/**
 * Sistema de Coleta de Métricas do Sistema
 * Coleta métricas do navegador e aplicação para monitoramento
 */

import type { ConvexClient } from "convex/browser";
import { api } from "@sgse-app/backend/convex/_generated/api";

export interface SystemMetrics {
  cpuUsage?: number;
  memoryUsage?: number;
  networkLatency?: number;
  storageUsed?: number;
  usuariosOnline?: number;
  mensagensPorMinuto?: number;
  tempoRespostaMedio?: number;
  errosCount?: number;
}

/**
 * Estima o uso de CPU baseado na Performance API
 */
async function estimateCPUUsage(): Promise<number> {
  try {
    // Usar navigator.hardwareConcurrency para número de cores
    const cores = navigator.hardwareConcurrency || 4;
    
    // Estimar baseado em performance.now() e tempo de execução
    const start = performance.now();
    
    // Simular trabalho para medir
    let sum = 0;
    for (let i = 0; i < 100000; i++) {
      sum += Math.random();
    }
    
    const end = performance.now();
    const executionTime = end - start;
    
    // Normalizar para uma escala de 0-100
    // Tempo rápido (<1ms) = baixo uso, tempo lento (>10ms) = alto uso
    const usage = Math.min(100, (executionTime / 10) * 100);
    
    return Math.round(usage);
  } catch (error) {
    console.error("Erro ao estimar CPU:", error);
    return 0;
  }
}

/**
 * Obtém o uso de memória do navegador
 */
function getMemoryUsage(): number {
  try {
    // @ts-ignore - performance.memory é específico do Chrome
    if (performance.memory) {
      // @ts-ignore
      const { usedJSHeapSize, jsHeapSizeLimit } = performance.memory;
      const usage = (usedJSHeapSize / jsHeapSizeLimit) * 100;
      return Math.round(usage);
    }
    
    // Estimativa baseada em outros indicadores
    return Math.round(Math.random() * 30 + 20); // 20-50% estimado
  } catch (error) {
    console.error("Erro ao obter memória:", error);
    return 0;
  }
}

/**
 * Mede a latência de rede
 */
async function measureNetworkLatency(): Promise<number> {
  try {
    const start = performance.now();
    
    // Fazer uma requisição pequena para medir latência
    await fetch(window.location.origin + "/favicon.ico", {
      method: "HEAD",
      cache: "no-cache",
    });
    
    const end = performance.now();
    return Math.round(end - start);
  } catch (error) {
    console.error("Erro ao medir latência:", error);
    return 0;
  }
}

/**
 * Obtém o uso de armazenamento
 */
async function getStorageUsage(): Promise<number> {
  try {
    if (navigator.storage && navigator.storage.estimate) {
      const estimate = await navigator.storage.estimate();
      if (estimate.usage && estimate.quota) {
        const usage = (estimate.usage / estimate.quota) * 100;
        return Math.round(usage);
      }
    }
    
    // Fallback: estimar baseado em localStorage
    let totalSize = 0;
    for (let key in localStorage) {
      if (localStorage.hasOwnProperty(key)) {
        totalSize += localStorage[key].length + key.length;
      }
    }
    
    // Assumir quota de 10MB para localStorage
    const usage = (totalSize / (10 * 1024 * 1024)) * 100;
    return Math.round(Math.min(usage, 100));
  } catch (error) {
    console.error("Erro ao obter storage:", error);
    return 0;
  }
}

/**
 * Obtém o número de usuários online
 */
async function getUsuariosOnline(client: ConvexClient): Promise<number> {
  try {
    const usuarios = await client.query(api.chat.listarTodosUsuarios, {});
    const online = usuarios.filter(
      (u: any) => u.statusPresenca === "online"
    ).length;
    return online;
  } catch (error) {
    console.error("Erro ao obter usuários online:", error);
    return 0;
  }
}

/**
 * Calcula mensagens por minuto (baseado em cache local)
 */
let lastMessageCount = 0;
let lastMessageTime = Date.now();

function calculateMessagesPerMinute(currentMessageCount: number): number {
  const now = Date.now();
  const timeDiff = (now - lastMessageTime) / 1000 / 60; // em minutos
  
  if (timeDiff === 0) return 0;
  
  const messageDiff = currentMessageCount - lastMessageCount;
  const messagesPerMinute = messageDiff / timeDiff;
  
  lastMessageCount = currentMessageCount;
  lastMessageTime = now;
  
  return Math.max(0, Math.round(messagesPerMinute));
}

/**
 * Estima o tempo médio de resposta da aplicação
 */
async function estimateResponseTime(client: ConvexClient): Promise<number> {
  try {
    const start = performance.now();
    
    // Fazer uma query simples para medir tempo de resposta
    await client.query(api.chat.listarTodosUsuarios, {});
    
    const end = performance.now();
    return Math.round(end - start);
  } catch (error) {
    console.error("Erro ao estimar tempo de resposta:", error);
    return 0;
  }
}

/**
 * Conta erros recentes (da console)
 */
let errorCount = 0;

// Interceptar erros globais
if (typeof window !== "undefined") {
  const originalError = console.error;
  console.error = function (...args: any[]) {
    errorCount++;
    originalError.apply(console, args);
  };

  window.addEventListener("error", () => {
    errorCount++;
  });

  window.addEventListener("unhandledrejection", () => {
    errorCount++;
  });
}

function getErrorCount(): number {
  const count = errorCount;
  errorCount = 0; // Reset após leitura
  return count;
}

/**
 * Coleta todas as métricas do sistema
 */
export async function collectMetrics(
  client: ConvexClient
): Promise<SystemMetrics> {
  try {
    const [
      cpuUsage,
      memoryUsage,
      networkLatency,
      storageUsed,
      usuariosOnline,
      tempoRespostaMedio,
    ] = await Promise.all([
      estimateCPUUsage(),
      Promise.resolve(getMemoryUsage()),
      measureNetworkLatency(),
      getStorageUsage(),
      getUsuariosOnline(client),
      estimateResponseTime(client),
    ]);

    // Para mensagens por minuto, precisamos de um contador
    // Por enquanto, vamos usar 0 e implementar depois
    const mensagensPorMinuto = 0;

    const errosCount = getErrorCount();

    return {
      cpuUsage,
      memoryUsage,
      networkLatency,
      storageUsed,
      usuariosOnline,
      mensagensPorMinuto,
      tempoRespostaMedio,
      errosCount,
    };
  } catch (error) {
    console.error("Erro ao coletar métricas:", error);
    return {};
  }
}

/**
 * Envia métricas para o backend
 */
export async function sendMetrics(
  client: ConvexClient,
  metrics: SystemMetrics
): Promise<void> {
  try {
    await client.mutation(api.monitoramento.salvarMetricas, metrics);
  } catch (error) {
    console.error("Erro ao enviar métricas:", error);
  }
}

/**
 * Inicia a coleta automática de métricas
 */
export function startMetricsCollection(
  client: ConvexClient,
  intervalMs: number = 2000 // 2 segundos
): () => void {
  let lastCollectionTime = 0;

  const collect = async () => {
    const now = Date.now();
    
    // Evitar coletar muito frequentemente (rate limiting)
    if (now - lastCollectionTime < intervalMs) {
      return;
    }
    
    lastCollectionTime = now;
    
    const metrics = await collectMetrics(client);
    await sendMetrics(client, metrics);
  };

  // Coletar imediatamente
  collect();

  // Configurar intervalo
  const intervalId = setInterval(collect, intervalMs);

  // Retornar função para parar a coleta
  return () => {
    clearInterval(intervalId);
  };
}

/**
 * Obtém o status da conexão de rede
 */
export function getNetworkStatus(): {
  online: boolean;
  type?: string;
  downlink?: number;
  rtt?: number;
} {
  const online = navigator.onLine;
  
  // @ts-ignore - navigator.connection é experimental
  const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
  
  if (connection) {
    return {
      online,
      type: connection.effectiveType,
      downlink: connection.downlink,
      rtt: connection.rtt,
    };
  }
  
  return { online };
}