<?php
require_once __DIR__ . '/../models/Species.php';
require_once __DIR__ . '/../middleware/AuthMiddleware.php';
require_once __DIR__ . '/../utils/Cache.php';

class SpeciesController {
    private $species;
    private $db;

    public function __construct($db) {
        $this->db = $db;
        $this->species = new Species($db);
    }

    // GET /species - Obtener todas las especies activas (cached)
    public function getAll() {
        try {
            $cacheKey = 'species_active_all';
            
            // Try to get from cache first (1 hour TTL)
            $species = Cache::get($cacheKey);
            $fromCache = true;
            
            if ($species === null) {
                $species = $this->species->read();
                // Cache with tags for easy invalidation (1 hour TTL)
                Cache::tag(['species'], $cacheKey, $species, 3600);
                $fromCache = false;
            }

            http_response_code(200);
            return json_encode([
                'success' => true,
                'data' => $species,
                'count' => count($species),
                'cached' => $fromCache
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al obtener especies: ' . $e->getMessage()
            ]);
        }
    }

    // GET /species/recommended - Obtener especies recomendadas para inventario
    public function getRecommended() {
        try {
            $cacheKey = 'species_recommended_inventory';
            
            // Try to get from cache first (2 hours TTL)
            $species = Cache::get($cacheKey);
            $fromCache = true;
            
            if ($species === null) {
                $species = $this->species->getRecommendedForInventory();
                // Cache with tags for easy invalidation (2 hours TTL)
                Cache::tag(['species'], $cacheKey, $species, 7200);
                $fromCache = false;
            }

            http_response_code(200);
            return json_encode([
                'success' => true,
                'data' => $species,
                'count' => count($species),
                'cached' => $fromCache
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al obtener especies recomendadas: ' . $e->getMessage()
            ]);
        }
    }

    // GET /species/search?q=term - Buscar especies
    public function search() {
        try {
            $searchTerm = $_GET['q'] ?? '';
            
            if (empty($searchTerm)) {
                http_response_code(400);
                return json_encode([
                    'success' => false,
                    'message' => 'Parámetro de búsqueda requerido'
                ]);
            }

            $stmt = $this->species->search($searchTerm);
            $species = $stmt->fetchAll(PDO::FETCH_ASSOC);

            http_response_code(200);
            return json_encode([
                'success' => true,
                'data' => $species,
                'count' => count($species),
                'search_term' => $searchTerm
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error en búsqueda de especies: ' . $e->getMessage()
            ]);
        }
    }

    // GET /species/most-used - Obtener especies más utilizadas (cached)
    public function getMostUsed() {
        try {
            $limit = $_GET['limit'] ?? 10;
            $species = $this->species->getMostUsedSpeciesCached($limit);

            http_response_code(200);
            return json_encode([
                'success' => true,
                'data' => $species,
                'count' => count($species),
                'cached' => true
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al obtener especies más utilizadas: ' . $e->getMessage()
            ]);
        }
    }

    // GET /species/stats - Obtener estadísticas de uso
    public function getStats() {
        try {
            $stats = $this->species->getUsageStats();

            http_response_code(200);
            return json_encode([
                'success' => true,
                'data' => $stats
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al obtener estadísticas: ' . $e->getMessage()
            ]);
        }
    }

    // POST /species/initialize - Inicializar catálogo de Guatemala (Admin only)
    public function initializeCatalog() {
        try {
            // Verificar permisos de administrador
            $user = AuthMiddleware::getCurrentUser();
            if (!$user || $user['rol'] !== 'Administrador') {
                http_response_code(403);
                return json_encode([
                    'success' => false,
                    'message' => 'Acceso denegado. Solo administradores pueden inicializar el catálogo.'
                ]);
            }

            $result = $this->species->initializeGuatemalaCatalog();

            http_response_code(200);
            return json_encode([
                'success' => true,
                'message' => 'Catálogo inicializado correctamente',
                'data' => $result
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al inicializar catálogo: ' . $e->getMessage()
            ]);
        }
    }

    // GET /species/{id} - Obtener especie específica
    public function getById($id) {
        try {
            if ($this->species->findById($id)) {
                http_response_code(200);
                return json_encode([
                    'success' => true,
                    'data' => [
                        'id' => $this->species->id,
                        'nombre_cientifico' => $this->species->nombre_cientifico,
                        'nombre_comun' => $this->species->nombre_comun,
                        'activa' => $this->species->activa,
                        'fecha_creacion' => $this->species->fecha_creacion
                    ]
                ]);
            } else {
                http_response_code(404);
                return json_encode([
                    'success' => false,
                    'message' => 'Especie no encontrada'
                ]);
            }
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al obtener especie: ' . $e->getMessage()
            ]);
        }
    }

    // POST /species - Crear nueva especie (Admin only)
    public function create() {
        try {
            // Verificar permisos de administrador
            $user = AuthMiddleware::getCurrentUser();
            if (!$user || $user['rol'] !== 'Administrador') {
                http_response_code(403);
                return json_encode([
                    'success' => false,
                    'message' => 'Acceso denegado. Solo administradores pueden crear especies.'
                ]);
            }

            $data = json_decode(file_get_contents("php://input"), true);

            if (!$data) {
                http_response_code(400);
                return json_encode([
                    'success' => false,
                    'message' => 'Datos JSON inválidos'
                ]);
            }

            $this->species->nombre_cientifico = $data['nombre_cientifico'] ?? '';
            $this->species->nombre_comun = $data['nombre_comun'] ?? '';
            $this->species->activa = $data['activa'] ?? true;

            // Validar datos
            $errors = $this->species->validate();
            if (!empty($errors)) {
                http_response_code(400);
                return json_encode([
                    'success' => false,
                    'message' => 'Datos inválidos',
                    'errors' => $errors
                ]);
            }

            // Verificar si ya existe
            if ($this->species->scientificNameExists($this->species->nombre_cientifico)) {
                http_response_code(409);
                return json_encode([
                    'success' => false,
                    'message' => 'Ya existe una especie con este nombre científico'
                ]);
            }

            if ($this->species->create()) {
                http_response_code(201);
                return json_encode([
                    'success' => true,
                    'message' => 'Especie creada exitosamente',
                    'data' => [
                        'id' => $this->species->id,
                        'nombre_cientifico' => $this->species->nombre_cientifico,
                        'nombre_comun' => $this->species->nombre_comun,
                        'activa' => $this->species->activa
                    ]
                ]);
            } else {
                http_response_code(500);
                return json_encode([
                    'success' => false,
                    'message' => 'Error al crear especie'
                ]);
            }
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al crear especie: ' . $e->getMessage()
            ]);
        }
    }

    // DELETE /species/cache - Clear species cache (Admin only)
    public function clearCache() {
        try {
            // Verificar permisos de administrador
            $user = AuthMiddleware::getCurrentUser();
            if (!$user || $user['rol'] !== 'Administrador') {
                http_response_code(403);
                return json_encode([
                    'success' => false,
                    'message' => 'Acceso denegado. Solo administradores pueden limpiar el cache.'
                ]);
            }

            require_once __DIR__ . '/../utils/Cache.php';
            
            // Clear specific species cache keys
            Cache::delete('species_active_all');
            Cache::delete('species_recommended_inventory');
            
            // Clear most used species cache for different limits
            for ($i = 5; $i <= 20; $i += 5) {
                Cache::delete("species_most_used_{$i}");
            }

            http_response_code(200);
            return json_encode([
                'success' => true,
                'message' => 'Cache de especies limpiado exitosamente'
            ]);
        } catch (Exception $e) {
            http_response_code(500);
            return json_encode([
                'success' => false,
                'message' => 'Error al limpiar cache: ' . $e->getMessage()
            ]);
        }
    }
}
?>