<?php
    namespace Workbloom\Component\Auth\v0\Controllers;

    use Workbloom\Services\JWTService;
    use AxiumPHP\Helpers\RequestHelper;
    use Workbloom\Helpers\DataSanitizer;
    use Workbloom\Component\Auth\v0\Services\AuthService;

    class AuthController {
        /**
         * Lida com a requisição de login de um usuário via POST.
         *
         * Este método atua como um **controlador** de API, processando as credenciais de login, realizando a validação de presença de campo e delegando a lógica complexa de autenticação, revogação/registro de token para a camada de serviço.
         *
         * #### Fluxo de Operação:
         * 1.  **Coleta e Validação de Presença:** Obtém os dados do formulário. Verifica se os campos **'login'** e **'password'** estão presentes. Se algum estiver ausente, envia um erro **400 Bad Request** e encerra a execução.
         * 2.  **Sanitização e Delegação:** Os dados são sanitizados e encapsulados em um array de credenciais. O método delega a lógica de autenticação (busca de usuário, `password_verify`, revogação de token antigo e registro de novo token) para o **`AuthService::login()`**.
         * 3.  **Envio da Resposta JSON:** O resultado retornado pelo serviço é formatado e enviado de volta ao cliente, comunicando o código HTTP, status e mensagem da operaçã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 login(): void {
            // Recebe formulário de login
            $form = RequestHelper::getFilteredInput(form_type: INPUT_POST);

            // Define campos obrigatórios
            $required_fields = [
                'login',
                'password'
            ];

            // Validação dos campos obrigatórios
            foreach ($required_fields as $field) {
                if (empty($form[$field])) {
                    // Resposta JSON de erro
                    RequestHelper::sendJsonResponse(
                        response_code: 400, 
                        status: 'error', 
                        message: "O campo '{$field}' é obrigatório", 
                        output: []
                    );
                    return;
                }
            }

            // Chama o serviço de autenticação
            $loginService = (new AuthService())->login(
                credentials: [
                    'login' => DataSanitizer::string(value: $form['login']),
                    'password' => DataSanitizer::string(value: $form['password'])
                ]
            );

            // Resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $loginService['response_code'] ?? 500, 
                status: $loginService['status'] ?? 'error', 
                message: $loginService['message'] ?? 'Internal server error', 
                output: $loginService['output'] ?? []
            );
        }

        /**
         * Lida com a requisição para listar os contextos de trabalho (empresas) disponíveis para o usuário autenticado.
         *
         * Este método atua como um **controlador** de API, extraindo o UUID e o status de root do usuário a partir do token JWT e delegando a lógica de busca de contextos para o `AuthService`.
         *
         * #### Fluxo de Operação:
         * 1.  **Obtenção e Decodificação do Token:** O token Bearer é obtido e decodificado via `JWTService`. Os dados essenciais do usuário, como `uuid` e `is_root`, são extraídos do payload.
         * 2.  **Delegação ao Serviço:** O método `listWorkContexts` do **`AuthService`** é chamado, passando o UUID do usuário e seu status de root. O serviço é responsável por consultar os contextos de trabalho (todas as empresas para usuários root ou apenas as associadas para usuários normais).
         * 3.  **Envio da Resposta JSON:** O resultado retornado pelo serviço (`workContexts`) é formatado para uma resposta JSON padronizada usando **`RequestHelper::sendJsonResponse`**. O código HTTP, status, mensagem e os dados dos contextos são 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 listWorkContexts(): void {
            // Receve o token Bearer da requisição
            $bearerToken = JWTService::decode(token: JWTService::getBearerToken());
            
            // Consulta os contextos de trabalho associados ao token
            $workContexts = (new AuthService())->listWorkContexts(usuario_uuid: $bearerToken['user_data']['uuid'], is_root: $bearerToken['user_data']['is_root']);

            // Resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $workContexts['response_code'] ?? 500,
                status: $workContexts['status'] ?? 'error',
                message: $workContexts['message'] ?? 'Internal server error',
                output: $workContexts['output'] ?? []
            );
        }

        /**
         * Lida com a requisição de seleção do contexto de trabalho (empresa) de um usuário.
         *
         * Este método atua como um **controlador** de API, responsável por:
         * 1.  **Extrair a Identidade:** Obtém e decodifica o token Bearer para identificar o usuário.
         * 2.  **Validação de Presença:** Verifica se o campo obrigatório `contexto_uuid` foi fornecido. Se estiver ausente, envia um erro **400 Bad Request** e encerra a execução.
         * 3.  **Delegação ao Serviço:** Delega a validação de acesso ao contexto, a revogação do token antigo e a geração do novo token atualizado (que inclui o contexto de trabalho) para o **`AuthService::selectWorkContext()`**.
         * 4.  **Envio da Resposta JSON:** O resultado retornado pelo serviço é formatado e enviado de volta ao cliente, comunicando o código HTTP, status, mensagem e o novo token JWT.
         *
         * @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 selectWorkContext(): void {
            // Receve o token Bearer da requisição
            $bearerToken = JWTService::decode(token: JWTService::getBearerToken());
            
            // Recebe formulário de seleção de contexto
            $form = RequestHelper::getFilteredInput(form_type: INPUT_POST);

            // Campos Obrigatórios
            $required_fields = [
                'contexto_uuid'
            ];

            // Validação dos campos obrigatórios
            foreach ($required_fields as $field) {
                if (empty($form[$field])) {
                    // Resposta JSON de erro
                    RequestHelper::sendJsonResponse(
                        response_code: 400, 
                        status: 'error', 
                        message: "O campo '{$field}' é obrigatório", 
                        output: []
                    );
                    return;
                }
            }

            // Chama o serviço de seleção de contexto
            $workContexts = (new AuthService())->selectWorkContext(
                usuario_uuid: $bearerToken['user_data']['uuid'],
                contexto_uuid: DataSanitizer::string(value: $form['contexto_uuid'] ?? '')
            );

            // Resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $workContexts['response_code'] ?? 500,
                status: $workContexts['status'] ?? 'error',
                message: $workContexts['message'] ?? 'Internal server error',
                output: $workContexts['output'] ?? []
            );
        }

        /**
         * Lida com a requisição de logout, revogando o token de autenticação do usuário.
         *
         * Este método atua como um **controlador** de API, responsável por extrair o token JWT do cabeçalho da requisição, delegar a lógica de revogação para o serviço e formatar a resposta JSON final.
         *
         * #### Fluxo de Operação:
         * 1.  **Obtenção do Token:** O token Bearer é extraído do cabeçalho da requisição.
         * 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 retornado pelo serviço (`logoutService`) é formatado para uma resposta JSON padronizada usando **`RequestHelper::sendJsonResponse`**. O código HTTP, status, mensagem e quaisquer dados de saída são 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 {
            // Chama o serviço de logout
            $logoutService = (new AuthService())->logout(
                token: JWTService::getBearerToken()
            );

            // Resposta JSON
            RequestHelper::sendJsonResponse(
                response_code: $logoutService['response_code'] ?? 500,
                status: $logoutService['status'] ?? 'error',
                message: $logoutService['message'] ?? 'Internal server error',
                output: $logoutService['output'] ?? []
            );
        }
    }