"use client";

import { useState, useEffect, useCallback } from "react";
import {
  getCertificatesPaginated,
  createCertificate,
  updateCertificate,
  deleteCertificate,
  searchLegacyExcel,
  uploadBulkScans,
  verifyCertificate,
} from "@/lib/api/certificate.api";
import {
  mapCertificatesApiResponse,
  buildLegacyMap,
} from "@/lib/api/mappers/certificate.mappers";
import type {
  CertificateRow,
  CreateCertificateDto,
  UpdateCertificateDto,
  CreateCertificateResponse,
  BulkScanResponse,
  VerifyCertificateResponse,
  LegacyExcelCert,
} from "@/lib/api/types/certificate.types";

// ─── useCertificates — list/pagination ─────────────────────────────────────
export function useCertificates(initialPage = 1) {
  const [rows, setRows] = useState<CertificateRow[]>([]);
  const [page, setPage] = useState(initialPage);
  const [lastPage, setLastPage] = useState(1);
  const [total, setTotal] = useState(0);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [search, setSearch] = useState("");

  const refresh = useCallback(() => {
    setLoading(true);
    setError(null);
    getCertificatesPaginated({ page, search })
      .then((res) => {
        setRows(mapCertificatesApiResponse(res.data));
        setTotal(res.total);
        setLastPage(res.lastPage);
      })
      .catch((err) => setError(err.message ?? "Failed to load certificates"))
      .finally(() => setLoading(false));
  }, [page, search]);

  useEffect(() => {
    refresh();
  }, [refresh]);

  return {
    rows,
    page,
    setPage,
    lastPage,
    total,
    search,
    setSearch,
    loading,
    error,
    refresh,
  };
}

// ─── useCertificateMutations ──────────────────────────────────────────────
export function useCertificateMutations(onSuccess?: () => void) {
  const [saving, setSaving] = useState(false);
  const [deleting, setDeleting] = useState(false);
  const [mutationError, setMutationError] = useState<string | null>(null);

  const create = async (
    dto: CreateCertificateDto,
  ): Promise<CreateCertificateResponse | null> => {
    setSaving(true);
    setMutationError(null);
    try {
      const r = await createCertificate(dto);
      onSuccess?.();
      return r;
    } catch (err: any) {
      setMutationError(err.message ?? "Failed to create certificate");
      return null;
    } finally {
      setSaving(false);
    }
  };

  const update = async (id: number, dto: UpdateCertificateDto) => {
    setSaving(true);
    setMutationError(null);
    try {
      const r = await updateCertificate(id, dto);
      onSuccess?.();
      return r;
    } catch (err: any) {
      setMutationError(err.message ?? "Failed to update certificate");
      return null;
    } finally {
      setSaving(false);
    }
  };

  const remove = async (id: number) => {
    setDeleting(true);
    setMutationError(null);
    try {
      await deleteCertificate(id);
      onSuccess?.();
      return true;
    } catch (err: any) {
      setMutationError(err.message ?? "Failed to delete certificate");
      return false;
    } finally {
      setDeleting(false);
    }
  };

  return { create, update, remove, saving, deleting, mutationError };
}

// ─── useLegacyLookup — fetch legacy certs for a company ────────────────────
export function useLegacyLookup() {
  const [legacyRecords, setLegacyRecords] = useState<LegacyExcelCert[]>([]);
  const [legacyMap, setLegacyMap] = useState<
    Record<string, { cert_no: string; legacy_id: number }>
  >({});
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const lookup = useCallback(async (companyName: string) => {
    if (!companyName?.trim()) {
      setLegacyRecords([]);
      setLegacyMap({});
      return;
    }
    setLoading(true);
    setError(null);
    try {
      const res = await searchLegacyExcel(companyName, 20);
      setLegacyRecords(res.data ?? []);
      setLegacyMap(buildLegacyMap(res.data ?? []));
    } catch (err: any) {
      setError(err.message ?? "Failed to fetch legacy records");
      setLegacyRecords([]);
      setLegacyMap({});
    } finally {
      setLoading(false);
    }
  }, []);

  const reset = useCallback(() => {
    setLegacyRecords([]);
    setLegacyMap({});
    setError(null);
  }, []);

  return { legacyRecords, legacyMap, loading, error, lookup, reset };
}

// ─── useBulkScanUpload ─────────────────────────────────────────────────────
export function useBulkScanUpload() {
  const [result, setResult] = useState<BulkScanResponse | null>(null);
  const [uploading, setUploading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const upload = async (files: File[]) => {
    setUploading(true);
    setError(null);
    try {
      const r = await uploadBulkScans(files);
      setResult(r);
      return r;
    } catch (err: any) {
      setError(err.message ?? "Bulk scan upload failed");
      return null;
    } finally {
      setUploading(false);
    }
  };

  const reset = () => {
    setResult(null);
    setError(null);
  };

  return { upload, result, uploading, error, reset };
}

// ─── useVerifyCertificate — public verify ──────────────────────────────────
export function useVerifyCertificate() {
  const [result, setResult] = useState<VerifyCertificateResponse | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const verify = async (token: string, fingerprint?: string) => {
    setLoading(true);
    setError(null);
    try {
      const r = await verifyCertificate(token, fingerprint);
      setResult(r);
      return r;
    } catch (err: any) {
      setError(err.message ?? "Verification failed");
      return null;
    } finally {
      setLoading(false);
    }
  };

  return { verify, result, loading, error };
}