import { NextRequest, NextResponse } from "next/server";

export const runtime = "edge";

// Mapeamento dos tipos de coleção - corrigindo nomes das variáveis
const COLLECTION_MAP = {
  catalogo: process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_PRODUTOS_CATALOGO_ID,
  venda: process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_PRODUTOS_VENDA_ID,
  estoque: process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_PRODUTOS_ESTOQUE_ID,
};

export async function GET(request: NextRequest) {
  // Log de debug da API Key
  console.log("🔑 API KEY prefix:", process.env.APPWRITE_API_KEY?.slice(0, 10));
  
  try {
    // Extrair parâmetros da query
    const { searchParams } = new URL(request.url);
    const tipo = searchParams.get("tipo") || "catalogo"; // Default: catalogo
    const limit = Number(searchParams.get("limit")) || 10;
    const page = Number(searchParams.get("page")) || 1;
    const termoBuscado = searchParams.get("termoBuscado") || "";
    const empresaId = searchParams.get("empresaId") || "";
    const offset = (page - 1) * limit;

    console.log("📋 [API] Listando produtos...", {
      tipo,
      limit,
      page,
      termoBuscado,
      empresaId,
      offset
    });

    // Validar tipo de coleção
    if (!COLLECTION_MAP[tipo as keyof typeof COLLECTION_MAP]) {
      console.error("❌ [API] Tipo de coleção inválido:", tipo);
      return NextResponse.json(
        { 
          success: false, 
          error: "Tipo de coleção inválido", 
          details: `Tipos válidos: ${Object.keys(COLLECTION_MAP).join(", ")}` 
        },
        { status: 400 }
      );
    }

    // Verificar configurações obrigatórias
    const apiKey = process.env.APPWRITE_API_KEY;
    if (!apiKey) {
      console.error("❌ [API] APPWRITE_API_KEY não configurada");
      return NextResponse.json(
        { success: false, error: "Configuração do servidor ausente", details: "APPWRITE_API_KEY não configurada" },
        { status: 500 }
      );
    }

    const endpoint = process.env.NEXT_PUBLIC_APPWRITE_ENDPOINT;
    const projectId = process.env.NEXT_PUBLIC_APPWRITE_PROJECT_ID;
    const databaseId = process.env.NEXT_PUBLIC_APPWRITE_DATABASE_ID;
    const collectionId = COLLECTION_MAP[tipo as keyof typeof COLLECTION_MAP];

    if (!endpoint || !projectId || !databaseId || !collectionId) {
      console.error("❌ [API] Configurações do Appwrite ausentes");
      console.error("Debug config:", { 
        endpoint: !!endpoint, 
        projectId: !!projectId, 
        databaseId: !!databaseId, 
        collectionId: !!collectionId,
        tipo,
        availableCollections: Object.keys(COLLECTION_MAP)
      });
      return NextResponse.json(
        { 
          success: false, 
          error: "Configurações do Appwrite ausentes",
          details: { endpoint: !!endpoint, projectId: !!projectId, databaseId: !!databaseId, collectionId: !!collectionId }
        },
        { status: 500 }
      );
    }

    console.log("🎯 [API] Usando coleção:", { tipo, collectionId });
    console.log("🔧 [API] Headers que serão enviados:", {
      "X-Appwrite-Project": projectId,
      "X-Appwrite-Key": apiKey?.slice(0, 10) + "...",
      "Content-Type": "application/json"
    });

    // Construir URL da API do Appwrite
    const apiUrl = `${endpoint}/databases/${databaseId}/collections/${collectionId}/documents`;
    
    // Teste sem queries por enquanto devido ao bug do Appwrite 1.8.0
    console.log("⚠️ [API] Testando sem queries devido ao bug conhecido do Appwrite");
    console.log("🔍 [API] Parâmetros solicitados:", { limit, offset, empresaId, termoBuscado });
    
    const finalUrl = apiUrl;
    console.log("📡 [API] URL da requisição:", finalUrl);

    // Fazer requisição direta para a API do Appwrite
    const response = await fetch(finalUrl, {
      method: "GET",
      headers: {
        "Content-Type": "application/json",
        "X-Appwrite-Project": projectId,
        "X-Appwrite-Key": apiKey,
      },
      cache: "no-store"
    });

    console.log("📡 [API] Status da resposta:", response.status);

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));
      console.error("❌ [API] Erro na requisição:", response.status, errorData);
      console.error("🔍 [API] Headers enviados:", {
        "X-Appwrite-Project": projectId,
        "X-Appwrite-Key": apiKey?.slice(0, 10) + "...",
      });
      return NextResponse.json(
        {
          success: false,
          error: `Erro ao buscar produtos: ${response.status}`,
          details: errorData
        },
        { status: response.status }
      );
    }

    const data = await response.json();
    console.log("✅ [API] Dados recebidos:", {
      tipo,
      total: data.total,
      documentsCount: data.documents?.length || 0
    });

    // Log da estrutura dos primeiros documentos para debug
    if (data.documents && data.documents.length > 0) {
      console.log("🔍 [API] Estrutura do primeiro documento:", {
        id: data.documents[0].$id,
        keys: Object.keys(data.documents[0]),
        sample: {
          descricao: data.documents[0].descricao,
          codigoEan: data.documents[0]["codigo-ean"],
          codigoInterno: data.documents[0]["codigo-interno"],
          precoOriginal: data.documents[0]["preco-original"],
          precoAtual: data.documents[0]["preco-atual"],
          empresas: data.documents[0].empresas,
          quantidade: data.documents[0].quantidade
        }
      });
    }

    return NextResponse.json({
      success: true,
      tipo,
      documents: data.documents || [],
      total: data.total || 0
    });

  } catch (error) {
    console.error("💥 [API] Erro ao listar produtos:", error);
    return NextResponse.json(
      { 
        success: false, 
        error: "Erro interno do servidor",
        details: error instanceof Error ? error.message : String(error)
      },
      { status: 500 }
    );
  }
}

export async function POST(request: NextRequest) {
  // Log de debug da API Key
  console.log("🔑 API KEY prefix:", process.env.APPWRITE_API_KEY?.slice(0, 10));
  console.log("➕ [API] Criando novo produto na coleção produtos-venda...");

  try {
    // Verificar configurações obrigatórias
    const apiKey = process.env.APPWRITE_API_KEY;
    if (!apiKey) {
      console.error("❌ [API] APPWRITE_API_KEY não configurada");
      return NextResponse.json(
        { success: false, error: "Configuração do servidor ausente", details: "APPWRITE_API_KEY não configurada" },
        { status: 500 }
      );
    }

    const endpoint = process.env.NEXT_PUBLIC_APPWRITE_ENDPOINT;
    const projectId = process.env.NEXT_PUBLIC_APPWRITE_PROJECT_ID;
    const databaseId = process.env.NEXT_PUBLIC_APPWRITE_DATABASE_ID;
    const collectionId = process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_PRODUTOS_VENDA_ID;

    if (!endpoint || !projectId || !databaseId || !collectionId) {
      console.error("❌ [API] Configurações do Appwrite ausentes");
      return NextResponse.json(
        { 
          success: false, 
          error: "Configurações do Appwrite ausentes",
          details: { endpoint: !!endpoint, projectId: !!projectId, databaseId: !!databaseId, collectionId: !!collectionId }
        },
        { status: 500 }
      );
    }

    console.log("🔧 [API] Headers que serão enviados:", {
      "X-Appwrite-Project": projectId,
      "X-Appwrite-Key": apiKey?.slice(0, 10) + "...",
      "Content-Type": "application/json"
    });

    const body = await request.json();
    console.log("📤 [API] Dados recebidos:", body);

    // Preparar dados para criação
    const createData = body.data || body;
    console.log("📝 [API] Dados preparados para criação:", createData);

    // Construir URL da API do Appwrite
    const apiUrl = `${endpoint}/databases/${databaseId}/collections/${collectionId}/documents`;
    console.log("📡 [API] URL da criação:", apiUrl);

    const response = await fetch(apiUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-Appwrite-Project": projectId,
        "X-Appwrite-Key": apiKey,
      },
      body: JSON.stringify(createData),
    });

    console.log("📡 [API] Status da criação:", response.status);

    if (response.status === 201 || response.status === 409) {
      const data = await response.json();
      console.log("✅ [API] Produto criado com sucesso!");
      return NextResponse.json({ success: true, data });
    } else {
      const errorData = await response.json().catch(() => ({}));
      console.error("❌ [API] Erro ao criar:", response.status, errorData);
      console.error("🔍 [API] Headers enviados:", {
        "X-Appwrite-Project": projectId,
        "X-Appwrite-Key": apiKey?.slice(0, 10) + "...",
      });
      return NextResponse.json(
        {
          success: false,
          error: errorData.message || "Erro ao criar produto",
          details: errorData,
        },
        { status: response.status }
      );
    }
  } catch (error) {
    console.error("💥 [API] Erro na criação:", error);
    return NextResponse.json(
      { 
        success: false, 
        error: "Erro interno do servidor",
        details: error instanceof Error ? error.message : String(error)
      },
      { status: 500 }
    );
  }
}
