<?php
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');

// Configurações do banco de dados
$configs = [
    ['host' => 'localhost', 'user' => 'pinheir3', 'password' => '080880Gelboy', 'database' => 'pinheir3_controle_frotasV1.1'],
    ['host' => 'localhost', 'user' => 'root', 'password' => '080880Gelboy', 'database' => 'pinheir3_controle_frotasV1.1'],
    ['host' => 'localhost', 'user' => 'pinheir3', 'password' => '', 'database' => 'pinheir3_controle_frotasV1.1'],
    ['host' => 'localhost', 'user' => 'root', 'password' => '', 'database' => 'controle_frotas']
];

$pdo = null;
$configUsada = null;

// Tentar conectar com diferentes configurações
foreach ($configs as $config) {
    try {
        $pdo = new PDO(
            "mysql:host={$config['host']};dbname={$config['database']};charset=utf8mb4",
            $config['user'],
            $config['password'],
            [
                PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8mb4"
            ]
        );
        $configUsada = $config;
        break;
    } catch (PDOException $e) {
        continue;
    }
}

if (!$pdo) {
    echo json_encode([
        'sucesso' => false,
        'erro' => 'Não foi possível conectar com o banco de dados',
        'timestamp' => date('Y-m-d H:i:s')
    ]);
    exit;
}

try {
    $acao = $_GET['acao'] ?? 'rastreamento';
    
    switch ($acao) {
        case 'rastreamento':
            // Verificar quais tabelas existem
            $stmt = $pdo->query("SHOW TABLES");
            $tabelas = $stmt->fetchAll(PDO::FETCH_COLUMN);
            
            $temUsuarios = in_array('usuarios', $tabelas);
            $temMotoristas = in_array('motoristas', $tabelas);
            $temVeiculos = in_array('veiculos', $tabelas);
            $temTrajetoPontos = in_array('trajeto_pontos', $tabelas);
            
            // Buscar viagens em andamento (sem data_fim) - versão adaptada
            $sql = "
                SELECT 
                    v.id,
                    v.cliente,
                    v.motivo,
                    v.tecnico_id,
                    v.veiculo_id,
                    v.data_inicio,
                    v.latitude_inicial,
                    v.longitude_inicial,
                    v.latitude_final,
                    v.longitude_final,
                    v.trajeto,
                    v.km_inicial,
                    TIMESTAMPDIFF(MINUTE, v.data_inicio, NOW()) as duracao_minutos,
                    
                    -- Dados do motorista/técnico (adaptado)
                    COALESCE(";
            
            if ($temUsuarios) {
                $sql .= "u.nome, ";
            }
            if ($temMotoristas) {
                $sql .= "m.nome, ";
            }
            $sql .= "v.tecnico_id) as motorista_nome,";
            
            if ($temMotoristas) {
                $sql .= "COALESCE(m.matricula, 'SEM_MATRICULA') as motorista_matricula,";
            } else {
                $sql .= "'SEM_MATRICULA' as motorista_matricula,";
            }
            
            $sql .= "
                    CONCAT(
                        COALESCE(";
            if ($temUsuarios) {
                $sql .= "u.nome, ";
            }
            if ($temMotoristas) {
                $sql .= "m.nome, ";
            }
            $sql .= "v.tecnico_id)";
            
            if ($temMotoristas) {
                $sql .= ", CASE WHEN m.matricula IS NOT NULL THEN CONCAT(' (', m.matricula, ')') ELSE '' END";
            }
            $sql .= ") as motorista_completo,
                    
                    -- Dados do veículo (adaptado)";
            
            if ($temVeiculos) {
                $sql .= "
                    ve.modelo as veiculo_modelo,
                    ve.placa as veiculo_placa,
                    CONCAT(COALESCE(ve.modelo, 'Modelo N/D'), ' - ', COALESCE(ve.placa, 'Placa N/D')) as veiculo_completo,";
            } else {
                $sql .= "
                    'Modelo N/D' as veiculo_modelo,
                    'Placa N/D' as veiculo_placa,
                    'Veículo N/D' as veiculo_completo,";
            }
            
            // Último ponto GPS (se tabela existe)
            if ($temTrajetoPontos) {
                $sql .= "
                    -- Último ponto GPS
                    (
                        SELECT JSON_OBJECT(
                            'latitude', tp.latitude,
                            'longitude', tp.longitude,
                            'timestamp', tp.timestamp_ponto,
                            'velocidade', tp.velocidade,
                            'precisao', tp.precisao
                        )
                        FROM trajeto_pontos tp 
                        WHERE tp.viagem_id = v.id 
                        ORDER BY tp.timestamp_ponto DESC 
                        LIMIT 1
                    ) as ultimo_ponto_gps,
                    
                    -- Contagem de pontos GPS
                    (
                        SELECT COUNT(*) 
                        FROM trajeto_pontos tp 
                        WHERE tp.viagem_id = v.id
                    ) as total_pontos_gps";
            } else {
                $sql .= "
                    NULL as ultimo_ponto_gps,
                    0 as total_pontos_gps";
            }
            
            $sql .= "
                FROM viagens v";
            
            if ($temUsuarios) {
                $sql .= "
                LEFT JOIN usuarios u ON v.tecnico_id = u.id";
            }
            if ($temMotoristas) {
                $sql .= "
                LEFT JOIN motoristas m ON v.tecnico_id = m.id OR v.tecnico_id = m.matricula";
            }
            if ($temVeiculos) {
                $sql .= "
                LEFT JOIN veiculos ve ON v.veiculo_id = ve.id";
            }
            
            $sql .= "
                WHERE v.data_fim IS NULL
                ORDER BY v.data_inicio DESC
            ";
            
            $stmt = $pdo->prepare($sql);
            $stmt->execute();
            $viagens = $stmt->fetchAll();
            
            $dadosProcessados = [];
            
            foreach ($viagens as $viagem) {
                // Processar trajeto JSON
                $trajeto = [];
                if ($viagem['trajeto']) {
                    $trajetoDecoded = json_decode($viagem['trajeto'], true);
                    if (is_array($trajetoDecoded)) {
                        $trajeto = $trajetoDecoded;
                    }
                }
                
                // Determinar posição atual
                $posicaoAtual = null;
                
                // 1. Usar último ponto GPS da tabela trajeto_pontos (se existe)
                if ($temTrajetoPontos && $viagem['ultimo_ponto_gps']) {
                    $ultimoPonto = json_decode($viagem['ultimo_ponto_gps'], true);
                    if ($ultimoPonto && $ultimoPonto['latitude'] && $ultimoPonto['longitude']) {
                        $posicaoAtual = [
                            'latitude' => floatval($ultimoPonto['latitude']),
                            'longitude' => floatval($ultimoPonto['longitude']),
                            'timestamp' => $ultimoPonto['timestamp'],
                            'velocidade' => floatval($ultimoPonto['velocidade'] ?? 0),
                            'precisao' => floatval($ultimoPonto['precisao'] ?? 0),
                            'fonte' => 'trajeto_pontos',
                            'tempo_atualizacao' => $ultimoPonto['timestamp']
                        ];
                    }
                }
                
                // 2. Fallback: último ponto do trajeto JSON
                if (!$posicaoAtual && !empty($trajeto)) {
                    $ultimoPonto = end($trajeto);
                    if ($ultimoPonto && isset($ultimoPonto['latitude'], $ultimoPonto['longitude'])) {
                        $posicaoAtual = [
                            'latitude' => floatval($ultimoPonto['latitude']),
                            'longitude' => floatval($ultimoPonto['longitude']),
                            'timestamp' => $ultimoPonto['timestamp'] ?? $viagem['data_inicio'],
                            'velocidade' => floatval($ultimoPonto['velocidade'] ?? 0),
                            'precisao' => floatval($ultimoPonto['precisao'] ?? 0),
                            'fonte' => 'trajeto_json',
                            'tempo_atualizacao' => $ultimoPonto['timestamp'] ?? $viagem['data_inicio']
                        ];
                    }
                }
                
                // 3. PRIORITÁRIO: Posição inicial da viagem (sempre mostrar no mapa quando viagem inicia)
                if (!$posicaoAtual) {
                    $latInicial = floatval($viagem['latitude_inicial'] ?? 0);
                    $lngInicial = floatval($viagem['longitude_inicial'] ?? 0);
                    
                    // Verificar se as coordenadas são válidas (não zero e dentro do range)
                    if ($latInicial != 0 && $lngInicial != 0 && 
                        $latInicial >= -90 && $latInicial <= 90 && 
                        $lngInicial >= -180 && $lngInicial <= 180) {
                        
                        $posicaoAtual = [
                            'latitude' => $latInicial,
                            'longitude' => $lngInicial,
                            'timestamp' => $viagem['data_inicio'],
                            'velocidade' => 0,
                            'precisao' => 0,
                            'fonte' => 'posicao_inicial',
                            'tempo_atualizacao' => $viagem['data_inicio']
                        ];
                    }
                }
                
                // 4. Fallback para coordenadas finais se não há iniciais
                if (!$posicaoAtual) {
                    $latFinal = floatval($viagem['latitude_final'] ?? 0);
                    $lngFinal = floatval($viagem['longitude_final'] ?? 0);
                    
                    if ($latFinal != 0 && $lngFinal != 0 && 
                        $latFinal >= -90 && $latFinal <= 90 && 
                        $lngFinal >= -180 && $lngFinal <= 180) {
                        
                        $posicaoAtual = [
                            'latitude' => $latFinal,
                            'longitude' => $lngFinal,
                            'timestamp' => $viagem['data_inicio'],
                            'velocidade' => 0,
                            'precisao' => 0,
                            'fonte' => 'posicao_final_como_inicial',
                            'tempo_atualizacao' => $viagem['data_inicio']
                        ];
                    }
                }
                
                // Calcular tempo desde última atualização
                $tempoUltimaAtualizacao = null;
                if ($posicaoAtual && $posicaoAtual['timestamp']) {
                    $timestampAtual = new DateTime();
                    $timestampPonto = new DateTime($posicaoAtual['timestamp']);
                    $tempoUltimaAtualizacao = $timestampAtual->getTimestamp() - $timestampPonto->getTimestamp();
                }
                
                $dadosProcessados[] = [
                    'id' => intval($viagem['id']),
                    'cliente' => $viagem['cliente'],
                    'motivo' => $viagem['motivo'],
                    'motorista_nome' => $viagem['motorista_nome'],
                    'motorista_matricula' => $viagem['motorista_matricula'],
                    'motorista_completo' => $viagem['motorista_completo'],
                    'veiculo_modelo' => $viagem['veiculo_modelo'],
                    'veiculo_placa' => $viagem['veiculo_placa'],
                    'veiculo_completo' => $viagem['veiculo_completo'],
                    'data_inicio' => $viagem['data_inicio'],
                    'duracao_minutos' => intval($viagem['duracao_minutos']),
                    'posicao_atual' => $posicaoAtual,
                    'total_pontos_gps' => intval($viagem['total_pontos_gps'] ?? 0),
                    'trajeto_pontos' => $trajeto,
                    'km_inicial' => intval($viagem['km_inicial']),
                    'tempo_ultima_atualizacao_segundos' => $tempoUltimaAtualizacao,
                    'status' => $posicaoAtual ? 'com_gps' : 'sem_gps',
                    'status_texto' => $posicaoAtual ? 'Com GPS' : 'Sem GPS'
                ];
            }
            
            echo json_encode([
                'sucesso' => true,
                'dados' => $dadosProcessados,
                'total_viagens' => count($dadosProcessados),
                'timestamp' => date('Y-m-d H:i:s'),
                'tabelas_encontradas' => $tabelas,
                'conexao' => [
                    'host' => $configUsada['host'],
                    'database' => $configUsada['database'],
                    'user' => $configUsada['user']
                ]
            ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
            break;
            
        case 'pontos_gps':
            $viagemId = $_GET['viagem_id'] ?? null;
            if (!$viagemId) {
                throw new Exception('ID da viagem é obrigatório');
            }
            
            // Verificar se tabela existe
            $stmt = $pdo->query("SHOW TABLES LIKE 'trajeto_pontos'");
            if ($stmt->rowCount() == 0) {
                echo json_encode([
                    'sucesso' => true,
                    'viagem_id' => intval($viagemId),
                    'pontos' => [],
                    'total_pontos' => 0,
                    'mensagem' => 'Tabela trajeto_pontos não existe',
                    'timestamp' => date('Y-m-d H:i:s')
                ]);
                break;
            }
            
            // Buscar todos os pontos GPS de uma viagem específica
            $sql = "
                SELECT 
                    latitude,
                    longitude,
                    timestamp_ponto,
                    velocidade,
                    precisao
                FROM trajeto_pontos 
                WHERE viagem_id = :viagem_id 
                ORDER BY timestamp_ponto ASC
            ";
            
            $stmt = $pdo->prepare($sql);
            $stmt->execute(['viagem_id' => $viagemId]);
            $pontos = $stmt->fetchAll();
            
            echo json_encode([
                'sucesso' => true,
                'viagem_id' => intval($viagemId),
                'pontos' => array_map(function($ponto) {
                    return [
                        'latitude' => floatval($ponto['latitude']),
                        'longitude' => floatval($ponto['longitude']),
                        'timestamp' => $ponto['timestamp_ponto'],
                        'velocidade' => floatval($ponto['velocidade'] ?? 0),
                        'precisao' => floatval($ponto['precisao'] ?? 0)
                    ];
                }, $pontos),
                'total_pontos' => count($pontos),
                'timestamp' => date('Y-m-d H:i:s')
            ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
            break;
            
        case 'stats':
            // Estatísticas gerais do rastreamento
            $sql = "
                SELECT 
                    COUNT(*) as total_viagens_ativas,
                    COUNT(CASE WHEN v.latitude_inicial IS NOT NULL THEN 1 END) as viagens_com_gps,
                    AVG(TIMESTAMPDIFF(MINUTE, v.data_inicio, NOW())) as duracao_media_minutos
                FROM viagens v
                WHERE v.data_fim IS NULL
            ";
            
            $stmt = $pdo->prepare($sql);
            $stmt->execute();
            $stats = $stmt->fetch();
            
            // Verificar se tabela trajeto_pontos existe para contar trajetos
            $viagensComTrajeto = 0;
            $stmt = $pdo->query("SHOW TABLES LIKE 'trajeto_pontos'");
            if ($stmt->rowCount() > 0) {
                $stmt = $pdo->query("
                    SELECT COUNT(DISTINCT viagem_id) as viagens_com_trajeto
                    FROM trajeto_pontos tp
                    INNER JOIN viagens v ON tp.viagem_id = v.id
                    WHERE v.data_fim IS NULL
                ");
                $result = $stmt->fetch();
                $viagensComTrajeto = $result['viagens_com_trajeto'] ?? 0;
            }
            
            echo json_encode([
                'sucesso' => true,
                'estatisticas' => [
                    'total_viagens_ativas' => intval($stats['total_viagens_ativas']),
                    'viagens_com_gps' => intval($stats['viagens_com_gps']),
                    'viagens_com_trajeto' => intval($viagensComTrajeto),
                    'duracao_media_minutos' => round(floatval($stats['duracao_media_minutos']), 1)
                ],
                'timestamp' => date('Y-m-d H:i:s')
            ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
            break;
            
        default:
            throw new Exception('Ação não reconhecida: ' . $acao);
    }
    
} catch (Exception $e) {
    echo json_encode([
        'sucesso' => false,
        'erro' => $e->getMessage(),
        'linha' => $e->getLine(),
        'arquivo' => basename($e->getFile()),
        'timestamp' => date('Y-m-d H:i:s')
    ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
}
?> 
