<?php

declare(strict_types=1);

namespace App\Controllers;

use App\Database;
use Doctrine\DBAL\Connection;
use Firebase\JWT\JWT; // Importa la libreria JWT
use Firebase\JWT\Key;  // Importa Key per la verifica

class AuthController
{
    private Connection $db;
    private string $jwtSecret;
    private int $jwtExpiration;

    public function __construct()
    {
        try {
            $this->db = Database::getConnection();
            // Leggi la configurazione JWT da .env
            $this->jwtSecret = $_ENV['JWT_SECRET'] ?? 'default-secret-change-me'; // Usa un default se non impostato
            $this->jwtExpiration = (int)($_ENV['JWT_EXPIRATION_TIME'] ?? 3600); // Default 1 ora
        } catch (\Throwable $e) {
            error_log("Failed to get DB connection or JWT config in AuthController: " . $e->getMessage());
            http_response_code(500);
            echo json_encode(['error' => 'Internal Server Error - Config']);
            exit;
        }
    }

    /**
     * Gestisce il login dell'utente.
     * POST /api/login
     */
    public function login(): void
    {
        // Prova a leggere JSON, fallback a POST
        $input = json_decode(file_get_contents('php://input'), true);
        if (json_last_error() !== JSON_ERROR_NONE || !is_array($input)) {
            $input = $_POST; // Fallback a POST se JSON non valido o vuoto
        }
         if (!is_array($input)) { // Se ancora non è un array, errore
             http_response_code(400); echo json_encode(['error' => 'Invalid input']); return;
        }

        $email = $input['email'] ?? null;
        $password = $input['password'] ?? null;

        if (!$email || !$password) {
            http_response_code(400);
            echo json_encode(['error' => 'Email and password are required']);
            return;
        }

        try {
            // Trova l'utente per email
            $user = $this->db->fetchAssociative('SELECT id, name, email, password, role, structure_id, is_active FROM users WHERE email = ?', [$email]);

            // Verifica utente e password
            if ($user === false || !password_verify($password, $user['password'])) {
                http_response_code(401); // Unauthorized
                echo json_encode(['error' => 'Invalid credentials']);
                return;
            }

            // Verifica se l'utente è attivo
             if (!$user['is_active']) {
                http_response_code(403); // Forbidden
                echo json_encode(['error' => 'User account is inactive']);
                return;
            }

            // Genera il token JWT
            $issuedAt = time();
            $expirationTime = $issuedAt + $this->jwtExpiration;
            $payload = [
                'iat' => $issuedAt,             // Issued at: time when the token was generated
                'exp' => $expirationTime,       // Expiration time
                'sub' => $user['id'],           // Subject: user ID
                'data' => [                     // Dati aggiuntivi (payload)
                    'name' => $user['name'],
                    'email' => $user['email'],
                    'role' => $user['role'],
                    'structure_id' => $user['structure_id']
                ]
            ];

            $jwt = JWT::encode($payload, $this->jwtSecret, 'HS256');

            // Restituisci il token e magari alcuni dati utente
            http_response_code(200);
            echo json_encode([
                'message' => 'Login successful',
                'access_token' => $jwt,
                'token_type' => 'Bearer',
                'expires_in' => $this->jwtExpiration,
                'user' => [ // Invia dati utente non sensibili
                     'id' => $user['id'],
                     'name' => $user['name'],
                     'email' => $user['email'],
                     'role' => $user['role'],
                     'structure_id' => $user['structure_id']
                ]
            ]);

        } catch (\Throwable $e) {
            http_response_code(500);
            error_log("Login error: " . $e->getMessage());
            echo json_encode(['error' => 'Login failed']);
        }
    }

     /**
     * Restituisce i dati dell'utente autenticato.
     * GET /api/me (Richiede token valido)
     */
     // Questo metodo verrà chiamato DOPO che un middleware/guardia ha verificato il token
     // e potenzialmente aggiunto i dati utente alla richiesta (o a un contesto).
     // Per ora, assumiamo che $userData sia disponibile dopo la verifica del token.
    public function me(array $userData = []): void // $userData verrà iniettato dalla guardia/middleware
    {
         if (empty($userData)) {
              http_response_code(401);
              echo json_encode(['error' => 'Not authenticated']);
              return;
         }
         // Restituisce i dati utente estratti dal token (o recuperati dal DB usando l'ID)
         http_response_code(200);
         echo json_encode($userData); // $userData contiene già i dati dal payload del token
    }


    // TODO: Implementare register() se necessario, con password_hash()
    // TODO: Implementare refresh() per rinnovare il token se necessario

}