<?php

use App\Models\Notification;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

/**
 * Send notification to users based on notification code and role mapping
 * 
 * Performance optimizations:
 * - Single query to get target roles from settings
 * - Bulk insert for notifications (one query for all users)
 * - Uses whereIn for efficient user filtering
 * - Chunked inserts (500 per chunk) to avoid max packet size issues
 * 
 * Note: Direct execution is fast enough (1-2 seconds for typical 10-50 users)
 * Queue integration was removed to avoid unnecessary complexity and worker dependency.
 * 
 * @param string $notificationCode Notification code from catalog
 * @param string $message Notification message
 * @param string|null $link Optional link for notification
 * @param string|null $title Optional custom title (if null, uses default from code)
 * @param array|null $filterParams Optional filter parameters for filtered list view
 * @param int $itemCount Item count for batch notifications (default: 1)
 * @return int Number of notifications created
 */
function sendNotification($notificationCode, $message, $link = null, $title = null, $filterParams = null, $itemCount = 1) {
    try {
        // Get target roles from settings
        $targetRoles = j(setting($notificationCode));
        
        // If no roles defined or empty, log warning and return early
        if (!is_array($targetRoles) || empty($targetRoles)) {
            Log::warning("Notification not sent: No roles defined in settings", [
                'notification_code' => $notificationCode,
                'message' => $message,
                'title' => $title,
            ]);
            return 0;
        }
        
        // Get active users with target roles in single query
        // Performance: Uses whereIn for efficient filtering
        $users = DB::table('users')
            ->select('id', 'level', 'name', 'email')
            ->whereIn('level', $targetRoles)
            ->whereNotNull('level') // Ensure level is not null
            ->get();
        
        // Remove level, name, email from selection after logging (we only need id for insert)
        $userIds = $users->pluck('id');
        
        // Debug: Log all users found
        Log::info("Notification target users found", [
            'notification_code' => $notificationCode,
            'target_roles' => $targetRoles,
            'users_count' => $users->count(),
            'user_ids' => $users->pluck('id')->toArray(),
            'user_levels' => $users->pluck('level')->toArray(),
        ]);
        
        // If no users found, log warning and return early
        if ($users->isEmpty()) {
            // Debug: Check what users exist with these levels
            $allUsersWithLevels = DB::table('users')
                ->select('id', 'level', 'name', 'email')
                ->whereNotNull('level')
                ->get()
                ->groupBy('level');
            
            Log::warning("Notification not sent: No users found with target roles", [
                'notification_code' => $notificationCode,
                'target_roles' => $targetRoles,
                'message' => $message,
                'available_levels' => $allUsersWithLevels->keys()->toArray(),
                'users_by_level' => $allUsersWithLevels->map(function($group) {
                    return $group->pluck('id')->toArray();
                })->toArray(),
            ]);
            return 0;
        }
        
        // Generate title if not provided
        if ($title === null) {
            $title = ucwords(str_replace('_', ' ', $notificationCode));
        }
        
        // If filterParams provided, generate link to filtered list page
        // We'll update link after insert with notification ID
        $useFilteredList = !empty($filterParams);
        if ($useFilteredList && $link === null) {
            $link = '/admin/notifications/filtered-list'; // Will be updated with notification ID after insert
        }
        
        // Prepare bulk insert data
        // Performance: Single insert query for all notifications
        $now = now();
        $notificationsData = [];
        
        foreach ($userIds as $userId) {
            $notificationsData[] = [
                'user_id' => $userId,
                'notification_code' => $notificationCode,
                'title' => $title,
                'message' => $message,
                'link' => $link,
                'is_read' => false,
                'filter_params' => $filterParams ? json_encode($filterParams) : null,
                'item_count' => $itemCount,
                'notification_type' => $filterParams ? 'batch' : 'single',
                'created_at' => $now,
                'updated_at' => $now,
            ];
        }
        
        // Bulk insert notifications
        // Performance: One query instead of N queries
        if (!empty($notificationsData)) {
            // Split into chunks to avoid max packet size issues
            $chunks = array_chunk($notificationsData, 500);
            $totalInserted = 0;
            
            foreach ($chunks as $chunk) {
                // If using filtered list, we need to update links with notification IDs after insert
                if ($useFilteredList) {
                    $ids = [];
                    foreach ($chunk as $data) {
                        $id = DB::table('notifications')->insertGetId($data);
                        $ids[] = $id;
                    }
                    // Update links with notification IDs
                    foreach ($ids as $id) {
                        DB::table('notifications')
                            ->where('id', $id)
                            ->update(['link' => '/admin/notifications/filtered-list?id=' . $id]);
                    }
                    $totalInserted += count($chunk);
                } else {
                    DB::table('notifications')->insert($chunk);
                    $totalInserted += count($chunk);
                }
            }
            
            return $totalInserted;
        }
        
        return 0;
        
    } catch (\Exception $e) {
        // Log error but don't break the main flow
        Log::error('Notification send error: ' . $e->getMessage(), [
            'code' => $notificationCode,
            'message' => $message,
        ]);
        
        return 0;
    }
}

/**
 * Helper: Send batch notification with filter params and count-based message
 *
 * @param string $notificationCode
 * @param string $title
 * @param string $messageTemplate String with %d placeholder for count
 * @param array $filterParams
 * @param int $count
 * @return int
 */
function sendBatchNotificationWithFilter($notificationCode, $title, $messageTemplate, array $filterParams, int $count)
{
    $count = (int) $count;
    if ($count <= 0) {
        return 0;
    }
    
    $message = $messageTemplate ? sprintf($messageTemplate, $count) : sprintf('%d record(s) require attention.', $count);
    return sendNotification($notificationCode, $message, null, $title, $filterParams, $count);
}

/**
 * Send notification to specific users (by user IDs)
 * Performance: Bulk insert for multiple users
 * 
 * @param array $userIds Array of user IDs
 * @param string $notificationCode Notification code
 * @param string $message Notification message
 * @param string|null $link Optional link
 * @param string|null $title Optional title
 * @return int Number of notifications created
 */
function sendNotificationToUsers($userIds, $notificationCode, $message, $link = null, $title = null) {
    try {
        if (empty($userIds)) {
            return 0;
        }
        
        // Generate title if not provided
        if ($title === null) {
            $title = ucwords(str_replace('_', ' ', $notificationCode));
        }
        
        // Prepare bulk insert data
        $now = now();
        $notificationsData = [];
        
        foreach ($userIds as $userId) {
            $notificationsData[] = [
                'user_id' => $userId,
                'notification_code' => $notificationCode,
                'title' => $title,
                'message' => $message,
                'link' => $link,
                'is_read' => false,
                'created_at' => $now,
                'updated_at' => $now,
            ];
        }
        
        // Bulk insert
        if (!empty($notificationsData)) {
            $chunks = array_chunk($notificationsData, 500);
            $totalInserted = 0;
            
            foreach ($chunks as $chunk) {
                DB::table('notifications')->insert($chunk);
                $totalInserted += count($chunk);
            }
            
            return $totalInserted;
        }
        
        return 0;
        
    } catch (\Exception $e) {
        Log::error('Notification send error (specific users): ' . $e->getMessage());
        return 0;
    }
}

/**
 * Send notification to single user
 * Performance: Single insert query
 * 
 * @param int $userId User ID
 * @param string $notificationCode Notification code
 * @param string $message Notification message
 * @param string|null $link Optional link
 * @param string|null $title Optional title
 * @return bool Success status
 */
function sendNotificationToUser($userId, $notificationCode, $message, $link = null, $title = null) {
    try {
        if ($title === null) {
            $title = ucwords(str_replace('_', ' ', $notificationCode));
        }
        
        Notification::create([
            'user_id' => $userId,
            'notification_code' => $notificationCode,
            'title' => $title,
            'message' => $message,
            'link' => $link,
            'is_read' => false,
        ]);
        
        return true;
        
    } catch (\Exception $e) {
        Log::error('Notification send error (single user): ' . $e->getMessage());
        return false;
    }
}

/**
 * Clean up old notifications
 * Performance: Bulk delete query with date filter
 * 
 * @param int $days Number of days to keep (default: 90)
 * @return int Number of deleted notifications
 */
function cleanupOldNotifications($days = 90) {
    try {
        return Notification::deleteOldNotifications($days);
    } catch (\Exception $e) {
        Log::error('Notification cleanup error: ' . $e->getMessage());
        return 0;
    }
}

/**
 * Copy existing notifications to new users based on their level
 * DISABLED: This function was causing duplicate notifications and system issues
 * 
 * @param string $notificationCode Notification code to copy
 * @return int Always returns 0 (disabled)
 */
function copyNotificationsToNewUsers($notificationCode) {
    // DISABLED: This function was causing excessive duplicate notifications
    // All calls to this function should be removed from notification check commands
    return 0;
}

/**
 * Normalize filter_params for comparison
 * 
 * @param mixed $filterParams
 * @return string
 */
function normalizeFilterParams($filterParams): string
{
    if (empty($filterParams)) {
        return '';
    }
    
    $decoded = is_string($filterParams) 
        ? json_decode($filterParams, true) 
        : $filterParams;
    
    if ($decoded === null || !is_array($decoded)) {
        return '';
    }
    
    ksort($decoded);
    return json_encode($decoded, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
}

/**
 * Clean up duplicate notifications by notification_code + user_id + filter_params
 * This is more aggressive and handles cases where same notification_code is sent multiple times
 * Uses direct SQL queries with minimal memory usage
 * 
 * @return array{total_deleted: int, notifications_before: int, notifications_after: int, error?: string}
 */
function cleanupDuplicateNotificationsByCode(): array
{
    try {
        $stats = [
            'total_deleted' => 0,
            'notifications_before' => 0,
            'notifications_after' => 0,
        ];
        
        $stats['notifications_before'] = DB::table('notifications')->count();
        
        // Process in very small batches to avoid memory issues
        $batchSize = 10; // Process 10 users at a time
        $totalDeleted = 0;
        $usersAffected = [];
        
        // Get all notification codes one by one
        $notificationCodes = DB::table('notifications')
            ->select('notification_code')
            ->distinct()
            ->pluck('notification_code');
        
        foreach ($notificationCodes as $notificationCode) {
            // Get user IDs for this code in batches
            $offset = 0;
            while (true) {
                $userIds = DB::table('notifications')
                    ->where('notification_code', $notificationCode)
                    ->select('user_id')
                    ->distinct()
                    ->offset($offset)
                    ->limit($batchSize)
                    ->pluck('user_id');
                
                if ($userIds->isEmpty()) {
                    break;
                }
                
                foreach ($userIds as $userId) {
                    // Get notification IDs for this code + user, ordered by created_at desc
                    // Process in small chunks
                    $notificationOffset = 0;
                    $notificationLimit = 100;
                    $seenFilterParams = [];
                    $idsToDelete = [];
                    
                    while (true) {
                        $notifications = DB::table('notifications')
                            ->where('notification_code', $notificationCode)
                            ->where('user_id', $userId)
                            ->select('id', 'filter_params', 'created_at')
                            ->orderBy('created_at', 'desc')
                            ->offset($notificationOffset)
                            ->limit($notificationLimit)
                            ->get();
                        
                        if ($notifications->isEmpty()) {
                            break;
                        }
                        
                        foreach ($notifications as $notification) {
                            // Normalize filter_params
                            $filterParams = normalizeFilterParams($notification->filter_params);
                            
                            // If we've seen this filter_params before, it's a duplicate
                            if (isset($seenFilterParams[$filterParams])) {
                                $idsToDelete[] = $notification->id;
                            } else {
                                // First occurrence - keep it
                                $seenFilterParams[$filterParams] = true;
                            }
                        }
                        
                        $notificationOffset += $notificationLimit;
                        
                        // If we got less than limit, we're done
                        if ($notifications->count() < $notificationLimit) {
                            break;
                        }
                    }
                    
                    // Delete duplicates for this user
                    if (!empty($idsToDelete)) {
                        $deleteChunks = array_chunk($idsToDelete, 500);
                        foreach ($deleteChunks as $chunk) {
                            $deleted = DB::table('notifications')->whereIn('id', $chunk)->delete();
                            $totalDeleted += $deleted;
                        }
                        
                        if (!in_array($userId, $usersAffected)) {
                            $usersAffected[] = $userId;
                        }
                    }
                    
                    // Free memory
                    unset($notifications, $idsToDelete, $seenFilterParams);
                }
                
                $offset += $batchSize;
            }
        }
        
        // Clear cache for affected users
        foreach ($usersAffected as $userId) {
            Cache::forget("user_notifications_{$userId}");
            Cache::forget("user_unread_type_count_{$userId}");
        }
        
        $stats['total_deleted'] = $totalDeleted;
        $stats['notifications_after'] = DB::table('notifications')->count();
        
        Log::info('Duplicate notifications cleanup by code completed', $stats);
        
        return $stats;
        
    } catch (\Exception $e) {
        Log::error('Error cleaning up duplicate notifications by code: ' . $e->getMessage());
        return [
            'error' => $e->getMessage(),
            'total_deleted' => 0,
        ];
    }
}

/**
 * Clean up duplicate notifications
 * Removes duplicate notifications keeping only the most recent one for each user
 * Duplicates are identified by: user_id + message + link + normalized filter_params
 * 
 * Performance: Uses SQL-based approach with chunking to avoid memory issues
 * 
 * @return array{total_deleted: int, users_affected: int, notifications_before: int, notifications_after: int, error?: string}
 */
function cleanupDuplicateNotifications(): array
{
    try {
        $stats = [
            'total_deleted' => 0,
            'users_affected' => 0,
            'notifications_before' => 0,
            'notifications_after' => 0,
        ];
        
        // Get total count before cleanup
        $stats['notifications_before'] = DB::table('notifications')->count();
        
        // Process one user at a time to minimize memory usage
        $userIds = DB::table('notifications')
            ->select('user_id')
            ->distinct()
            ->pluck('user_id');
        
        $usersAffected = [];
        $totalDeleted = 0;
        
        foreach ($userIds as $userId) {
            // Get notifications for this user, ordered by created_at desc (newest first)
            // Process in smaller chunks to avoid memory issues
            $offset = 0;
            $limit = 500;
            $userHasDuplicates = false;
            $seen = [];
            $idsToDelete = [];
            
            while (true) {
                $notifications = DB::table('notifications')
                    ->where('user_id', $userId)
                    ->select('id', 'message', 'link', 'filter_params', 'created_at')
                    ->orderBy('created_at', 'desc')
                    ->offset($offset)
                    ->limit($limit)
                    ->get();
                
                if ($notifications->isEmpty()) {
                    break;
                }
                
                foreach ($notifications as $notification) {
                    // Normalize filter_params
                    $filterParams = normalizeFilterParams($notification->filter_params);
                    
                    $key = $notification->message . '|' . ($notification->link ?? '') . '|' . $filterParams;
                    
                    // If we've seen this key before, it's a duplicate
                    if (isset($seen[$key])) {
                        $idsToDelete[] = $notification->id;
                        $userHasDuplicates = true;
                    } else {
                        // First occurrence - keep it
                        $seen[$key] = true;
                    }
                }
                
                $offset += $limit;
                
                // If we got less than limit, we're done with this user
                if ($notifications->count() < $limit) {
                    break;
                }
            }
            
            // Delete duplicates for this user
            if (!empty($idsToDelete)) {
                $deleteChunks = array_chunk($idsToDelete, 500);
                foreach ($deleteChunks as $chunk) {
                    $deleted = DB::table('notifications')->whereIn('id', $chunk)->delete();
                    $totalDeleted += $deleted;
                }
                
                if ($userHasDuplicates) {
                    $usersAffected[] = $userId;
                    // Clear cache for this user
                    Cache::forget("user_notifications_{$userId}");
                    Cache::forget("user_unread_type_count_{$userId}");
                }
            }
            
            // Free memory
            unset($notifications, $idsToDelete, $seen);
        }
        
        $stats['total_deleted'] = $totalDeleted;
        $stats['users_affected'] = count($usersAffected);
        
        // Get total count after cleanup
        $stats['notifications_after'] = DB::table('notifications')->count();
        
        Log::info('Duplicate notifications cleanup completed', $stats);
        
        return $stats;
        
    } catch (\Exception $e) {
        Log::error('Error cleaning up duplicate notifications: ' . $e->getMessage());
        return [
            'error' => $e->getMessage(),
            'total_deleted' => 0,
        ];
    }
}