<?php

namespace App\Controllers\Api;

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use App\Models\Game;
use App\Models\Movie;
use App\Models\TvShow;
use App\Models\MusicArtist;
use App\Controllers\Api\ApiController;

class MediaController extends ApiController
{
    private $gameModel;
    private $movieModel;
    private $tvShowModel;
    private $musicArtistModel;

    public function __construct(\PDO $pdo)
    {
        $this->gameModel = new Game($pdo);
        $this->movieModel = new Movie($pdo);
        $this->tvShowModel = new TvShow($pdo);
        $this->musicArtistModel = new MusicArtist($pdo);
    }

    // List all games with pagination
    public function listGames(Request $request, Response $response): Response
    {
        try {
            $pagination = $this->getPaginationParams($request);
            $filters = $this->getFiltersFromRequest($request);
            
            $games = $this->gameModel->findAll(
                $filters,
                $pagination['per_page'],
                $pagination['offset']
            );

            $total = $this->gameModel->count($filters);

            return $this->success($response, [
                'items' => $games,
                'pagination' => [
                    'total' => $total,
                    'per_page' => $pagination['per_page'],
                    'current_page' => $pagination['page'],
                    'last_page' => ceil($total / $pagination['per_page'])
                ]
            ]);
        } catch (\Exception $e) {
            return $this->error($response, 'Failed to fetch games', 500);
        }
    }

    // Get single game by ID
    public function getGame(Request $request, Response $response, array $args): Response
    {
        try {
            $id = (int)($args['id'] ?? 0);
            if (!$id) {
                return $this->error($response, 'Invalid game ID', 400);
            }

            $game = $this->gameModel->find($id);
            if (!$game) {
                return $this->error($response, 'Game not found', 404);
            }

            return $this->success($response, $game);
        } catch (\Exception $e) {
            return $this->error($response, 'Failed to fetch game', 500);
        }
    }

    // Search across all media
    public function search(Request $request, Response $response): Response
    {
        try {
            $query = $request->getQueryParams()['q'] ?? '';
            $type = $request->getQueryParams()['type'] ?? 'all';
            $pagination = $this->getPaginationParams($request);
            
            $results = [];
            
            if ($type === 'all' || $type === 'game') {
                $results['games'] = $this->searchGames($query, $pagination);
            }
            
            if ($type === 'all' || $type === 'movie') {
                $results['movies'] = $this->searchMovies($query, $pagination);
            }
            
            if ($type === 'all' || $type === 'tvshow') {
                $results['tvshows'] = $this->searchTvShows($query, $pagination);
            }
            
            if ($type === 'all' || $type === 'music') {
                $results['artists'] = $this->searchArtists($query, $pagination);
            }

            return $this->success($response, $results);
        } catch (\Exception $e) {
            return $this->error($response, 'Search failed: ' . $e->getMessage(), 500);
        }
    }

    // Helper methods for searching different media types
    private function searchGames(string $query, array $pagination): array
    {
        try {
            // First try to use the model's search method if it exists
            if (method_exists($this->gameModel, 'search')) {
                $games = $this->gameModel->search($query, $pagination['per_page'], $pagination['offset']);
                $total = method_exists($this->gameModel, 'countSearchResults') 
                    ? $this->gameModel->countSearchResults($query)
                    : count($games);
            } 
            // Fallback to basic filtering if search method doesn't exist
            else {
                $allGames = $this->gameModel->findAll();
                $filtered = array_filter($allGames, function($game) use ($query) {
                    return stripos($game['title'] ?? '', $query) !== false;
                });
                
                // Apply pagination
                $games = array_slice($filtered, $pagination['offset'], $pagination['per_page']);
                $total = count($filtered);
            }
        
            return [
                'items' => $games,
                'total' => $total,
                'page' => $pagination['page'],
                'per_page' => $pagination['per_page']
            ];
        } catch (\Exception $e) {
            // If anything goes wrong, return empty results
            return [
                'items' => [],
                'total' => 0,
                'page' => $pagination['page'],
                'per_page' => $pagination['per_page'],
                'error' => $e->getMessage()
            ];
        }
    }

    private function searchMovies(string $query, array $pagination): array
    {
        // Implement movie search logic
        return [
            'items' => [],
            'total' => 0
        ];
    }

    private function searchTvShows(string $query, array $pagination): array
    {
        // Implement TV show search logic
        return [
            'items' => [],
            'total' => 0
        ];
    }

    private function searchArtists(string $query, array $pagination): array
    {
        // Implement artist search logic
        return [
            'items' => [],
            'total' => 0
        ];
    }

    // Extract filters from request
    private function getFiltersFromRequest(Request $request): array
    {
        $filters = [];
        $queryParams = $request->getQueryParams();
        
        // Add common filters
        if (!empty($queryParams['genre'])) {
            $filters['genre'] = $queryParams['genre'];
        }
        
        if (!empty($queryParams['year'])) {
            $filters['year'] = (int)$queryParams['year'];
        }
        
        // Add more filters as needed
        
        return $filters;
    }
}