import { Icon } from "@iconify/react";
import {
  Box,
  Button,
  Card,
  Chip,
  CircularProgress,
  Dialog,
  DialogActions,
  DialogContent,
  DialogContentText,
  DialogTitle,
  FormControl,
  InputLabel,
  MenuItem,
  Paper,
  Select,
  Skeleton,
  Table,
  TableBody,
  TableCell,
  TableContainer,
  TableHead,
  TableRow,
  Typography,
} from "@mui/material";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { useEffect, useMemo, useState } from "react";
import { toast } from "sonner";
import { getEmpresaMonedas } from "../../../api/monedas.service";
import {
  generarComisionesExistentes,
  getResumenComisiones,
  getVendedoresCobradores,
} from "../../../api/vendedores-cobradores.service";
import { usePermission } from "../../../hooks/usePermission";
import { EmptyState, ScreenGuia } from "../../_standards";
import { SearchableSelect } from "../../ui/SearchableSelect";
import { ComisionesDetalleDialog } from "./ComisionesDetalleDialog";
import { ComisionesPdfModal } from "./ComisionesPdfModal";

const tipoChip = {
  vendedor: { label: "Vendedor", color: "primary" },
  cobrador: { label: "Cobrador", color: "secondary" },
  ambos: { label: "Ambos", color: "success" },
};

const estadoChip = {
  pendiente: { label: "Pendiente", color: "warning" },
  liquidada: { label: "Liquidada", color: "success" },
};

export const ComisionesPanel = () => {
  const [periodo, setPeriodo] = useState("mes_actual");
  const [vendedorId, setVendedorId] = useState("todos");
  const [filterMoneda, setFilterMoneda] = useState("");
  const [dialogOpen, setDialogOpen] = useState(false);
  // Resultado detallado del último "Generar comisiones históricas" — string vacío = cerrado.
  const [resultadoGenerar, setResultadoGenerar] = useState(null);
  const [detalleVC, setDetalleVC] = useState(null);
  const [pdfTipo, setPdfTipo] = useState(null);
  const queryClient = useQueryClient();
  const { can: canCobranzas } = usePermission("COBRANZAS");
  const canGenerar = canCobranzas("COB_COM_COMISION_GENERAR");

  const { desde, hasta, fechaDesdeStr, fechaHastaStr } = useMemo(() => {
    const hoy = new Date();
    let desdeDate, hastaDate;
    switch (periodo) {
      case "mes_actual":
        desdeDate = new Date(hoy.getFullYear(), hoy.getMonth(), 1);
        hastaDate = new Date(hoy.getFullYear(), hoy.getMonth() + 1, 0);
        break;
      case "mes_anterior":
        desdeDate = new Date(hoy.getFullYear(), hoy.getMonth() - 1, 1);
        hastaDate = new Date(hoy.getFullYear(), hoy.getMonth(), 0);
        break;
      case "trimestre": {
        const trimestre = Math.floor(hoy.getMonth() / 3);
        desdeDate = new Date(hoy.getFullYear(), trimestre * 3, 1);
        hastaDate = new Date(hoy.getFullYear(), trimestre * 3 + 3, 0);
        break;
      }
      case "anio":
        desdeDate = new Date(hoy.getFullYear(), 0, 1);
        hastaDate = new Date(hoy.getFullYear(), 11, 31);
        break;
      default:
        desdeDate = new Date(hoy.getFullYear(), hoy.getMonth(), 1);
        hastaDate = hoy;
    }
    const formatDate = (d) => d.toISOString().split("T")[0];
    return {
      desde: desdeDate,
      hasta: hastaDate,
      fechaDesdeStr: formatDate(desdeDate),
      fechaHastaStr: formatDate(hastaDate),
    };
  }, [periodo]);

  const { data: monedasData } = useQuery({
    queryKey: ["empresa-monedas"],
    queryFn: getEmpresaMonedas,
  });
  const monedas = monedasData || [];

  const { data: vcActivos } = useQuery({
    queryKey: ["vendedores-cobradores-activos-filtro"],
    queryFn: () => getVendedoresCobradores({ active: true }),
  });
  const vendedoresCobradoresFiltro = useMemo(
    () =>
      (Array.isArray(vcActivos) ? vcActivos : vcActivos?.data || []).map((v) => ({
        id: v.id,
        nombre: `${v.nombre ?? ""} ${v.apellido ?? ""}`.trim() || v.codigo || "Sin nombre",
      })),
    [vcActivos],
  );

  useEffect(() => {
    if (monedas.length > 0 && !filterMoneda) {
      const principal = monedas.find((m) => m.es_principal);
      if (principal) setFilterMoneda(principal.moneda?.id || principal.id);
      else if (monedas[0]) setFilterMoneda(monedas[0].moneda?.id || monedas[0].id);
    }
  }, [monedas, filterMoneda]);

  const { data: comisionesData, isLoading } = useQuery({
    queryKey: ["resumen-comisiones", fechaDesdeStr, fechaHastaStr, filterMoneda],
    queryFn: () =>
      getResumenComisiones({
        fechaDesde: fechaDesdeStr,
        fechaHasta: fechaHastaStr,
        monedaId: filterMoneda || undefined,
      }),
  });

  const { mutate: generarComisiones, isPending: generando } = useMutation({
    mutationFn: generarComisionesExistentes,
    onSuccess: (data) => {
      const generadas = Number(data?.comisionesGeneradas ?? 0);
      if (generadas > 0) {
        toast.success(`${generadas} comisión(es) generada(s) correctamente`);
      } else {
        // Sin generación → abrir diálogo con detalle en vez de toast que desaparece.
        setResultadoGenerar({
          comisionesGeneradas: generadas,
          detalles: Array.isArray(data?.detalles) ? data.detalles : [],
          mensaje: data?.mensaje || "No se generó ninguna comisión",
        });
      }
      queryClient.invalidateQueries({ queryKey: ["resumen-comisiones"] });
      setDialogOpen(false);
    },
    onError: () => toast.error("Error al generar comisiones"),
  });


  const comisionesResumen = useMemo(() => {
    if (!comisionesData) return [];
    return comisionesData.map((c) => ({
      ...c,
      nombre: `${c.nombre} ${c.apellido || ""}`.trim(),
    }));
  }, [comisionesData]);

  const comisionesFiltradas =
    vendedorId === "todos"
      ? comisionesResumen
      : comisionesResumen.filter((c) => c.id === vendedorId);

  const totales = comisionesFiltradas.reduce(
    (acc, c) => ({
      ventas: acc.ventas + (c.ventas || 0),
      cobranzas: acc.cobranzas + (c.cobranzas || 0),
      comisiones: acc.comisiones + (c.comision_generada || 0),
    }),
    { ventas: 0, cobranzas: 0, comisiones: 0 },
  );

  const monedaActual = comisionesFiltradas[0]?.moneda || { codigo: "PYG", simbolo: "Gs." };

  const formatCurrency = (value, moneda = null) => {
    const mon = moneda || monedaActual;
    const codigo = mon?.codigo || "PYG";
    const simbolo = mon?.simbolo || "Gs.";
    const formattedValue = new Intl.NumberFormat("es-PY", {
      minimumFractionDigits: codigo === "PYG" ? 0 : 2,
      maximumFractionDigits: codigo === "PYG" ? 0 : 2,
    }).format(value || 0);
    return `${simbolo} ${formattedValue}`;
  };

  return (
    <Box sx={{ display: "flex", flexDirection: "column", gap: 2 }}>
      <ScreenGuia
        titulo="¿Cómo funciona el panel de Comisiones?"
        intro="Resumen de comisiones generadas a partir de ventas y cobranzas registradas en el período."
        pasos={[
          {
            icon: "lucide:filter",
            color: "#3b82f6",
            titulo: "1. Filtrá",
            desc: "Elegí período, vendedor/cobrador y moneda para acotar el resumen.",
          },
          {
            icon: "lucide:trending-up",
            color: "#22c55e",
            titulo: "2. Revisá los KPIs",
            desc: "Total Ventas, Cobranzas y Comisiones Generadas del período.",
          },
          {
            icon: "lucide:list",
            color: "#f59e0b",
            titulo: "3. Detalle por persona",
            desc: "La tabla muestra ventas, cobranzas y comisión generada por cada vendedor/cobrador.",
          },
          {
            icon: "lucide:wallet",
            color: "#8b5cf6",
            titulo: "4. Liquidá",
            desc: "Cuando estés conforme, usá el módulo de Liquidaciones para pagar las comisiones.",
          },
        ]}
        notas={[
          {
            icon: "lucide:info",
            text: "Las comisiones de cobranza se generan automáticamente al registrar un recibo si el cobrador tiene % o monto fijo configurado.",
          },
          {
            icon: "lucide:alert-triangle",
            text: "Si una factura tenía vendedor pero no tiene comisión registrada, usá «Generar comisiones históricas».",
          },
        ]}
      />

      <Box
        sx={{
          display: "flex",
          alignItems: "flex-start",
          justifyContent: "space-between",
          gap: 2,
          flexWrap: "wrap",
        }}
      >
        <Box>
          <Typography variant="h6" fontWeight={700}>
            Comisiones
          </Typography>
          <Typography variant="body2" color="text.secondary">
            Resumen de comisiones generadas por período
          </Typography>
        </Box>
        <Box sx={{ display: "flex", gap: 1, flexWrap: "wrap" }}>
          <Button
            variant="outlined"
            size="small"
            startIcon={<Icon icon="mdi:file-pdf-box" width={16} />}
            onClick={() => setPdfTipo("resumen")}
          >
            PDF Resumen
          </Button>
          <Button
            variant="outlined"
            size="small"
            startIcon={<Icon icon="mdi:file-pdf-box" width={16} />}
            onClick={() => setPdfTipo("detalle")}
          >
            PDF Detallado
          </Button>
          {canGenerar && (
            <Button
              variant="outlined"
              size="small"
              startIcon={<Icon icon="lucide:refresh-cw" width={16} />}
              onClick={() => setDialogOpen(true)}
            >
              Generar comisiones históricas
            </Button>
          )}
        </Box>
      </Box>

      <Paper variant="outlined" sx={{ p: 2 }}>
        <Box sx={{ display: "flex", gap: 2, alignItems: "center", flexWrap: "wrap" }}>
          <Icon icon="lucide:sliders-horizontal" width={20} color="#94a3b8" />
          <FormControl size="small" sx={{ minWidth: 180 }}>
            <InputLabel>Período</InputLabel>
            <Select
              value={periodo}
              label="Período"
              onChange={(e) => setPeriodo(e.target.value)}
            >
              <MenuItem value="mes_actual">Mes Actual</MenuItem>
              <MenuItem value="mes_anterior">Mes Anterior</MenuItem>
              <MenuItem value="trimestre">Trimestre Actual</MenuItem>
              <MenuItem value="anio">Año Actual</MenuItem>
            </Select>
          </FormControl>
          <Box sx={{ minWidth: 260 }}>
            <SearchableSelect
              options={[{ id: "todos", nombre: "Todos" }, ...vendedoresCobradoresFiltro]}
              value={vendedorId}
              onChange={(id) => setVendedorId(id || "todos")}
              label="Vendedor/Cobrador"
              placeholder="Buscar..."
              clearable={false}
              getOptionLabel={(o) => o?.nombre || ""}
            />
          </Box>
          <FormControl size="small" sx={{ minWidth: 120 }}>
            <InputLabel>Moneda</InputLabel>
            <Select
              value={filterMoneda}
              label="Moneda"
              onChange={(e) => setFilterMoneda(e.target.value)}
            >
              {monedas.map((m) => (
                <MenuItem key={m.moneda?.id || m.id} value={m.moneda?.id || m.id}>
                  {m.moneda?.codigo || m.codigo}
                </MenuItem>
              ))}
            </Select>
          </FormControl>
          <Box sx={{ flex: 1 }} />
          <Typography
            variant="caption"
            color="text.secondary"
            sx={{ display: "inline-flex", alignItems: "center", gap: 0.5 }}
          >
            <Icon icon="lucide:calendar" width={14} />
            {desde.toLocaleDateString()} — {hasta.toLocaleDateString()}
          </Typography>
        </Box>
      </Paper>

      <Box
        sx={{
          display: "grid",
          gridTemplateColumns: "repeat(auto-fit, minmax(200px, 1fr))",
          gap: 2,
        }}
      >
        <KpiCard
          icon="lucide:trending-up"
          color="#3b82f6"
          label="Total Ventas"
          value={formatCurrency(totales.ventas)}
          loading={isLoading}
        />
        <KpiCard
          icon="lucide:hand-coins"
          color="#8b5cf6"
          label="Total Cobranzas"
          value={formatCurrency(totales.cobranzas)}
          loading={isLoading}
        />
        <KpiCard
          icon="lucide:badge-dollar-sign"
          color="#22c55e"
          label="Comisiones Generadas"
          value={formatCurrency(totales.comisiones)}
          loading={isLoading}
        />
      </Box>

      <TableContainer component={Paper} variant="outlined">
        <Table size="small">
          <TableHead>
            <TableRow>
              <TableCell>Vendedor/Cobrador</TableCell>
              <TableCell>Tipo</TableCell>
              <TableCell align="right">Ventas</TableCell>
              <TableCell align="right">Cobranzas</TableCell>
              <TableCell align="center">% Comisión</TableCell>
              <TableCell align="right">Comisión Generada</TableCell>
              <TableCell align="center">Estado</TableCell>
            </TableRow>
          </TableHead>
          <TableBody>
            {isLoading ? (
              Array.from({ length: 3 }).map((_, i) => (
                <TableRow key={i}>
                  {Array.from({ length: 7 }).map((__, j) => (
                    <TableCell key={j}>
                      <Skeleton variant="text" />
                    </TableCell>
                  ))}
                </TableRow>
              ))
            ) : comisionesFiltradas.length === 0 ? (
              <TableRow>
                <TableCell colSpan={7} sx={{ p: 0, border: 0 }}>
                  <EmptyState
                    icon="lucide:inbox"
                    title="No hay comisiones para el período seleccionado"
                    description="Probá cambiar de período o moneda. Si esperás ver datos, revisá que el cobrador tenga % configurado y que las facturas estén asignadas."
                    helpLabel="¿Por qué no veo nada?"
                    onHelp={() => {
                      const el = document.querySelector('[aria-expanded]');
                      el?.scrollIntoView({ behavior: "smooth", block: "start" });
                    }}
                  />
                </TableCell>
              </TableRow>
            ) : (
              comisionesFiltradas.map((c) => {
                const tipo = tipoChip[c.tipo] || tipoChip.ambos;
                const estado = estadoChip[c.estado] || estadoChip.pendiente;
                return (
                  <TableRow
                    key={c.id}
                    hover
                    sx={{ cursor: "pointer" }}
                    onClick={() => setDetalleVC(c)}
                  >
                    <TableCell>
                      <Typography fontWeight={500}>{c.nombre}</Typography>
                    </TableCell>
                    <TableCell>
                      <Chip label={tipo.label} size="small" color={tipo.color} variant="outlined" />
                    </TableCell>
                    <TableCell align="right">
                      {c.tipo === "vendedor" || c.tipo === "ambos"
                        ? formatCurrency(c.ventas)
                        : "-"}
                    </TableCell>
                    <TableCell align="right">
                      {c.tipo === "cobrador" || c.tipo === "ambos"
                        ? formatCurrency(c.cobranzas)
                        : "-"}
                    </TableCell>
                    <TableCell align="center">
                      {c.comision_porcentaje > 0 ? `${c.comision_porcentaje}%` : "-"}
                    </TableCell>
                    <TableCell align="right">
                      <Typography fontWeight={700} color="success.main">
                        {formatCurrency(c.comision_generada)}
                      </Typography>
                    </TableCell>
                    <TableCell align="center">
                      <Chip
                        label={estado.label}
                        size="small"
                        color={estado.color}
                        variant="outlined"
                      />
                    </TableCell>
                  </TableRow>
                );
              })
            )}
          </TableBody>
        </Table>
      </TableContainer>

      <Paper variant="outlined" sx={{ p: 1.5, display: "flex", gap: 1, alignItems: "flex-start" }}>
        <Icon icon="lucide:info" width={16} color="#3b82f6" style={{ marginTop: 2 }} />
        <Typography variant="caption" color="text.secondary">
          <strong>Nota:</strong> Las comisiones se calculan automáticamente basándose en las ventas
          y cobranzas registradas. Para liquidarlas, usá el módulo de Liquidaciones.
        </Typography>
      </Paper>

      <ComisionesPdfModal
        open={!!pdfTipo}
        onClose={() => setPdfTipo(null)}
        tipo={pdfTipo || "resumen"}
        fechaDesde={fechaDesdeStr}
        fechaHasta={fechaHastaStr}
        monedaId={filterMoneda || undefined}
      />

      <ComisionesDetalleDialog
        open={!!detalleVC}
        onClose={() => setDetalleVC(null)}
        vendedorCobrador={detalleVC}
        fechaDesde={fechaDesdeStr}
        fechaHasta={fechaHastaStr}
        monedaId={filterMoneda || undefined}
      />

      <Dialog open={dialogOpen} onClose={() => setDialogOpen(false)} maxWidth="sm" fullWidth>
        <DialogTitle>Generar comisiones históricas</DialogTitle>
        <DialogContent>
          <DialogContentText>
            Se generarán comisiones de <strong>venta</strong> para todas las facturas que ya tienen
            vendedor asignado pero aún no tienen comisión registrada. Las que ya tienen comisión{" "}
            <strong>no se duplicarán</strong>.
          </DialogContentText>
        </DialogContent>
        <DialogActions>
          <Button onClick={() => setDialogOpen(false)} disabled={generando}>
            Cancelar
          </Button>
          <Button
            variant="contained"
            onClick={() => generarComisiones()}
            disabled={generando}
            startIcon={
              generando ? (
                <CircularProgress size={16} />
              ) : (
                <Icon icon="lucide:refresh-cw" width={16} />
              )
            }
          >
            {generando ? "Procesando..." : "Confirmar"}
          </Button>
        </DialogActions>
      </Dialog>

      {/* Diálogo de diagnóstico cuando "Generar comisiones históricas" devuelve 0.
          Reemplaza al toast que desaparecía sin dejar rastro. Muestra los motivos
          agrupados que devuelve el backend en `detalles`. */}
      <Dialog
        open={Boolean(resultadoGenerar)}
        onClose={() => setResultadoGenerar(null)}
        maxWidth="md"
        fullWidth
      >
        <DialogTitle sx={{ display: "flex", alignItems: "center", gap: 1, color: "warning.main" }}>
          <Icon icon="mdi:alert-circle-outline" />
          No se generó ninguna comisión
        </DialogTitle>
        <DialogContent dividers>
          <DialogContentText sx={{ mb: 2 }}>
            El proceso terminó sin generar comisiones. Revisá los motivos por factura para
            entender qué falta configurar.
          </DialogContentText>

          {/* Si el backend devolvió un mensaje explícito (ej. "Módulo COMISIONES
              no activo"), mostrarlo con destaque — antes lo tragaba silenciosamente. */}
          {resultadoGenerar?.mensaje && resultadoGenerar.mensaje !== "No se generó ninguna comisión" && (
            <Box
              sx={{
                p: 1.5,
                mb: 2,
                borderRadius: 1,
                bgcolor: "error.main",
                color: "error.contrastText",
                display: "flex",
                alignItems: "center",
                gap: 1,
              }}
            >
              <Icon icon="mdi:information-outline" width={20} />
              <Typography variant="body2" fontWeight={600}>
                {resultadoGenerar.mensaje}
              </Typography>
            </Box>
          )}

          {resultadoGenerar && resultadoGenerar.detalles.length === 0 ? (
            <Box sx={{ p: 2, borderRadius: 1, bgcolor: "action.hover" }}>
              <Typography variant="body2" gutterBottom>
                <strong>Ninguna asignación de factura se procesó.</strong>
              </Typography>
              <Typography variant="body2" color="text.secondary">
                Causas típicas:
              </Typography>
              <Box component="ul" sx={{ pl: 2.5, mt: 0.5, color: "text.secondary" }}>
                <Typography variant="body2" component="li">
                  <strong>Módulo COMISIONES desactivado</strong> en la suscripción de la empresa
                  (revisar Configuración → Suscripción → Módulos contratados).
                </Typography>
                <Typography variant="body2" component="li">
                  Hay <strong>facturas sin vendedor asignado</strong> (se emitieron sin elegir
                  vendedor).
                </Typography>
                <Typography variant="body2" component="li">
                  Todas las facturas ya tienen comisión previa liquidada (no hay nada para generar).
                </Typography>
              </Box>
              <Typography variant="body2" color="text.secondary" sx={{ mt: 1.5 }}>
                <strong>Cómo verificar</strong>: revisá primero que el módulo COMISIONES esté
                activo. Luego que las facturas hayan sido emitidas con vendedor asignado
                (dropdown "Vendedor" al facturar). Si todo es correcto, contactá soporte con el
                mensaje exacto que aparece arriba.
              </Typography>
            </Box>
          ) : (
            <>
              <Typography variant="caption" color="text.secondary" gutterBottom sx={{ display: "block" }}>
                {resultadoGenerar?.detalles?.length ?? 0} factura(s) analizada(s):
              </Typography>
              {resultadoGenerar && (() => {
                const motivos = {};
                for (const linea of resultadoGenerar.detalles) {
                  const match = String(linea).match(/:\s*(.+)$/);
                  const motivo = match ? match[1].trim() : String(linea);
                  motivos[motivo] = (motivos[motivo] || 0) + 1;
                }
                const explicacion = {
                  "sin vendedor asignado":
                    "La factura tiene una asignación pero sin vendedor (probablemente sólo se asignó cobrador). Ir a Finanzas → Asignación y elegir el vendedor.",
                  "ya tiene comisión":
                    "Ya existe una comisión previa para esta factura+vendedor. Es idempotente por diseño.",
                  "sin comisión":
                    "El vendedor no tiene cargado un porcentaje de comisión mayor a 0. Editá el vendedor y cargá el porcentaje.",
                  "monto base 0":
                    "La factura no tiene totales calculados o su total es 0. Revisar la factura origen.",
                };
                return (
                  <Box sx={{ display: "flex", flexDirection: "column", gap: 1.25 }}>
                    {Object.entries(motivos).map(([motivo, cantidad]) => (
                      <Paper key={motivo} variant="outlined" sx={{ p: 1.5 }}>
                        <Box sx={{ display: "flex", alignItems: "center", gap: 1 }}>
                          <Chip
                            label={cantidad}
                            size="small"
                            color="warning"
                            sx={{ fontWeight: 700, minWidth: 40 }}
                          />
                          <Typography variant="body2" fontWeight={600}>
                            {motivo}
                          </Typography>
                        </Box>
                        <Typography variant="caption" color="text.secondary" sx={{ display: "block", mt: 0.5, ml: 5.5 }}>
                          {explicacion[motivo] || "Ver logs del backend para más detalle."}
                        </Typography>
                      </Paper>
                    ))}
                  </Box>
                );
              })()}
            </>
          )}
        </DialogContent>
        <DialogActions>
          <Button onClick={() => setResultadoGenerar(null)}>Cerrar</Button>
        </DialogActions>
      </Dialog>
    </Box>
  );
};

function KpiCard({ icon, color, label, value, loading }) {
  return (
    <Card variant="outlined" sx={{ p: 2, display: "flex", gap: 1.5, alignItems: "center" }}>
      <Box
        sx={{
          width: 40,
          height: 40,
          borderRadius: "10px",
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          bgcolor: `${color}22`,
          color,
          flexShrink: 0,
        }}
      >
        <Icon icon={icon} width={20} />
      </Box>
      <Box sx={{ minWidth: 0, flex: 1 }}>
        <Typography
          variant="caption"
          color="text.secondary"
          sx={{ textTransform: "uppercase", letterSpacing: 0.5, fontWeight: 600 }}
        >
          {label}
        </Typography>
        {loading ? (
          <Skeleton width="60%" height={28} />
        ) : (
          <Typography variant="h6" fontWeight={700} sx={{ lineHeight: 1.2 }}>
            {value}
          </Typography>
        )}
      </Box>
    </Card>
  );
}

export default ComisionesPanel;
