import React, { useState, useEffect } from 'react';
import { AlertTriangle, RefreshCw, CheckCircle, XCircle } from 'lucide-react';
import { useAppDispatch } from '@/store/hooks';
import { searchEntreprise } from '@/store/features/entreprise/thunk';
import { Client } from '@/types/clientType';
import { EntrepriseResponse } from '@/types/entreprise';
import { motion, AnimatePresence } from 'framer-motion';
import { useNavigate } from 'react-router-dom';

interface ClientInfoVerifierProps {
  client: Client;
}

interface VerificationResult {
  isValid: boolean;
  issues: string[];
  hasOfficialData: boolean;
  needsUpdate: boolean;
}

export const ClientInfoVerifier: React.FC<ClientInfoVerifierProps> = ({ client }) => {
  const dispatch = useAppDispatch();
  const navigate = useNavigate();
  
  const [isChecking, setIsChecking] = useState(false);
  const [verificationResult, setVerificationResult] = useState<VerificationResult | null>(null);
  const [showDetails, setShowDetails] = useState(false);

  // Vérifier automatiquement au chargement
  useEffect(() => {
    checkClientInfo();
  }, [client.numero]);

  const checkClientInfo = async () => {
    setIsChecking(true);
    
    try {
      const issues: string[] = [];
      let hasOfficialData = false;
      
      // 1. Vérifier les champs requis
      if (!client.intitule || client.intitule.trim().length === 0) {
        issues.push("Raison sociale manquante");
      }
      
      if (!client.siret || client.siret.length !== 14) {
        issues.push("SIRET invalide ou manquant");
      }
      
      if (!client.adresse || client.adresse.trim().length === 0) {
        issues.push("Adresse manquante");
      }
      
      if (!client.code_postal || client.code_postal.length !== 5) {
        issues.push("Code postal invalide ou manquant");
      }
      
      if (!client.ville || client.ville.trim().length === 0) {
        issues.push("Ville manquante");
      }

      // 2. Rechercher l'entreprise dans la base officielle
      let searchQuery = "";
      
      if (client.siret && client.siret.length === 14) {
        searchQuery = client.siret;
      } else if (client.intitule) {
        searchQuery = client.intitule;
      }

      if (searchQuery) {
        try {
          const response = await dispatch(searchEntreprise(searchQuery)).unwrap() as EntrepriseResponse;
          
          if (response.results && response.results.length > 0) {
            hasOfficialData = true;
            const officialData = response.results[0];
            
            // Vérifier les divergences avec les données officielles
            if (client.siret && officialData.siret_siege) {
              if (client.siret !== officialData.siret_siege.replace(/\s/g, '')) {
                issues.push("SIRET différent des données officielles");
              }
            }
            
            if (client.intitule && officialData.company_name) {
              // Vérifier si les noms sont très différents
              const similarity = calculateSimilarity(
                client.intitule.toLowerCase(),
                officialData.company_name.toLowerCase()
              );
              
              if (similarity < 0.6) {
                issues.push("Raison sociale différente des données officielles");
              }
            }
            
            if (client.adresse && officialData.address) {
              const similarity = calculateSimilarity(
                client.adresse.toLowerCase(),
                officialData.address.toLowerCase()
              );
              
              if (similarity < 0.5) {
                issues.push("Adresse différente des données officielles");
              }
            }
            
            if (client.code_postal && officialData.code_postal) {
              if (client.code_postal !== officialData.code_postal) {
                issues.push("Code postal différent des données officielles");
              }
            }
            
            if (client.ville && officialData.ville) {
              if (client.ville.toLowerCase() !== officialData.ville.toLowerCase()) {
                issues.push("Ville différente des données officielles");
              }
            }

            // Vérifier si l'entreprise est active
            if (officialData.is_active === false && client.est_actif === true) {
              issues.push("L'entreprise est marquée inactive dans les registres officiels");
            }
          } else {
            issues.push("Entreprise non trouvée dans les registres officiels");
          }
        } catch (error) {
          console.error("Erreur lors de la vérification:", error);
          issues.push("Impossible de vérifier les données officielles");
        }
      }

      // 3. Déterminer si une mise à jour est nécessaire
      const needsUpdate = issues.length > 0;
      
      setVerificationResult({
        isValid: !needsUpdate,
        issues,
        hasOfficialData,
        needsUpdate,
      });
      
    } catch (error) {
      console.error("Erreur lors de la vérification:", error);
      setVerificationResult({
        isValid: false,
        issues: ["Erreur lors de la vérification des informations"],
        hasOfficialData: false,
        needsUpdate: true,
      });
    } finally {
      setIsChecking(false);
    }
  };

  // Fonction pour calculer la similarité entre deux chaînes (algorithme de Levenshtein simplifié)
  const calculateSimilarity = (str1: string, str2: string): number => {
    const longer = str1.length > str2.length ? str1 : str2;
    const shorter = str1.length > str2.length ? str2 : str1;
    
    if (longer.length === 0) return 1.0;
    
    const editDistance = levenshteinDistance(longer, shorter);
    return (longer.length - editDistance) / longer.length;
  };

  const levenshteinDistance = (str1: string, str2: string): number => {
    const matrix: number[][] = [];

    for (let i = 0; i <= str2.length; i++) {
      matrix[i] = [i];
    }

    for (let j = 0; j <= str1.length; j++) {
      matrix[0][j] = j;
    }

    for (let i = 1; i <= str2.length; i++) {
      for (let j = 1; j <= str1.length; j++) {
        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
          matrix[i][j] = matrix[i - 1][j - 1];
        } else {
          matrix[i][j] = Math.min(
            matrix[i - 1][j - 1] + 1,
            matrix[i][j - 1] + 1,
            matrix[i - 1][j] + 1
          );
        }
      }
    }

    return matrix[str2.length][str1.length];
  };

  const handleUpdateInfo = () => {
    navigate(`/home/clients/${client.numero}/edit`);
  };

  // Ne rien afficher si la vérification n'est pas terminée ou si tout est OK
  if (isChecking || !verificationResult) {
    return null;
  }

  if (verificationResult.isValid) {
    return null;
  }

  return (
    <div className="flex flex-col gap-2">
      {/* Bouton principal */}
      <button
        onClick={() => setShowDetails(!showDetails)}
        className="flex items-center gap-2 px-4 py-2 bg-amber-50 dark:bg-amber-900/20 border border-amber-200 dark:border-amber-800 rounded-xl text-sm font-medium text-amber-700 dark:text-amber-300 hover:bg-amber-100 dark:hover:bg-amber-900/30 transition-colors"
      >
        <AlertTriangle className="w-4 h-4" />
        <span>Informations à vérifier ({verificationResult.issues.length})</span>
      </button>

      {/* Détails des problèmes */}
      <AnimatePresence>
        {showDetails && (
          <motion.div
            initial={{ opacity: 0, height: 0 }}
            animate={{ opacity: 1, height: "auto" }}
            exit={{ opacity: 0, height: 0 }}
            className="overflow-hidden"
          >
            <div className="bg-white dark:bg-gray-950 border border-amber-200 dark:border-amber-800 rounded-xl p-4 space-y-3">
              <div className="flex items-start justify-between">
                <div>
                  <h4 className="text-sm font-semibold text-gray-900 dark:text-white mb-2">
                    Problèmes détectés :
                  </h4>
                  <ul className="space-y-1">
                    {verificationResult.issues.map((issue, index) => (
                      <li key={index} className="flex items-start gap-2 text-xs text-gray-600 dark:text-gray-400">
                        <XCircle className="w-3 h-3 text-red-500 flex-shrink-0 mt-0.5" />
                        <span>{issue}</span>
                      </li>
                    ))}
                  </ul>
                </div>
              </div>

              <div className="flex gap-2 pt-2 border-t border-amber-100 dark:border-amber-900">
                <button
                  onClick={handleUpdateInfo}
                  className="flex items-center gap-2 px-4 py-2 bg-[#007E45] text-white rounded-lg text-sm font-medium hover:bg-[#006837] transition-colors"
                >
                  <RefreshCw className="w-4 h-4" />
                  Mettre à jour les informations
                </button>
                <button
                  onClick={() => setShowDetails(false)}
                  className="px-4 py-2 text-sm font-medium text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-white transition-colors"
                >
                  Ignorer
                </button>
              </div>
            </div>
          </motion.div>
        )}
      </AnimatePresence>
    </div>
  );
};

export default ClientInfoVerifier;