<?php
/**
 * API ESPECÍFICA PARA GESTORES
 * Visualizar solicitações pendentes e notificações
 */

header('Content-Type: application/json; charset=utf-8');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type, Authorization, Accept');

if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    exit(0);
}

// Configuração do banco de dados
$dbConfig = [
    'host' => 'localhost',
    'port' => 3306,
    'database' => 'pinheir3_controle_frotasV1.1',
    'username' => 'pinheir3_admin',
    'password' => '080880Gelboy',
    'charset' => 'utf8mb4'
];

// Função para conectar ao banco
function getConnection() {
    global $dbConfig;
    
    try {
        $dsn = sprintf(
            'mysql:host=%s;port=%d;dbname=%s;charset=%s',
            $dbConfig['host'],
            $dbConfig['port'],
            $dbConfig['database'],
            $dbConfig['charset']
        );
        
        $pdo = new PDO($dsn, $dbConfig['username'], $dbConfig['password'], [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]);
        
        return $pdo;
    } catch (PDOException $e) {
        throw $e;
    }
}

// Função para enviar resposta de sucesso
function sendSuccess($data = [], $statusCode = 200) {
    http_response_code($statusCode);
    echo json_encode([
        'success' => true,
        'timestamp' => date('Y-m-d H:i:s'),
        'data' => $data
    ], JSON_UNESCAPED_UNICODE);
    exit();
}

// Função para enviar resposta de erro
function sendError($message, $statusCode = 400) {
    http_response_code($statusCode);
    echo json_encode([
        'success' => false,
        'timestamp' => date('Y-m-d H:i:s'),
        'error' => [
            'message' => $message,
            'code' => $statusCode
        ]
    ], JSON_UNESCAPED_UNICODE);
    exit();
}

// Função para verificar autenticação de gestor
function requireGestorAuth() {
    $headers = getallheaders();
    $authHeader = $headers['Authorization'] ?? '';
    
    if (empty($authHeader) || !preg_match('/Bearer\s+(.*)$/i', $authHeader, $matches)) {
        sendError('Token de acesso necessário', 401);
    }
    
    $token = $matches[1];
    
    try {
        // Decodificar token JWT simples
        $decoded = json_decode(base64_decode($token), true);
        
        if (!$decoded || !isset($decoded['id']) || !isset($decoded['usuario'])) {
            sendError('Token inválido', 401);
        }
        
        // Verificar se o token expirou
        if (isset($decoded['exp']) && $decoded['exp'] < time()) {
            sendError('Token expirado', 401);
        }
        
        // Buscar dados do gestor no banco
        $pdo = getConnection();
        $sql = "SELECT id, nome, email, usuario, nivel_acesso, status 
                FROM gestores 
                WHERE id = ? AND usuario = ? AND status = 'ativo'";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$decoded['id'], $decoded['usuario']]);
        $gestor = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if (!$gestor) {
            sendError('Gestor não encontrado ou inativo', 401);
        }
        
        return [
            'user_id' => $gestor['id'],
            'nome' => $gestor['nome'],
            'cargo' => $gestor['nivel_acesso']
        ];
        
    } catch (Exception $e) {
        sendError('Token inválido: ' . $e->getMessage(), 401);
    }
}

try {
    // Verificar autenticação
    $gestor = requireGestorAuth();
    
    switch ($_SERVER['REQUEST_METHOD']) {
        case 'GET':
            $acao = $_GET['acao'] ?? 'solicitacoes';
            switch ($acao) {
                case 'solicitacoes':
                    listarSolicitacoesPendentes($gestor);
                    break;
                case 'notificacoes':
                    listarNotificacoesGestor($gestor);
                    break;
                case 'contar_notificacoes':
                    contarNotificacoesGestor($gestor);
                    break;
                default:
                    sendError('Ação não reconhecida', 400);
            }
            break;
        
        case 'POST':
            $acao = $_GET['acao'] ?? 'aprovar';
            switch ($acao) {
                case 'aprovar':
                    aprovarSolicitacao($gestor);
                    break;
                case 'negar':
                    negarSolicitacao($gestor);
                    break;
                case 'marcar_lida':
                    marcarNotificacaoComoLida($gestor);
                    break;
                default:
                    sendError('Ação não reconhecida', 400);
            }
            break;
        
        default:
            sendError('Método não permitido', 405);
    }
    
} catch (Exception $e) {
    sendError('Erro interno: ' . $e->getMessage(), 500);
}

/**
 * Listar solicitações pendentes para o gestor
 */
function listarSolicitacoesPendentes($gestor) {
    try {
        $pdo = getConnection();
        
        // Buscar todas as solicitações pendentes (sem filtrar por gestor específico)
        $sql = "SELECT 
                    s.*,
                    COALESCE(s.data_solicitacao, s.data_criacao) as data_solicitacao,
                    m.nome as tecnico_nome,
                    m.matricula as tecnico_matricula,
                    v.modelo as veiculo_modelo,
                    v.placa as veiculo_placa,
                    TIMESTAMPDIFF(MINUTE, s.data_criacao, NOW()) as tempo_espera_minutos
                FROM solicitacoes_viagem s
                LEFT JOIN motoristas m ON s.tecnico_id = m.id
                LEFT JOIN veiculos v ON s.veiculo_id = v.id
                WHERE s.status = 'pendente'
                ORDER BY s.prioridade DESC, s.data_criacao ASC";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute();
        $solicitacoes = $stmt->fetchAll();
        
        sendSuccess([
            'solicitacoes_pendentes' => $solicitacoes,
            'total_pendentes' => count($solicitacoes),
            'gestor' => [
                'id' => $gestor['user_id'],
                'nome' => $gestor['nome']
            ]
        ]);
        
    } catch (Exception $e) {
        sendError('Erro ao listar solicitações: ' . $e->getMessage(), 500);
    }
}

/**
 * Listar notificações do gestor
 */
function listarNotificacoesGestor($gestor) {
    try {
        $pdo = getConnection();
        
        $sql = "SELECT 
                    n.*,
                    s.cliente as solicitacao_cliente,
                    s.prioridade as solicitacao_prioridade,
                    s.tecnico_id as solicitacao_tecnico_id,
                    m.nome as tecnico_nome
                FROM notificacoes_push n
                LEFT JOIN solicitacoes_viagem s ON n.solicitacao_id = s.id
                LEFT JOIN motoristas m ON s.tecnico_id = m.id
                WHERE n.user_id = ? AND n.lida = FALSE
                ORDER BY 
                    CASE 
                        WHEN n.tipo = 'solicitacao_viagem' THEN 1
                        ELSE 2
                    END,
                    n.created_at DESC";

        $stmt = $pdo->prepare($sql);
        $stmt->execute([$gestor['user_id']]);
        $notificacoes = $stmt->fetchAll();
        
        sendSuccess([
            'notificacoes_nao_lidas' => $notificacoes,
            'total_nao_lidas' => count($notificacoes)
        ]);
        
    } catch (Exception $e) {
        sendError('Erro ao listar notificações: ' . $e->getMessage(), 500);
    }
}

/**
 * Contar notificações não lidas do gestor
 */
function contarNotificacoesGestor($gestor) {
    try {
        $pdo = getConnection();
        
        $sql = "SELECT 
                    COUNT(*) as total_nao_lidas,
                    COUNT(CASE WHEN tipo = 'solicitacao_viagem' THEN 1 END) as solicitacoes_pendentes,
                    COUNT(CASE WHEN tipo = 'aprovacao_viagem' THEN 1 END) as aprovacoes,
                    COUNT(CASE WHEN tipo = 'negacao_viagem' THEN 1 END) as negacoes
                FROM notificacoes_push 
                WHERE user_id = ? AND lida = FALSE";

        $stmt = $pdo->prepare($sql);
        $stmt->execute([$gestor['user_id']]);
        $resultado = $stmt->fetch();
        
        sendSuccess([
            'total_nao_lidas' => (int)$resultado['total_nao_lidas'],
            'solicitacoes_pendentes' => (int)$resultado['solicitacoes_pendentes'],
            'aprovacoes' => (int)$resultado['aprovacoes'],
            'negacoes' => (int)$resultado['negacoes'],
            'tem_notificacoes' => $resultado['total_nao_lidas'] > 0
        ]);
        
    } catch (Exception $e) {
        sendError('Erro ao contar notificações: ' . $e->getMessage(), 500);
    }
}

/**
 * Aprovar solicitação de viagem
 */
function aprovarSolicitacao($gestor) {
    $input = json_decode(file_get_contents('php://input'), true);
    $solicitacaoId = $input['solicitacao_id'] ?? null;
    $justificativa = $input['justificativa'] ?? 'Aprovada pelo gestor';
    
    if (!$solicitacaoId) {
        sendError('ID da solicitação é obrigatório', 400);
    }

    try {
        $pdo = getConnection();
        $pdo->beginTransaction();

        // Buscar solicitação
        $sql = "SELECT * FROM solicitacoes_viagem WHERE id = ? AND status = 'pendente'";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$solicitacaoId]);
        $solicitacao = $stmt->fetch();

        if (!$solicitacao) {
            sendError('Solicitação não encontrada ou já processada', 404);
        }

        // Atualizar status da solicitação
        $sql = "UPDATE solicitacoes_viagem SET 
                status = 'aprovada', 
                gestor_id = ?, 
                data_resposta = NOW(), 
                resposta_gestor = ? 
                WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$gestor['user_id'], $justificativa, $solicitacaoId]);

        // Criar viagem automaticamente
        $viagemId = criarViagemApoAprovacao($pdo, $solicitacao);

        // Atualizar solicitação com ID da viagem
        $sql = "UPDATE solicitacoes_viagem SET viagem_id = ? WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$viagemId, $solicitacaoId]);

        // Enviar notificação de aprovação para o motorista
        enviarNotificacaoParaMotorista($pdo, $solicitacao['tecnico_id'], 'aprovacao_viagem', [
            'gestor_nome' => $gestor['nome'],
            'cliente' => $solicitacao['cliente'],
            'viagem_id' => $viagemId
        ]);

        $pdo->commit();

        sendSuccess([
            'solicitacao_id' => $solicitacaoId,
            'viagem_id' => $viagemId,
            'status' => 'aprovada',
            'mensagem' => 'Viagem aprovada e criada com sucesso'
        ]);

    } catch (Exception $e) {
        if (isset($pdo)) {
            $pdo->rollback();
        }
        sendError('Erro ao aprovar solicitação: ' . $e->getMessage(), 500);
    }
}

/**
 * Negar solicitação de viagem
 */
function negarSolicitacao($gestor) {
    $input = json_decode(file_get_contents('php://input'), true);
    $solicitacaoId = $input['solicitacao_id'] ?? null;
    $justificativa = $input['justificativa'] ?? null;
    
    if (!$solicitacaoId) {
        sendError('ID da solicitação é obrigatório', 400);
    }

    if (!$justificativa) {
        sendError('Justificativa é obrigatória para negar solicitação', 400);
    }

    try {
        $pdo = getConnection();
        $pdo->beginTransaction();

        // Buscar solicitação
        $sql = "SELECT * FROM solicitacoes_viagem WHERE id = ? AND status = 'pendente'";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$solicitacaoId]);
        $solicitacao = $stmt->fetch();

        if (!$solicitacao) {
            sendError('Solicitação não encontrada ou já processada', 404);
        }

        // Atualizar status da solicitação
        $sql = "UPDATE solicitacoes_viagem SET 
                status = 'negada', 
                gestor_id = ?, 
                data_resposta = NOW(), 
                resposta_gestor = ? 
                WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$gestor['user_id'], $justificativa, $solicitacaoId]);

        // Enviar notificação de negação para o motorista
        enviarNotificacaoParaMotorista($pdo, $solicitacao['tecnico_id'], 'negacao_viagem', [
            'gestor_nome' => $gestor['nome'],
            'cliente' => $solicitacao['cliente'],
            'justificativa' => $justificativa
        ]);

        $pdo->commit();

        sendSuccess([
            'solicitacao_id' => $solicitacaoId,
            'status' => 'negada',
            'justificativa' => $justificativa,
            'mensagem' => 'Solicitação negada com sucesso'
        ]);

    } catch (Exception $e) {
        if (isset($pdo)) {
            $pdo->rollback();
        }
        sendError('Erro ao negar solicitação: ' . $e->getMessage(), 500);
    }
}

/**
 * Marcar notificação como lida
 */
function marcarNotificacaoComoLida($gestor) {
    $input = json_decode(file_get_contents('php://input'), true);
    $notificacaoId = $input['notificacao_id'] ?? null;
    
    if (!$notificacaoId) {
        sendError('ID da notificação é obrigatório', 400);
    }

    try {
        $pdo = getConnection();
        
        $sql = "UPDATE notificacoes_push 
                SET lida = TRUE, updated_at = NOW() 
                WHERE id = ? AND user_id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$notificacaoId, $gestor['user_id']]);
        
        if ($stmt->rowCount() === 0) {
            sendError('Notificação não encontrada ou não pertence ao gestor', 404);
        }

        sendSuccess([
            'notificacao_id' => $notificacaoId,
            'lida' => true,
            'mensagem' => 'Notificação marcada como lida'
        ]);
        
    } catch (Exception $e) {
        sendError('Erro ao marcar notificação: ' . $e->getMessage(), 500);
    }
}

/**
 * Criar viagem após aprovação da solicitação
 */
function criarViagemApoAprovacao($pdo, $solicitacao) {
    $sql = "INSERT INTO viagens (
        tecnico_id, veiculo_id, cliente, motivo, km_inicial,
        data_inicio, latitude_inicial, longitude_inicial,
        endereco_inicial, cliente_id, observacoes, sincronizado
    ) VALUES (?, ?, ?, ?, ?, NOW(), ?, ?, ?, ?, ?, 1)";

    $stmt = $pdo->prepare($sql);
    $stmt->execute([
        $solicitacao['tecnico_id'],
        $solicitacao['veiculo_id'],
        $solicitacao['cliente'],
        $solicitacao['motivo'],
        $solicitacao['km_inicial'],
        $solicitacao['latitude_inicial'],
        $solicitacao['longitude_inicial'],
        $solicitacao['endereco_inicial'],
        $solicitacao['cliente_id'],
        'Viagem criada após aprovação da solicitação #' . $solicitacao['id']
    ]);

    return $pdo->lastInsertId();
}

/**
 * Enviar notificação para motorista
 */
function enviarNotificacaoParaMotorista($pdo, $motoristaId, $tipo, $dados) {
    $titulo = '';
    $mensagem = '';

    switch ($tipo) {
        case 'aprovacao_viagem':
            $titulo = '✅ Viagem Aprovada';
            $mensagem = sprintf(
                'Sua viagem para %s foi aprovada por %s. Você já pode iniciar!',
                $dados['cliente'],
                $dados['gestor_nome']
            );
            break;
        
        case 'negacao_viagem':
            $titulo = '❌ Viagem Negada';
            $mensagem = sprintf(
                'Sua viagem para %s foi negada por %s. Motivo: %s',
                $dados['cliente'],
                $dados['gestor_nome'],
                $dados['justificativa']
            );
            break;
    }

    if ($titulo && $mensagem) {
        $sql = "INSERT INTO notificacoes_push 
                (user_id, tipo, titulo, mensagem, viagem_id, created_at) 
                VALUES (?, ?, ?, ?, ?, NOW())";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([
            $motoristaId, 
            $tipo, 
            $titulo, 
            $mensagem, 
            $dados['viagem_id'] ?? null
        ]);
    }
}
?> 
