"use client";

import { useState } from "react";
import { getCurrentUserWithRetry } from "@/lib/appwrite";

const ComparacaoConsultaPage = () => {
  const [resultado, setResultado] = useState<any>(null);
  const [loading, setLoading] = useState(false);

  const compararConsultas = async () => {
    setLoading(true);
    const comparacao: any = {
      timestamp: new Date().toISOString(),
      etapas: [],
      dados: {},
    };

    try {
      // 1. Verificar usuário autenticado
      comparacao.etapas.push("🔍 1. Verificando usuário autenticado...");
      const user = await getCurrentUserWithRetry();

      if (!user) {
        comparacao.etapas.push("❌ Usuário não autenticado");
        setResultado(comparacao);
        setLoading(false);
        return;
      }

      comparacao.etapas.push(
        `✅ Usuário autenticado: ${user.name} (${user.$id})`
      );

      // 2. Consulta via SDK (método atual)
      comparacao.etapas.push("📚 2. Consultando via SDK (método atual)...");

      try {
        const { databases, Query } = await import("@/lib/appwrite");

        const databaseId = process.env.NEXT_PUBLIC_APPWRITE_DATABASE_ID!;
        const collectionId =
          process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_USUARIOS_ID!;

        const sdkResponse = await databases.listDocuments(
          databaseId,
          collectionId,
          [Query.equal("auth-id-appwrite", user.$id), Query.limit(1)]
        );

        if (sdkResponse.documents.length > 0) {
          const userDoc = sdkResponse.documents[0];
          comparacao.etapas.push(`✅ SDK: Usuário encontrado (${userDoc.$id})`);
          comparacao.dados.sdk = {
            success: true,
            id: userDoc.$id,
            nomeCivil: userDoc["nome-civil"],
            enderecos: userDoc.enderecos || [],
            empresas: userDoc.empresas || [],
            total: sdkResponse.total,
            updatedAt: userDoc.$updatedAt,
          };
        } else {
          comparacao.etapas.push("❌ SDK: Usuário não encontrado");
          comparacao.dados.sdk = {
            success: false,
            total: sdkResponse.total,
          };
        }
      } catch (sdkError: any) {
        comparacao.etapas.push(`💥 SDK: Erro - ${sdkError.message}`);
        comparacao.dados.sdk = {
          success: false,
          error: sdkError.message,
        };
      }

      // 3. Consulta via API HTTP (mesmo método usado para atualizar)
      comparacao.etapas.push(
        "🌐 3. Consultando via API HTTP (método da atualização)..."
      );

      try {
        const apiUrl = `${process.env
          .NEXT_PUBLIC_APPWRITE_ENDPOINT!}/databases/${process.env
          .NEXT_PUBLIC_APPWRITE_DATABASE_ID!}/collections/${process.env
          .NEXT_PUBLIC_APPWRITE_COLLECTION_USUARIOS_ID!}/documents`;

        const apiResponse = await fetch(apiUrl, {
          method: "GET",
          headers: {
            "Content-Type": "application/json",
            "X-Appwrite-Project": process.env.NEXT_PUBLIC_APPWRITE_PROJECT_ID!,
          },
        });

        if (apiResponse.ok) {
          const apiData = await apiResponse.json();

          // Buscar o usuário específico
          const userDoc = apiData.documents.find(
            (doc: any) => doc["auth-id-appwrite"] === user.$id
          );

          if (userDoc) {
            comparacao.etapas.push(
              `✅ API: Usuário encontrado (${userDoc.$id})`
            );
            comparacao.dados.api = {
              success: true,
              id: userDoc.$id,
              nomeCivil: userDoc["nome-civil"],
              enderecos: userDoc.enderecos || [],
              empresas: userDoc.empresas || [],
              total: apiData.total,
              updatedAt: userDoc.$updatedAt,
            };
          } else {
            comparacao.etapas.push("❌ API: Usuário não encontrado");
            comparacao.dados.api = {
              success: false,
              total: apiData.total,
              allUsers: apiData.documents.map((doc: any) => ({
                id: doc.$id,
                authId: doc["auth-id-appwrite"],
              })),
            };
          }
        } else {
          const errorData = await apiResponse.json();
          comparacao.etapas.push(`❌ API: Erro HTTP ${apiResponse.status}`);
          comparacao.dados.api = {
            success: false,
            status: apiResponse.status,
            error: errorData,
          };
        }
      } catch (apiError: any) {
        comparacao.etapas.push(`💥 API: Erro - ${apiError.message}`);
        comparacao.dados.api = {
          success: false,
          error: apiError.message,
        };
      }

      // 4. Comparação e análise
      comparacao.etapas.push("📊 4. Análise comparativa...");

      const sdkSuccess = comparacao.dados.sdk?.success;
      const apiSuccess = comparacao.dados.api?.success;

      if (sdkSuccess && apiSuccess) {
        // Comparar dados
        const sdkEnderecos = comparacao.dados.sdk.enderecos.length;
        const apiEnderecos = comparacao.dados.api.enderecos.length;
        const sdkEmpresas = comparacao.dados.sdk.empresas.length;
        const apiEmpresas = comparacao.dados.api.empresas.length;

        if (sdkEnderecos === apiEnderecos && sdkEmpresas === apiEmpresas) {
          comparacao.etapas.push("✅ Ambos métodos retornaram dados idênticos");
        } else {
          comparacao.etapas.push(
            `⚠️ Dados diferentes: SDK(${sdkEnderecos}/${sdkEmpresas}) vs API(${apiEnderecos}/${apiEmpresas})`
          );
        }

        // Comparar timestamps
        const sdkTime = new Date(comparacao.dados.sdk.updatedAt).getTime();
        const apiTime = new Date(comparacao.dados.api.updatedAt).getTime();

        if (sdkTime === apiTime) {
          comparacao.etapas.push(
            "✅ Timestamps idênticos - dados sincronizados"
          );
        } else {
          const diff = Math.abs(sdkTime - apiTime) / 1000;
          comparacao.etapas.push(
            `⚠️ Diferença de tempo: ${diff}s entre SDK e API`
          );
        }
      } else if (sdkSuccess && !apiSuccess) {
        comparacao.etapas.push(
          "🔍 SDK encontrou dados, mas API não - possível problema de permissões na API"
        );
      } else if (!sdkSuccess && apiSuccess) {
        comparacao.etapas.push(
          "🔍 API encontrou dados, mas SDK não - possível problema no SDK"
        );
      } else {
        comparacao.etapas.push(
          "❌ Nenhum método encontrou o usuário - problema de dados"
        );
      }
    } catch (error: any) {
      comparacao.etapas.push(`💥 ERRO GERAL: ${error.message}`);
    }

    setResultado(comparacao);
    setLoading(false);
  };

  return (
    <div className="min-h-screen bg-gray-50 p-4">
      <div className="max-w-4xl mx-auto">
        <div className="bg-white rounded-lg shadow-lg p-6">
          <h1 className="text-2xl font-bold mb-4">
            🔍 Comparação de Consultas
          </h1>
          <p className="text-gray-600 mb-6">
            Compara a consulta via SDK (usada no useAuthGuard) vs API HTTP
            (usada para atualizações)
          </p>

          <div className="space-x-2 mb-6">
            <button
              onClick={compararConsultas}
              disabled={loading}
              className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
            >
              {loading ? "⏳ Comparando..." : "🔍 Comparar Consultas"}
            </button>

            <a
              href="/teste-criacao"
              className="inline-block px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700"
            >
              🧪 Teste de Criação
            </a>

            <a
              href="/diagnostico"
              className="inline-block px-4 py-2 bg-purple-600 text-white rounded hover:bg-purple-700"
            >
              🔬 Diagnóstico
            </a>
          </div>

          {resultado && (
            <div className="space-y-4">
              {/* Log de execução */}
              <div className="bg-gray-900 text-green-400 p-4 rounded font-mono text-sm max-h-96 overflow-y-auto">
                <h3 className="text-white mb-2">📝 Log de Comparação:</h3>
                {resultado.etapas.map((etapa: string, index: number) => (
                  <div key={index}>{etapa}</div>
                ))}
              </div>

              {/* Comparação lado a lado */}
              <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
                <div className="bg-blue-50 p-4 rounded">
                  <h3 className="font-bold mb-2 text-blue-800">
                    📚 Consulta via SDK:
                  </h3>
                  <pre className="text-xs overflow-auto max-h-64 bg-white p-2 rounded border">
                    {JSON.stringify(resultado.dados.sdk, null, 2)}
                  </pre>
                </div>

                <div className="bg-green-50 p-4 rounded">
                  <h3 className="font-bold mb-2 text-green-800">
                    🌐 Consulta via API HTTP:
                  </h3>
                  <pre className="text-xs overflow-auto max-h-64 bg-white p-2 rounded border">
                    {JSON.stringify(resultado.dados.api, null, 2)}
                  </pre>
                </div>
              </div>
            </div>
          )}
        </div>
      </div>
    </div>
  );
};

export default ComparacaoConsultaPage;
