<?php
    namespace Zampet\Module\Auth\v0\Controllers;

    use Zampet\Helpers\Sanitizer;
    use Zampet\Services\JWTService;
    use AxiumPHP\Helpers\RequestHelper;
    use Zampet\Module\Auth\v0\DTO\UsuarioDTO;
    use Zampet\Module\Auth\v0\Services\AuthService;

    class AuthController {
        /**
         * Lida com a requisição de registro (criação) de um novo usuário.
         *
         * Este método atua como um **controlador** para o endpoint de registro. Ele recebe os dados do formulário, realiza uma validação de presença básica nos campos obrigatórios, sanitiza os dados e delega a lógica de negócio e persistência para o `AuthService`. A resposta final é formatada e enviada como JSON.
         *
         * #### Fluxo de Operação:
         * 1.  **Coleta de Dados:** Obtém os dados do formulário (`fullName`, `email`, `password`) via requisição POST.
         * 2.  **Validação de Presença:** Itera sobre os campos obrigatórios (`fullName`, `email`, `password`). Se qualquer um estiver vazio, o método envia uma resposta JSON com o código **400 Bad Request** e encerra a execução.
         * 3.  **Sanitização e DTO:** Os dados são sanitizados (string, email) e encapsulados em um **`UsuarioDTO`**.
         * 4.  **Delegação ao Serviço:** O método `register` do `AuthService` é chamado com o DTO. O serviço é responsável por validações de complexidade, checagem de duplicidade, criptografia de senha e persistência no banco de dados.
         * 5.  **Envio da Resposta JSON:** O resultado do serviço (`serviceResult`) é formatado e enviado de volta ao cliente. O código de resposta HTTP e o status JSON são extraídos do array retornado pelo serviço.
         *
         * @return void Este método não retorna um valor, pois seu objetivo é enviar uma resposta JSON e encerrar a execução do script.
         */
        public function register(): void {
            // Receber dados do formulário de registro
            $form = RequestHelper::getFilteredInput(form_type: INPUT_POST);

            // Dados Obrigatórios
            $required_fields = [
                'fullName', 
                'email',
                'cpf',
                'birthDate',
                'password'
            ];

            // Verificar se todos os campos obrigatórios estão presentes
            foreach ($required_fields as $field) {
                if (empty($form[$field])) {
                    RequestHelper::sendJsonResponse(
                        response_code: 400, 
                        status: 'error', 
                        message: "Field '{$field}' is required"
                    );
                    exit;
                }
            }

            // Chama o serviço de autenticação para registrar o usuário
            $serviceResult = (new AuthService())->register(usuarioDTO: 
                new UsuarioDTO(data: [
                    'nome_completo' => Sanitizer::string(value: $form['fullName']),
                    'email' => Sanitizer::email(value: $form['email']),
                    'senha' => Sanitizer::string(value: $form['password']),
                    'documentcpf' => Sanitizer::document(value: $form['cpf']),
                    'data_nascimento' => Sanitizer::string(value: $form['birthDate'])
                ])
            );

            // Enviar a resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $serviceResult['response_code'], 
                status: $serviceResult['status'], 
                message: $serviceResult['message'], 
                output: $serviceResult['output'] ?? []
            );
            exit;
        }

        /**
         * Lida com a requisição de login de um usuário via POST.
         *
         * Este método atua como um **controlador** para o endpoint de login. Ele processa as credenciais enviadas pelo usuário, realiza uma validação de presença básica e delega o processo de autenticação a um serviço. A resposta da autenticação é então formatada e enviada de volta ao cliente como um JSON.
         *
         * #### Fluxo de Operação:
         * 1.  **Coleta de Dados:** Obtém os dados do formulário (`email` e `password`) enviados via requisição POST.
         * 2.  **Validação de Presença:** Itera sobre os campos obrigatórios. Se qualquer 3campo estiver vazio, uma resposta JSON com o código **400 Bad Request** é enviada e a execução é encerrada.
         * 3.  **Delegação ao Serviço:** O método `login` do **`AuthService`** é chamado com o e-mail e a senha fornecidos. O serviço é responsável por toda a lógica de autenticação (busca, verificação de senha, revogação de tokens e geração de novo JWT).
         * 4.  **Envio da Resposta JSON:** O resultado do serviço (`serviceResult`) é formatado para uma resposta JSON padronizada usando **`RequestHelper::sendJsonResponse`**, incluindo o código HTTP, status, mensagem e os dados de saída (como o token JWT). A execução é encerrada.
         *
         * @return void Este método não retorna um valor, pois seu objetivo é enviar uma resposta JSON e encerrar a execução do script.
         */
        public function login(): void {
            // Receber dados do formulário de login
            $form = RequestHelper::getFilteredInput(form_type: INPUT_POST);

            // Dados Obrigatórios
            $required_fields = [
                'email', 
                'password'
            ];

            // Verificar se todos os campos obrigatórios estão presentes
            foreach ($required_fields as $field) {
                if (empty($form[$field])) {
                    RequestHelper::sendJsonResponse(
                        response_code: 400, 
                        status: 'error', 
                        message: "Field '{$field}' is required"
                    );
                    exit;
                }
            }

            // Chamar o serviço de autenticação para fazer login
            $serviceResult = (new AuthService())->login(email: $form['email'], password: $form['password']);

            // Enviar a resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $serviceResult['response_code'], 
                status: $serviceResult['status'], 
                message: $serviceResult['message'], 
                output: $serviceResult['output'] ?? []
            );
            exit;
        }

        /**
         * Lida com a requisição de logout, revogando o token de autenticação do usuário.
         *
         * Este método atua como um **controlador** para o endpoint de logout. Ele extrai o token JWT do cabeçalho da requisição, delega a lógica de revogação para a camada de serviço e envia uma resposta JSON formatada de volta ao cliente.
         *
         * #### Fluxo de Operação:
         * 1.  **Obtenção do Token:** O token Bearer é extraído do cabeçalho da requisição usando `JWTService::getBearerToken()`.
         * 2.  **Delegação ao Serviço:** O método `logout` do **`AuthService`** é chamado com o token. O serviço é responsável por revogar o token no banco de dados e gerenciar a transação.
         * 3.  **Envio da Resposta JSON:** O resultado da operação do serviço (`serviceResult`) é formatado para uma resposta JSON padronizada usando **`RequestHelper::sendJsonResponse`**, garantindo que o código HTTP, status, mensagem e quaisquer dados de saída sejam comunicados ao cliente.
         *
         * @return void Este método não retorna um valor, pois seu objetivo é enviar uma resposta JSON e encerrar a execução do script.
         */
        public function logout(): void {
            // Chamar o serviço de autenticação para fazer logout
            $serviceResult = (new AuthService())->logout(token: JWTService::getBearerToken());

            // Enviar a resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $serviceResult['response_code'], 
                status: $serviceResult['status'], 
                message: $serviceResult['message'], 
                output: $serviceResult['output'] ?? []
            );
            exit;
        }

        public function getUserData(): void {
            // Chamar o serviço de autenticação para obter os dados do usuário
            $serviceResult = (new AuthService())->getUserData(token: JWTService::getBearerToken());

            // Enviar a resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $serviceResult['response_code'], 
                status: $serviceResult['status'], 
                message: $serviceResult['message'], 
                output: $serviceResult['output'] ?? []
            );
            exit;
        }
    }