API Geoespacial Personalizada

// Controller para cálculo de rotas otimizadas
const express = require('express');
const router = express.Router();
const { Pool } = require('pg');
const turf = require('@turf/turf');

// Conexão com PostGIS
const pool = new Pool({
  user: process.env.DB_USER,
  host: process.env.DB_HOST,
  database: process.env.DB_NAME,
  password: process.env.DB_PASSWORD,
  port: process.env.DB_PORT
});

// Middleware para verificar parâmetros de rota
const validateRouteParams = (req, res, next) => {
  const { origin, destination, mode } = req.body;
  
  if (!origin || !destination ||
      !origin.latitude || !origin.longitude ||
      !destination.latitude || !destination.longitude) {
    return res.status(400).json({
      success: false,
      message: 'Origem e destino são obrigatórios e devem incluir latitude e longitude'
    });
  }
  
  req.routeParams = {
    origin: {
      lat: parseFloat(origin.latitude),
      lng: parseFloat(origin.longitude)
    },
    destination: {
      lat: parseFloat(destination.latitude),
      lng: parseFloat(destination.longitude)
    },
    mode: mode || 'car' // Modo padrão é carro
  };
  
  next();
};

// Rota para calcular trajeto otimizado
router.post('/route', validateRouteParams, async (req, res) => {
  try {
    const { origin, destination, mode } = req.routeParams;
    const client = await pool.connect();
    
    // Encontrar os vértices de rede mais próximos dos pontos de origem e destino
    const startNodeQuery = await client.query(
      `
      SELECT id, ST_AsText(geom) as geom
      FROM road_network_vertices
      ORDER BY ST_Distance(
        geom, 
        ST_SetSRID(ST_MakePoint($1, $2), 4326)
      ) LIMIT 1
      `,
      [origin.lng, origin.lat]
    );
    
    const endNodeQuery = await client.query(
      `
      SELECT id, ST_AsText(geom) as geom
      FROM road_network_vertices
      ORDER BY ST_Distance(
        geom, 
        ST_SetSRID(ST_MakePoint($1, $2), 4326)
      ) LIMIT 1
      `,
      [destination.lng, destination.lat]
    );
    
    const startNodeId = startNodeQuery.rows[0].id;
    const endNodeId = endNodeQuery.rows[0].id;
    
    // Obter dados de tráfego em tempo real para ajustar pesos
    const trafficFactors = await getTrafficFactors();
    
    // Calcular rota usando pgRouting (algoritmo A*)
    const speedFactor = getSpeedFactor(mode);
    const costColumn = getCostColumn(mode);
    
    // Query para cálculo de rota otimizada
    const routeQuery = await client.query(
      `
      SELECT 
        id, edge, cost, agg_cost,
        ST_AsGeoJSON(
          ST_LineMerge(
            ST_Union(
              r.the_geom
            )
          )
        ) AS geometry
      FROM pgr_astar(
        'SELECT id, 
                source, 
                target, 
                length * ${costColumn} * COALESCE(
                  (SELECT factor FROM traffic_conditions 
                   WHERE edge_id = road_network.id 
                   ORDER BY timestamp DESC LIMIT 1),
                  1.0
                ) AS cost,
                length * ${costColumn} * COALESCE(
                  (SELECT factor FROM traffic_conditions 
                   WHERE edge_id = road_network.id 
                   ORDER BY timestamp DESC LIMIT 1),
                  1.0
                ) AS reverse_cost,
                x1, y1, x2, y2
         FROM road_network',
        $1, $2, true, true
      ) as pt
      JOIN road_network as r ON pt.edge = r.id
      ORDER BY pt.path_seq
      `,
      [startNodeId, endNodeId]
    );
    
    // Montar objeto de rota com geometria, distância, duração e instruções
    const route = processRouteResults(routeQuery.rows);
    
    // Adicionar informações sobre condições da rota
    route.conditions = await getRouteConditions(route.geometry);
    
    // Liberar cliente de volta ao pool
    client.release();
    
    // Retornar rota calculada
    res.json({
      success: true,
      route
    });
  } catch (error) {
    console.error('Erro ao calcular rota:', error);
    res.status(500).json({
      success: false,
      message: 'Erro ao calcular rota',
      error: error.message
    });
  }
});

// Função para obter fatores de tráfego em tempo real
async function getTrafficFactors() {
  try {
    const client = await pool.connect();
    const result = await client.query(
      `
      SELECT edge_id, factor 
      FROM traffic_conditions 
      WHERE timestamp > NOW() - INTERVAL '15 minutes'
      `
    );
    client.release();
    
    const factors = {};
    result.rows.forEach(row => {
      factors[row.edge_id] = row.factor;
    });
    
    return factors;
  } catch (error) {
    console.error('Erro ao obter fatores de tráfego:', error);
    return {};
  }
}

// Exportar router
module.exports = router;

// Sistema de monitoramento em tempo real com WebSockets
const http = require('http');
const express = require('express');
const socketIO = require('socket.io');
const redis = require('redis');
const { promisify } = require('util');

const app = express();
const server = http.createServer(app);
const io = socketIO(server, {
  cors: {
    origin: '*',
    methods: ['GET', 'POST']
  }
});

// Configuração do Redis para armazenamento temporário e pub/sub
const redisClient = redis.createClient({
  host: process.env.REDIS_HOST,
  port: process.env.REDIS_PORT,
  password: process.env.REDIS_PASSWORD
});

const redisGetAsync = promisify(redisClient.get).bind(redisClient);
const redisSetAsync = promisify(redisClient.set).bind(redisClient);
const redisSubscriber = redisClient.duplicate();

// Configurar canal de assinatura para atualizações de localização
redisSubscriber.subscribe('location-updates');
redisSubscriber.on('message', handleLocationUpdate);

// Mapa de conexões ativas dos clientes
const activeConnections = new Map();

// Objeto para armazenar informações do último estado conhecido
const lastKnownState = {
  vehicles: {},
  deliveries: {}
};

// Configuração de Socket.IO
io.on('connection', (socket) => {
  console.log(`Novo cliente conectado: ${socket.id}`);
  
  // Autenticar conexão
  socket.on('authenticate', async (authData) => {
    try {
      const { userId, token, subscriptions } = authData;
      
      // Verificar autenticação (implementação simplificada)
      const isValid = await validateToken(userId, token);
      
      if (!isValid) {
        socket.emit('auth_error', { message: 'Autenticação inválida' });
        socket.disconnect(true);
        return;
      }
      
      // Armazenar informações da conexão
      activeConnections.set(socket.id, {
        userId,
        subscriptions: subscriptions || []
      });
      
      // Enviar o estado inicial para o cliente
      await sendInitialState(socket, userId, subscriptions);
      
      socket.emit('auth_success', { message: 'Autenticação bem-sucedida' });
    } catch (error) {
      console.error('Erro durante autenticação:', error);
      socket.emit('auth_error', { message: 'Erro durante autenticação' });
    }
  });
  
  // Receber atualizações de localização de dispositivos móveis
  socket.on('update_location', async (data) => {
    try {
      const connection = activeConnections.get(socket.id);
      
      if (!connection) {
        socket.emit('error', { message: 'Não autenticado' });
        return;
      }
      
      // Validar dados de localização
      const isValid = validateLocationData(data);
      
      if (!isValid) {
        socket.emit('error', { message: 'Dados de localização inválidos' });
        return;
      }
      
      // Processar e armazenar atualização de localização
      const { deviceId, type, latitude, longitude, heading, speed, accuracy, timestamp } = data;
      
      const locationUpdate = {
        deviceId,
        type,
        position: {
          latitude,
          longitude,
          heading,
          speed,
          accuracy
        },
        timestamp: timestamp || new Date().toISOString(),
        userId: connection.userId
      };
      
      // Publicar atualização no Redis para distribuição
      await publishLocationUpdate(locationUpdate);
      
      // Atualizar estado do sistema
      updateSystemState(locationUpdate);
      
      socket.emit('update_success', { message: 'Localização atualizada com sucesso' });
    } catch (error) {
      console.error('Erro ao processar atualização de localização:', error);
      socket.emit('error', { message: 'Erro ao processar atualização' });
    }
  });
  
  // Gerenciar desconexões
  socket.on('disconnect', () => {
    console.log(`Cliente desconectado: ${socket.id}`);
    activeConnections.delete(socket.id);
  });
});

// Função para processar atualizações de localização do Redis
function handleLocationUpdate(channel, message) {
  try {
    const update = JSON.parse(message);
    
    // Atualizar o estado do sistema
    updateSystemState(update);
    
    // Distribuir para clientes interessados
    broadcastUpdate(update);
  } catch (error) {
    console.error('Erro ao processar mensagem do Redis:', error);
  }
}

// Função para publicar atualizações de localização no Redis
async function publishLocationUpdate(update) {
  try {
    const message = JSON.stringify(update);
    redisClient.publish('location-updates', message);
    
    // Também armazenar temporariamente no Redis para clientes que se conectarem depois
    const key = `location:${update.type}:${update.deviceId}`;
    await redisSetAsync(key, message, 'EX', 3600); // Expirar após 1 hora
  } catch (error) {
    console.error('Erro ao publicar atualização no Redis:', error);
  }
}

// Iniciar o servidor
const PORT = process.env.PORT || 3001;
server.listen(PORT, () => {
  console.log(`Servidor de monitoramento em tempo real rodando na porta ${PORT}`);
});

// Sistema de cache offline para mapas
import React, { useState, useEffect } from 'react';
import { View, Text, Button, StyleSheet, Alert } from 'react-native';
import SQLite from 'react-native-sqlite-storage';
import RNFetchBlob from 'react-native-fetch-blob';
import NetInfo from '@react-native-community/netinfo';
import Geolocation from '@react-native-community/geolocation';
import { getBoundingBox } from '../utils/geoUtils';

SQLite.enablePromise(true);

const OfflineMapManager = ({ onProgressUpdate, children }) => {
  const [isConnected, setIsConnected] = useState(true);
  const [offlineAreas, setOfflineAreas] = useState([]);
  const [db, setDb] = useState(null);
  const [isDownloading, setIsDownloading] = useState(false);
  const [downloadProgress, setDownloadProgress] = useState(0);

  useEffect(() => {
    // Inicializar banco de dados
    const initDatabase = async () => {
      try {
        const database = await SQLite.openDatabase({
          name: 'offlineMaps.db',
          location: 'default'
        });
        
        // Criar tabelas se não existirem
        await database.executeSql(`
          CREATE TABLE IF NOT EXISTS offline_areas (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            min_lat REAL,
            min_lon REAL,
            max_lat REAL,
            max_lon REAL,
            min_zoom INTEGER,
            max_zoom INTEGER,
            created_at TEXT,
            updated_at TEXT
          );
        `);
        
        await database.executeSql(`
          CREATE TABLE IF NOT EXISTS map_tiles (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            area_id INTEGER,
            z INTEGER,
            x INTEGER,
            y INTEGER,
            tile_data BLOB,
            etag TEXT,
            FOREIGN KEY (area_id) REFERENCES offline_areas (id) ON DELETE CASCADE
          );
        `);
        
        await database.executeSql(`
          CREATE TABLE IF NOT EXISTS poi_data (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            area_id INTEGER,
            poi_id TEXT,
            category TEXT,
            name TEXT, 
            lat REAL,
            lon REAL,
            data TEXT,
            FOREIGN KEY (area_id) REFERENCES offline_areas (id) ON DELETE CASCADE
          );
        `);
        
        setDb(database);
        await loadOfflineAreas(database);
      } catch (error) {
        console.error('Erro ao inicializar banco de dados:', error);
        Alert.alert('Erro', 'Não foi possível inicializar o armazenamento offline');
      }
    };
    
    initDatabase();
    
    // Monitorar estado de conexão
    const unsubscribe = NetInfo.addEventListener(state => {
      setIsConnected(state.isConnected);
      
      if (state.isConnected) {
        console.log('Dispositivo online - verificando atualizações de mapas offline');
        syncOfflineMaps();
      } else {
        console.log('Dispositivo offline - usando dados em cache');
      }
    });
    
    return () => {
      unsubscribe();
      if (db) {
        db.close();
      }
    };
  }, []);

  // Carregar áreas offline salvas
  const loadOfflineAreas = async (database) => {
    try {
      const [results] = await database.executeSql('SELECT * FROM offline_areas ORDER BY created_at DESC');
      const areas = [];
      
      for (let i = 0; i < results.rows.length; i++) {
        areas.push(results.rows.item(i));
      }
      
      setOfflineAreas(areas);
    } catch (error) {
      console.error('Erro ao carregar áreas offline:', error);
    }
  };

  // Baixar nova área para uso offline
  const downloadAreaForOfflineUse = async (options) => {
    if (!db || !isConnected) {
      Alert.alert('Erro', 'Não é possível baixar mapas offline no momento');
      return;
    }
    
    try {
      setIsDownloading(true);
      setDownloadProgress(0);
      
      let bounds;
      
      if (options?.bounds) {
        bounds = options.bounds;
      } else {
        // Obter localização atual e calcular caixa delimitadora
        const position = await new Promise((resolve, reject) => {
          Geolocation.getCurrentPosition(
            pos => resolve(pos),
            err => reject(err),
            { enableHighAccuracy: true, timeout: 15000, maximumAge: 10000 }
          );
        });
        
        const { latitude, longitude } = position.coords;
        bounds = getBoundingBox({ latitude, longitude }, options?.radiusKm || 5);
      }
      
      const { minLat, minLon, maxLat, maxLon } = bounds;
      const minZoom = options?.minZoom || 10;
      const maxZoom = options?.maxZoom || 16;
      
      // Inserir nova área offline
      const [areaResult] = await db.executeSql(
        `INSERT INTO offline_areas 
         (name, min_lat, min_lon, max_lat, max_lon, min_zoom, max_zoom, created_at, updated_at) 
         VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`,
        [options?.name || 'Área Offline', minLat, minLon, maxLat, maxLon, minZoom, maxZoom]
      );
      
      const areaId = areaResult.insertId;
      
      // Calcular total de tiles para download
      const tiles = calculateTilesToDownload(bounds, minZoom, maxZoom);
      const totalTiles = tiles.length;
      
      if (totalTiles > 5000 && !options?.forceLargeDownload) {
        Alert.alert(
          'Aviso',
          `Esta área contém ${totalTiles} tiles e pode ocupar bastante espaço. Deseja continuar?`,
          [
            { text: 'Cancelar', style: 'cancel', onPress: () => {
              setIsDownloading(false);
              db.executeSql('DELETE FROM offline_areas WHERE id = ?', [areaId]);
            }},
            { text: 'Continuar', onPress: () => downloadTiles(tiles, areaId, totalTiles) }
          ]
        );
      } else {
        await downloadTiles(tiles, areaId, totalTiles);
      }
      
      // Baixar dados de POIs para a área
      await downloadPOIData(bounds, areaId);
      
      // Recarregar áreas offline
      await loadOfflineAreas(db);
      
      setIsDownloading(false);
      Alert.alert('Sucesso', 'Área offline baixada com sucesso!');
    } catch (error) {
      console.error('Erro ao baixar área offline:', error);
      Alert.alert('Erro', `Falha ao baixar área offline: ${error.message}`);
      setIsDownloading(false);
    }
  };

  // Função interna para baixar os tiles
  const downloadTiles = async (tiles, areaId, totalTiles) => {
    let downloaded = 0;
    const batchSize = 10; // Número de downloads paralelos
    
    for (let i = 0; i < tiles.length; i += batchSize) {
      const batch = tiles.slice(i, i + batchSize);
      await Promise.all(batch.map(async (tile) => {
        try {
          const { z, x, y } = tile;
          const tileUrl = `https://tile.openstreetmap.org/${z}/${x}/${y}.png`;
          
          const response = await RNFetchBlob.fetch('GET', tileUrl);
          const tileData = response.data;
          const etag = response.info().headers.ETag || '';
          
          await db.executeSql(
            `INSERT INTO map_tiles (area_id, z, x, y, tile_data, etag) VALUES (?, ?, ?, ?, ?, ?)`,
            [areaId, z, x, y, tileData, etag]
          );
        } catch (error) {
          console.warn(`Erro ao baixar tile: ${error.message}`);
        }
        
        downloaded++;
        const progress = Math.floor((downloaded / totalTiles) * 100);
        setDownloadProgress(progress);
        
        if (onProgressUpdate) {
          onProgressUpdate(progress);
        }
      }));
    }
  };

  // Sincronizar mapas offline quando online
  const syncOfflineMaps = async () => {
    if (!db || !isConnected) return;
    
    try {
      console.log('Sincronizando mapas offline...');
      
      // Verificar atualizações para tiles existentes baseado em ETags
      // Implementação detalhada omitida
      
      console.log('Sincronização de mapas concluída');
    } catch (error) {
      console.error('Erro ao sincronizar mapas offline:', error);
    }
  };

  // Verificar se uma posição está dentro de uma área offline
  const isPositionCovered = (position, zoom) => {
    const { latitude, longitude } = position;
    
    return offlineAreas.some(area => (
      latitude >= area.min_lat && 
      latitude <= area.max_lat && 
      longitude >= area.min_lon && 
      longitude <= area.max_lon &&
      zoom >= area.min_zoom &&
      zoom <= area.max_zoom
    ));
  };

  // Buscar um tile do armazenamento offline
  const getOfflineTile = async (z, x, y) => {
    if (!db) return null;
    
    try {
      const [results] = await db.executeSql(
        'SELECT tile_data FROM map_tiles WHERE z = ? AND x = ? AND y = ? LIMIT 1',
        [z, x, y]
      );
      
      if (results.rows.length > 0) {
        return results.rows.item(0).tile_data;
      }
      
      return null;
    } catch (error) {
      console.error('Erro ao buscar tile offline:', error);
      return null;
    }
  };

  return (
    
      {React.cloneElement(children, {
        isConnected,
        offlineAreas,
        isPositionCovered,
        getOfflineTile,
        downloadAreaForOfflineUse,
        isDownloading,
        downloadProgress
      })}
      
      {isDownloading && (
        
          {`Baixando mapa: ${downloadProgress}%`}
        
      )}
    
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1
  },
  progressContainer: {
    position: 'absolute',
    bottom: 20,
    left: 20,
    right: 20,
    backgroundColor: 'rgba(0,0,0,0.7)',
    padding: 10,
    borderRadius: 8
  },
  progressText: {
    color: 'white',
    textAlign: 'center'
  }
});

export default OfflineMapManager;