/**
 * 🎯 API DE RASCUNHOS DO ERP
 * 
 * Persistência de rascunhos no servidor para recuperação
 * em qualquer dispositivo/navegador.
 * 
 * ENDPOINTS:
 * - POST /rascunhos/sync - Sincronizar rascunhos
 * - GET /rascunhos/list - Listar rascunhos
 * - DELETE /rascunhos/:id - Deletar rascunho
 * - DELETE /rascunhos/clean - Limpar rascunhos expirados
 */

import { Hono } from "hono";
import * as kv from "./kv_store.tsx";

const rascunhosRouter = new Hono();

const TTL_DAYS = 7; // Rascunhos expiram após 7 dias

/**
 * 🔄 SINCRONIZAR RASCUNHOS (LOCAL → SERVIDOR)
 */
rascunhosRouter.post("/sync", async (c) => {
  try {
    const body = await c.req.json();
    const { usuarioId, empresaId, rascunhos } = body;

    if (!usuarioId || !empresaId || !Array.isArray(rascunhos)) {
      return c.json({
        success: false,
        error: "Parâmetros inválidos (usuarioId, empresaId, rascunhos obrigatórios)",
      }, 400);
    }

    console.log(`[Rascunhos] 🔄 Sincronizando ${rascunhos.length} rascunhos para ${usuarioId}`);

    let sincronizados = 0;
    let erros = 0;

    for (const rascunho of rascunhos) {
      try {
        // Verificar se o rascunho pertence ao usuário
        if (rascunho.usuarioId !== usuarioId || rascunho.empresaId !== empresaId) {
          console.warn(`[Rascunhos] ⚠️ Rascunho não pertence ao usuário: ${rascunho.id}`);
          continue;
        }

        // Chave no KV: rascunho:{empresaId}:{usuarioId}:{tipo}:{id}
        const key = `rascunho:${empresaId}:${usuarioId}:${rascunho.tipo}:${rascunho.id}`;

        // Verificar se já existe uma versão mais recente no servidor
        const existente = await kv.get(key);
        if (existente) {
          // Se versão existente for mais recente, pular
          if (existente.versao >= rascunho.versao && existente.timestamp >= rascunho.timestamp) {
            console.log(`[Rascunhos] ⏭️ Versão existente mais recente: ${rascunho.id} (v${existente.versao})`);
            continue;
          }
        }

        // Salvar no servidor
        await kv.set(key, {
          ...rascunho,
          sincronizadoEm: Date.now(),
        });

        sincronizados++;
      } catch (itemError: any) {
        console.error(`[Rascunhos] ❌ Erro ao sincronizar rascunho ${rascunho.id}:`, itemError);
        erros++;
      }
    }

    console.log(`[Rascunhos] ✅ Sincronização completa: ${sincronizados} salvos, ${erros} erros`);

    return c.json({
      success: true,
      sincronizados,
      erros,
    });
  } catch (error: any) {
    console.error("[Rascunhos] ❌ Erro ao sincronizar:", error);
    return c.json({
      success: false,
      error: error.message || "Erro ao sincronizar rascunhos",
    }, 500);
  }
});

/**
 * 📋 LISTAR RASCUNHOS DO USUÁRIO
 */
rascunhosRouter.get("/list", async (c) => {
  try {
    const usuarioId = c.req.query("usuarioId");
    const empresaId = c.req.query("empresaId");
    const tipo = c.req.query("tipo"); // Opcional

    if (!usuarioId || !empresaId) {
      return c.json({
        success: false,
        error: "Parâmetros inválidos (usuarioId e empresaId obrigatórios)",
      }, 400);
    }

    console.log(`[Rascunhos] 📋 Listando rascunhos para ${usuarioId} (empresa: ${empresaId})`);

    // Buscar todos os rascunhos do usuário na empresa
    const prefix = `rascunho:${empresaId}:${usuarioId}:`;
    const todosRascunhos = await kv.getByPrefix(prefix);

    // Filtrar por tipo se fornecido
    let rascunhos = todosRascunhos;
    if (tipo) {
      rascunhos = todosRascunhos.filter((r: any) => r.tipo === tipo);
    }

    // Filtrar expirados (TTL)
    const agora = Date.now();
    const rascunhosValidos = rascunhos.filter((r: any) => {
      const diasDesdeUltimoSalvamento = (agora - r.timestamp) / (1000 * 60 * 60 * 24);
      return diasDesdeUltimoSalvamento <= TTL_DAYS;
    });

    // Ordenar por timestamp (mais recente primeiro)
    rascunhosValidos.sort((a: any, b: any) => b.timestamp - a.timestamp);

    console.log(`[Rascunhos] ✅ ${rascunhosValidos.length} rascunhos encontrados`);

    return c.json({
      success: true,
      rascunhos: rascunhosValidos,
      total: rascunhosValidos.length,
    });
  } catch (error: any) {
    console.error("[Rascunhos] ❌ Erro ao listar:", error);
    return c.json({
      success: false,
      error: error.message || "Erro ao listar rascunhos",
    }, 500);
  }
});

/**
 * 🗑️ DELETAR RASCUNHO ESPECÍFICO
 */
rascunhosRouter.delete("/:id", async (c) => {
  try {
    const id = c.req.param("id");
    const usuarioId = c.req.query("usuarioId");
    const empresaId = c.req.query("empresaId");
    const tipo = c.req.query("tipo");

    if (!id || !usuarioId || !empresaId || !tipo) {
      return c.json({
        success: false,
        error: "Parâmetros inválidos (id, usuarioId, empresaId, tipo obrigatórios)",
      }, 400);
    }

    console.log(`[Rascunhos] 🗑️ Deletando rascunho: ${id}`);

    const key = `rascunho:${empresaId}:${usuarioId}:${tipo}:${id}`;
    await kv.del(key);

    console.log(`[Rascunhos] ✅ Rascunho deletado: ${id}`);

    return c.json({
      success: true,
      message: "Rascunho deletado com sucesso",
    });
  } catch (error: any) {
    console.error("[Rascunhos] ❌ Erro ao deletar:", error);
    return c.json({
      success: false,
      error: error.message || "Erro ao deletar rascunho",
    }, 500);
  }
});

/**
 * 🧹 LIMPAR RASCUNHOS EXPIRADOS (MANUTENÇÃO)
 */
rascunhosRouter.delete("/clean", async (c) => {
  try {
    const empresaId = c.req.query("empresaId");

    if (!empresaId) {
      return c.json({
        success: false,
        error: "empresaId obrigatório",
      }, 400);
    }

    console.log(`[Rascunhos] 🧹 Limpando rascunhos expirados da empresa: ${empresaId}`);

    // Buscar todos os rascunhos da empresa
    const prefix = `rascunho:${empresaId}:`;
    const todosRascunhos = await kv.getByPrefix(prefix);

    let removidos = 0;
    const agora = Date.now();

    for (const rascunho of todosRascunhos) {
      const diasDesdeUltimoSalvamento = (agora - rascunho.timestamp) / (1000 * 60 * 60 * 24);
      
      if (diasDesdeUltimoSalvamento > TTL_DAYS) {
        const key = `rascunho:${rascunho.empresaId}:${rascunho.usuarioId}:${rascunho.tipo}:${rascunho.id}`;
        await kv.del(key);
        removidos++;
      }
    }

    console.log(`[Rascunhos] ✅ ${removidos} rascunhos expirados removidos`);

    return c.json({
      success: true,
      removidos,
      message: `${removidos} rascunhos expirados foram removidos`,
    });
  } catch (error: any) {
    console.error("[Rascunhos] ❌ Erro ao limpar:", error);
    return c.json({
      success: false,
      error: error.message || "Erro ao limpar rascunhos expirados",
    }, 500);
  }
});

/**
 * 📊 OBTER ESTATÍSTICAS DE RASCUNHOS
 */
rascunhosRouter.get("/stats", async (c) => {
  try {
    const usuarioId = c.req.query("usuarioId");
    const empresaId = c.req.query("empresaId");

    if (!usuarioId || !empresaId) {
      return c.json({
        success: false,
        error: "Parâmetros inválidos (usuarioId e empresaId obrigatórios)",
      }, 400);
    }

    const prefix = `rascunho:${empresaId}:${usuarioId}:`;
    const rascunhos = await kv.getByPrefix(prefix);

    // Filtrar expirados
    const agora = Date.now();
    const rascunhosValidos = rascunhos.filter((r: any) => {
      const diasDesdeUltimoSalvamento = (agora - r.timestamp) / (1000 * 60 * 60 * 24);
      return diasDesdeUltimoSalvamento <= TTL_DAYS;
    });

    // Agrupar por tipo
    const porTipo: Record<string, number> = {};
    rascunhosValidos.forEach((r: any) => {
      porTipo[r.tipo] = (porTipo[r.tipo] || 0) + 1;
    });

    return c.json({
      success: true,
      total: rascunhosValidos.length,
      porTipo,
      ultimoSalvamento: rascunhosValidos.length > 0
        ? Math.max(...rascunhosValidos.map((r: any) => r.timestamp))
        : null,
    });
  } catch (error: any) {
    console.error("[Rascunhos] ❌ Erro ao obter estatísticas:", error);
    return c.json({
      success: false,
      error: error.message || "Erro ao obter estatísticas",
    }, 500);
  }
});

export default rascunhosRouter;