// app/Http/Controllers/Admin/MediaController.php
use Intervention\Image\ImageManager;
use Intervention\Image\Drivers\Gd\Driver;

class MediaController extends Controller
{
    public function uploadImage(Request $request)
    {
        $request->validate([
            'image' => 'required|image|max:5120' // 5MB max
        ]);

        $file = $request->file('image');
        $manager = new ImageManager(new Driver());
        
        // Create different sizes
        $sizes = [
            'original' => ['width' => 1920, 'quality' => 85],
            'large' => ['width' => 1200, 'quality' => 80],
            'medium' => ['width' => 800, 'quality' => 75],
            'small' => ['width' => 400, 'quality' => 70],
            'thumbnail' => ['width' => 150, 'quality' => 65]
        ];

        $filename = Str::random(40);
        $savedFiles = [];

        foreach ($sizes as $sizeName => $config) {
            $image = $manager->read($file->getPathname());
            
            // Resize maintaining aspect ratio
            $image->scaleDown(width: $config['width']);
            
            // Convert to WebP for better compression
            $webpFilename = "{$filename}_{$sizeName}.webp";
            $webpPath = storage_path("app/public/images/{$webpFilename}");
            
            $image->toWebp($config['quality'])->save($webpPath);
            
            // Fallback JPEG
            $jpegFilename = "{$filename}_{$sizeName}.jpg";
            $jpegPath = storage_path("app/public/images/{$jpegFilename}");
            
            $image->toJpeg($config['quality'])->save($jpegPath);
            
            $savedFiles[$sizeName] = [
                'webp' => "images/{$webpFilename}",
                'jpeg' => "images/{$jpegFilename}"
            ];
        }

        return response()->json([
            'success' => true,
            'files' => $savedFiles
        ]);
    }
}

// app/View/Components/CriticalCss.php
class CriticalCss extends Component
{
    public function render()
    {
        $criticalCss = $this->extractCriticalCss();
        
        return view('components.critical-css', [
            'criticalCss' => $criticalCss
        ]);
    }
    
    private function extractCriticalCss()
    {
        // Extract critical CSS for above-the-fold content
        $criticalStyles = [
            // Header styles
            '.header { background: #1f2937; color: white; }',
            '.logo { height: 60px; }',
            // Navigation styles
            '.nav-link { color: white; padding: 1rem; }',
            // Hero section styles
            '.hero { background: linear-gradient(...); min-height: 50vh; }',
            // Layout styles
            '.container { max-width: 1200px; margin: 0 auto; }',
        ];
        
        return implode("\n", $criticalStyles);
    }
}

// ❌ Bad - N+1 queries
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->category->name; // N+1 query problem
    echo $post->user->name;
}

// ✅ Good - Eager loading
$posts = Post::with(['category', 'user'])->get();
foreach ($posts as $post) {
    echo $post->category->name;
    echo $post->user->name;
}

// ✅ Better - Selective eager loading
$posts = Post::with(['category:id,name', 'user:id,name'])
    ->select('id', 'title', 'category_id', 'user_id', 'created_at')
    ->get();

// ✅ Best - Chunking for large datasets
Post::with(['category', 'user'])
    ->chunk(100, function ($posts) {
        foreach ($posts as $post) {
            // Process post
        }
    });

// High-performance post listing
class PostRepository
{
    public function getOptimizedPosts($page = 1, $perPage = 12)
    {
        return DB::table('posts as p')
            ->select([
                'p.id',
                'p.title',
                'p.slug',
                'p.excerpt',
                'p.featured_image',
                'p.published_at',
                'p.views',
                'c.name as category_name',
                'c.slug as category_slug',
                'u.name as author_name'
            ])
            ->join('categories as c', 'p.category_id', '=', 'c.id')
            ->join('users as u', 'p.user_id', '=', 'u.id')
            ->where('p.status', 'published')
            ->where('p.published_at', '<=', now())
            ->orderBy('p.published_at', 'desc')
            ->offset(($page - 1) * $perPage)
            ->limit($perPage)
            ->get();
    }
    
    public function getPopularPosts($limit = 5)
    {
        return Cache::remember('popular_posts', 3600, function () use ($limit) {
            return DB::table('posts')
                ->select('id', 'title', 'slug', 'views', 'featured_image')
                ->where('status', 'published')
                ->where('published_at', '>=', now()->subMonths(3))
                ->orderBy('views', 'desc')
                ->limit($limit)
                ->get();
        });
    }
}

// config/database.php - Redis optimization
'redis' => [
    'client' => env('REDIS_CLIENT', 'phpredis'),
    
    'options' => [
        'cluster' => env('REDIS_CLUSTER', 'redis'),
        'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_database_'),
    ],
    
    'default' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_DB', '0'),
        'read_write_timeout' => 60,
        'context' => [
            'auth' => env('REDIS_PASSWORD'),
        ],
    ],
    
    'cache' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_CACHE_DB', '1'),
    ],
];

// app/Services/CacheService.php
class CacheService
{
    const CACHE_TTL = [
        'posts' => 3600,        // 1 hour
        'pages' => 7200,        // 2 hours
        'categories' => 86400,  // 24 hours
        'settings' => 86400,    // 24 hours
        'gallery' => 1800,      // 30 minutes
        'stats' => 300,         // 5 minutes
    ];
    
    public function rememberPosts($key, $callback, $ttl = null)
    {
        $ttl = $ttl ?? self::CACHE_TTL['posts'];
        $cacheKey = "posts:{$key}";
        
        return Cache::remember($cacheKey, $ttl, $callback);
    }
    
    public function forgetPostsCache()
    {
        $pattern = "posts:*";
        $keys = Redis::keys($pattern);
        
        if (!empty($keys)) {
            Redis::del($keys);
        }
    }
    
    public function cacheHomepageData()
    {
        return Cache::remember('homepage_data', 1800, function () {
            return [
                'featured_posts' => Post::featured()->published()->limit(3)->get(),
                'latest_posts' => Post::published()->latest()->limit(6)->get(),
                'announcements' => Announcement::active()->limit(3)->get(),
                'village_stats' => VillageData::active()->orderBy('sort_order')->get(),
                'latest_gallery' => Gallery::active()->latest()->limit(8)->get(),
            ];
        });
    }
    
    public function warmupCache()
    {
        // Preload frequently accessed data
        $this->cacheHomepageData();
        
        Cache::remember('categories_menu', 86400, function () {
            return Category::active()->orderBy('sort_order')->get();
        });
        
        Cache::remember('site_settings', 86400, function () {
            return Setting::pluck('value', 'key')->toArray();
        });
    }
}

// app/Http/Middleware/PerformanceMonitor.php
class PerformanceMonitor
{
    public function handle($request, Closure $next)
    {
        $startTime = microtime(true);
        $startMemory = memory_get_usage(true);
        
        $response = $next($request);
        
        $endTime = microtime(true);
        $endMemory = memory_get_usage(true);
        
        $duration = round(($endTime - $startTime) * 1000, 2); // ms
        $memoryUsed = round(($endMemory - $startMemory) / 1024 / 1024, 2); // MB
        
        // Log slow requests
        if ($duration > 1000) { // > 1 second
            Log::warning('Slow request detected', [
                'url' => $request->fullUrl(),
                'method' => $request->method(),
                'duration' => $duration . 'ms',
                'memory' => $memoryUsed . 'MB',
                'user_id' => auth()->id(),
                'ip' => $request->ip()
            ]);
        }
        
        // Add performance headers (development only)
        if (config('app.debug')) {
            $response->headers->add([
                'X-Response-Time' => $duration . 'ms',
                'X-Memory-Usage' => $memoryUsed . 'MB',
                'X-DB-Queries' => DB::getQueryLog() ? count(DB::getQueryLog()) : 0
            ]);
        }
        
        return $response;
    }
}

// app/Http/Controllers/Admin/PerformanceController.php
class PerformanceController extends Controller
{
    public function dashboard()
    {
        $metrics = $this->getPerformanceMetrics();
        return view('admin.performance.dashboard', compact('metrics'));
    }
    
    private function getPerformanceMetrics()
    {
        $lastWeek = now()->subWeek();
        
        return [
            'avg_response_time' => DB::table('performance_logs')
                ->where('created_at', '>', $lastWeek)
                ->avg('response_time'),
                
            'slow_queries' => DB::table('performance_logs')
                ->where('created_at', '>', $lastWeek)
                ->where('response_time', '>', 1000)
                ->count(),
                
            'error_rate' => DB::table('performance_logs')
                ->where('created_at', '>', $lastWeek)
                ->where('status_code', '>=', 400)
                ->count() / DB::table('performance_logs')->where('created_at', '>', $lastWeek)->count() * 100,
                
            'top_slow_pages' => DB::table('performance_logs')
                ->select('url', DB::raw('AVG(response_time) as avg_time'), DB::raw('COUNT(*) as requests'))
                ->where('created_at', '>', $lastWeek)
                ->groupBy('url')
                ->orderBy('avg_time', 'desc')
                ->limit(10)
                ->get(),
        ];
    }
}