mdb/app/hooks/useAnalyse.ts

import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';

import { getCurrentUserId, pb } from '@/services/pocketbase';
import type { AnalyseFinanciereRecord, TypeBienFiscal } from '@/types/collections';
import { roundMoney } from '@/utils/format';

export type AnalyseFormInput = {
  prix_achat?: number;
  type_bien_fiscal?: TypeBienFiscal;
  frais_notaire?: number;
  frais_agence_achat?: number;
  budget_travaux?: number;
  reserve_imprevus_pct?: number;
  duree_portage_mois?: number;
  taux_credit?: number;
  taxe_fonciere_annuelle?: number;
  charges_copropriete_mensuelle?: number;
  prix_revente_cible?: number;
  /** Prix de revente estimé au m² (marché). */
  prix_revente_m2?: number;
  frais_agence_vente_pct?: number;
  taux_impot?: number;
};

export type AnalyseCalculated = {
  frais_notaire: number;
  travaux_total: number;
  frais_portage_total: number;
  prix_revient: number;
  marge_brute: number;
  marge_nette: number;
  marge_brute_pct: number;
  marge_nette_pct: number;
  rendement_net_pct: number;
};

export function calculateResults(data: AnalyseFormInput): AnalyseCalculated {
  const prixAchat = data.prix_achat ?? 0;
  const typeFiscal = data.type_bien_fiscal ?? 'ancien';
  const fraisNotaireAuto = prixAchat * (typeFiscal === 'neuf' ? 0.02 : 0.075);
  const fraisNotaire = data.frais_notaire ?? fraisNotaireAuto;

  const budgetTravaux = data.budget_travaux ?? 0;
  const reservePct = data.reserve_imprevus_pct ?? 0;
  const travauxTotal = budgetTravaux * (1 + reservePct / 100);

  const tauxCredit = data.taux_credit ?? 0;
  const taxeFon = data.taxe_fonciere_annuelle ?? 0;
  const charges = data.charges_copropriete_mensuelle ?? 0;
  const dureeMois = data.duree_portage_mois ?? 0;
  const mensualiteCredit = (prixAchat * (tauxCredit / 100)) / 12;
  const mensualiteFoncier = taxeFon / 12;
  const fraisPortageTotal = (mensualiteCredit + mensualiteFoncier + charges) * dureeMois;

  const fraisAgenceAchat = data.frais_agence_achat ?? 0;
  const prixRevient = prixAchat + fraisNotaire + fraisAgenceAchat + travauxTotal + fraisPortageTotal;

  const prixRevente = data.prix_revente_cible ?? 0;
  const margeBrute = prixRevente - prixRevient;

  const fraisAgenceVentePct = data.frais_agence_vente_pct ?? 0;
  const tauxImpot = data.taux_impot ?? 0;
  const fraisAgenceVente = prixRevente * (fraisAgenceVentePct / 100);
  const impotSurMarge = margeBrute * (tauxImpot / 100);
  const margeNette = margeBrute - fraisAgenceVente - impotSurMarge;

  const margeBrutePct = prixRevient > 0 ? (margeBrute / prixRevient) * 100 : 0;
  const margeNettePct = prixRevente > 0 ? (margeNette / prixRevente) * 100 : 0;
  const rendementNetPct = prixRevient > 0 ? (margeNette / prixRevient) * 100 : 0;

  return {
    frais_notaire: roundMoney(fraisNotaire),
    travaux_total: roundMoney(travauxTotal),
    frais_portage_total: roundMoney(fraisPortageTotal),
    prix_revient: roundMoney(prixRevient),
    marge_brute: roundMoney(margeBrute),
    marge_nette: roundMoney(margeNette),
    marge_brute_pct: roundMoney(margeBrutePct),
    marge_nette_pct: roundMoney(margeNettePct),
    rendement_net_pct: roundMoney(rendementNetPct),
  };
}

export function rendementColor(rendementNetPct: number): string {
  if (rendementNetPct > 15) return '#16A34A';
  if (rendementNetPct >= 8) return '#EA580C';
  return '#DC2626';
}

function formToRecord(form: AnalyseFormInput, calc: AnalyseCalculated): Record<string, unknown> {
  return {
    prix_achat: form.prix_achat,
    type_bien_fiscal: form.type_bien_fiscal,
    frais_notaire: calc.frais_notaire,
    frais_agence_achat: form.frais_agence_achat,
    budget_travaux: form.budget_travaux,
    reserve_imprevus_pct: form.reserve_imprevus_pct,
    duree_portage_mois: form.duree_portage_mois,
    taux_credit: form.taux_credit,
    taxe_fonciere_annuelle: form.taxe_fonciere_annuelle,
    charges_copropriete_mensuelle: form.charges_copropriete_mensuelle,
    prix_revente_cible: form.prix_revente_cible,
    ...(form.prix_revente_m2 !== undefined && form.prix_revente_m2 !== null
      ? { prix_revente_m2: form.prix_revente_m2 }
      : {}),
    frais_agence_vente_pct: form.frais_agence_vente_pct,
    taux_impot: form.taux_impot,
    marge_brute: calc.marge_brute,
    marge_brute_pct: calc.marge_brute_pct,
    marge_nette: calc.marge_nette,
    marge_nette_pct: calc.marge_nette_pct,
  };
}

export function useAnalyse(bienId: string | undefined) {
  const uid = getCurrentUserId();
  const queryClient = useQueryClient();

  const query = useQuery({
    queryKey: ['analyse_financiere', bienId, uid],
    queryFn: async (): Promise<AnalyseFinanciereRecord | null> => {
      if (!bienId || !uid) return null;
      const res = await pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
        filter: `bien="${bienId}" && user="${uid}"`,
        sort: '-id',
      });
      return res.items[0] ?? null;
    },
    enabled: Boolean(bienId && uid),
  });

  const saveMutation = useMutation({
    mutationFn: async (data: AnalyseFormInput & { notes?: string }) => {
      if (!bienId || !uid) throw new Error('Données manquantes');
      const res = await pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
        filter: `bien="${bienId}" && user="${uid}"`,
        sort: '-id',
      });
      const existing = res.items[0];
      const calc = calculateResults(data);
      const payload = {
        ...formToRecord(data, calc),
        notes: data.notes,
      };
      if (existing) {
        return pb.collection('analyses_financieres').update<AnalyseFinanciereRecord>(existing.id, payload);
      }
      return pb.collection('analyses_financieres').create<AnalyseFinanciereRecord>({
        user: uid,
        bien: bienId,
        ...payload,
      });
    },
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ['analyse_financiere', bienId, uid] });
      void queryClient.invalidateQueries({ queryKey: ['bien_detail', bienId] });
      void queryClient.invalidateQueries({ queryKey: ['biens', uid] });
    },
  });

  const patchMutation = useMutation({
    mutationFn: async (patch: { prix_revente_m2?: number | null }) => {
      if (!bienId || !uid) throw new Error('Données manquantes');
      const res = await pb.collection('analyses_financieres').getList<AnalyseFinanciereRecord>(1, 1, {
        filter: `bien="${bienId}" && user="${uid}"`,
        sort: '-id',
      });
      const existing = res.items[0];
      if (existing) {
        return pb.collection('analyses_financieres').update<AnalyseFinanciereRecord>(existing.id, patch);
      }
      return pb.collection('analyses_financieres').create<AnalyseFinanciereRecord>({
        user: uid,
        bien: bienId,
        type_bien_fiscal: 'ancien',
        ...patch,
      });
    },
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ['analyse_financiere', bienId, uid] });
      void queryClient.invalidateQueries({ queryKey: ['bien_detail', bienId] });
    },
  });

  return {
    analyse: query.data ?? null,
    isLoading: query.isPending,
    error: query.error,
    refetch: query.refetch,
    fetchAnalyse: query.refetch,
    saveAnalyse: saveMutation.mutateAsync,
    isSaving: saveMutation.isPending,
    patchAnalyse: patchMutation.mutateAsync,
    isPatching: patchMutation.isPending,
    calculateResults,
  };
}