import { Head, router } from '@inertiajs/react';
import { ChevronDown, ChevronRight, Download, FileUp, MoreHorizontal, Plus, RefreshCw, Search, SearchX, Trash2, Upload, X } from 'lucide-react';
import clsx from 'clsx';
import { useEffect, useRef, useState, type ReactNode } from 'react';
import AppLayout from '@/layouts/AppLayout';
import { Paginacion } from '@/components/Paginacion';
import { SelectBuscable } from '@/components/SelectBuscable';
import { Button } from '@/components/ui/button';
import { Checkbox } from '@/components/ui/checkbox';
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog';
import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from '@/components/ui/dropdown-menu';
import { Input } from '@/components/ui/input';
import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from '@/components/ui/sheet';
import { Skeleton } from '@/components/ui/skeleton';
import { getJson, postJson } from '@/lib/http';
import { int, money, pct, toNum } from '@/lib/format';

type Producto = { producto_id: string; descripcion: string; clasificacion: string | null; linea: string | null; tipo_producto: string | null; precio_promedio: number | string | null; unidades_por_caja: number | string | null; activo: boolean };
type Alias = { cadena: string; alias_nombre: string; factor_conversion: number | string; confianza_manual: number | string; activo: boolean };
type Comision = { linea: string; equipo: string; clasificacion: string; peso: number | string };
type SinMatch = { producto_original: string; filas: number; venta: number | string; archivo?: string };
type FilaComarketing = { producto_id: string; producto: string; linea: string; equipo: string; clasificacion: string; peso: number };

type Props = {
    q: string;
    seleccionado: string;
    resultados: { rows: { producto_id: string; descripcion: string; clasificacion?: string; linea?: string; tipo_producto?: string; activo: boolean }[]; total: number; page: number; pageSize: number };
    detalle: { producto: Producto; aliases: Alias[]; comisiones: Comision[]; enInventario: boolean } | null;
    catalogos: { clasificaciones: string[]; lineas: string[]; tipos: string[]; cadenas: string[]; pares: { linea: string; equipo: string }[] };
};

/** Editor abierto: producto nuevo o uno existente (su detalle llega del servidor). */
type Editor = { modo: 'nuevo' } | { modo: 'editar'; id: string } | null;

const vacio: Producto = { producto_id: '', descripcion: '', clasificacion: '', linea: '', tipo_producto: '', precio_promedio: 0, unidades_por_caja: 1, activo: true };
const opts = { preserveState: true, preserveScroll: true };
const etiqueta = 'mb-1.5 block text-sm font-medium';
const celda = 'w-full rounded-md border border-input bg-transparent px-2 text-sm shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50';

const norm = (v: unknown) =>
    String(v ?? '')
        .trim()
        .normalize('NFD')
        .replace(/[̀-ͯ]/g, '')
        .toUpperCase();

async function leerExcel(file: File) {
    const XLSX = await import('xlsx');
    const wb = XLSX.read(await file.arrayBuffer(), { type: 'array' });
    const filas = XLSX.utils.sheet_to_json<Record<string, unknown>>(wb.Sheets[wb.SheetNames[0]!]!, { defval: '' });
    return filas.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [norm(k).replace(/[\s_]+/g, ' '), v])));
}
const col = (r: Record<string, unknown>, ...n: string[]) => {
    for (const x of n) if (x in r && r[x] !== '') return r[x];
    return undefined;
};

/** Visita a la pantalla; los parámetros vacíos no van en la URL. */
const visitar = (params: { q?: string; producto?: string; pagina?: number }, extra: { replace?: boolean } = {}) =>
    router.get('/admin_productos', Object.fromEntries(Object.entries(params).filter(([k, v]) => v && !(k === 'pagina' && v === 1))), { ...opts, ...extra });

function EtiquetaActivo({ activo }: { activo: boolean }) {
    return (
        <span className={clsx('inline-flex items-center gap-1.5 text-xs font-medium whitespace-nowrap', activo ? 'text-emerald-700' : 'text-slate-500')}>
            <span className={clsx('size-1.5 rounded-full', activo ? 'bg-emerald-600' : 'bg-slate-400')} />
            {activo ? 'Activo' : 'Inactivo'}
        </span>
    );
}

/** Selector de dos o tres opciones (tipo "pestañas"), accesible como radiogroup. */
function Segmentado<T extends string | boolean>({ valor, opciones, onChange, label }: { valor: T; opciones: { v: T; l: string; punto?: string }[]; onChange: (v: T) => void; label: string }) {
    return (
        <div className="inline-flex rounded-lg bg-slate-100 p-1" role="radiogroup" aria-label={label}>
            {opciones.map((o) => (
                <button
                    key={String(o.v)}
                    type="button"
                    role="radio"
                    aria-checked={valor === o.v}
                    onClick={() => onChange(o.v)}
                    className={clsx('flex items-center gap-1.5 rounded-md px-3 py-1.5 text-sm transition-colors', valor === o.v ? 'bg-white font-semibold shadow-sm' : 'text-muted-foreground hover:text-foreground')}
                >
                    {o.punto && <span className={clsx('size-1.5 rounded-full', o.punto)} />}
                    {o.l}
                </button>
            ))}
        </div>
    );
}

function Seccion({ titulo, ayuda, accion, children }: { titulo: string; ayuda?: ReactNode; accion?: ReactNode; children: ReactNode }) {
    return (
        <section className="border-b border-border px-6 py-5 last:border-0">
            <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
                <div>
                    <h3 className="text-sm font-semibold">{titulo}</h3>
                    {ayuda && <p className="mt-0.5 text-sm text-muted-foreground">{ayuda}</p>}
                </div>
                {accion}
            </div>
            {children}
        </section>
    );
}

/** Diálogo de confirmación genérico (reemplaza a confirm() del navegador). */
function Confirmar({ abierto, titulo, descripcion, accion, onConfirmar, onCerrar }: { abierto: boolean; titulo: string; descripcion: ReactNode; accion: string; onConfirmar: () => void; onCerrar: () => void }) {
    return (
        <Dialog open={abierto} onOpenChange={(o) => !o && onCerrar()}>
            <DialogContent>
                <DialogHeader>
                    <DialogTitle>{titulo}</DialogTitle>
                    <DialogDescription>{descripcion}</DialogDescription>
                </DialogHeader>
                <DialogFooter>
                    <Button variant="outline" onClick={onCerrar}>
                        Cancelar
                    </Button>
                    <Button
                        onClick={() => {
                            onCerrar();
                            onConfirmar();
                        }}
                    >
                        {accion}
                    </Button>
                </DialogFooter>
            </DialogContent>
        </Dialog>
    );
}

/**
 * Administración → Productos: catálogo, alias por cadena, precios, factores de conversión y distribución de comisión.
 * Catálogo paginado (25 por página) con búsqueda por código o descripción (botón Buscar / Enter); un clic en la fila abre el editor en un panel deslizante (?producto= en la URL).
 */
export default function Productos({ q, seleccionado, resultados, detalle, catalogos }: Props) {
    const [buscar, setBuscar] = useState(q);
    const [editor, setEditor] = useState<Editor>(null);
    const [p, setP] = useState<Producto>(vacio);
    const [aliases, setAliases] = useState<Alias[]>([]);
    const [eliminados, setEliminados] = useState<Alias[]>([]);
    const [comisiones, setComisiones] = useState<Comision[]>([]);
    const [original, setOriginal] = useState('');
    const [historicos, setHistoricos] = useState(true);
    const [msg, setMsg] = useState<{ t: 'ok' | 'err'; m: string } | null>(null);
    const [ocupado, setOcupado] = useState(false);
    const [sinMatch, setSinMatch] = useState<SinMatch[] | null>(null);
    const [verSinMatch, setVerSinMatch] = useState(false);
    const [filtroSinMatch, setFiltroSinMatch] = useState('');
    const [archivoBase, setArchivoBase] = useState<File | null>(null);
    const [confirmarSap, setConfirmarSap] = useState(false);
    const [cm, setCm] = useState<{ abierto: boolean; vigencia: string; archivo?: string; rows?: FilaComarketing[]; preview?: Record<string, unknown> }>({ abierto: false, vigencia: new Date().toISOString().slice(0, 7) });
    const inputBase = useRef<HTMLInputElement>(null);
    const inputCm = useRef<HTMLInputElement>(null);
    const productoAnterior = useRef(seleccionado);

    // Al cargar la página el editor empieza cerrado aunque la URL traiga ?producto= (p. ej. al recargar), y se limpia la URL.
    useEffect(() => {
        if (seleccionado) visitar({ q, pagina: resultados.page }, { replace: true });
    }, []);

    // El servidor confirma otro producto (clic en un resultado o tras guardar): el editor pasa a ese producto.
    useEffect(() => {
        if (seleccionado === productoAnterior.current) return;
        productoAnterior.current = seleccionado;
        if (seleccionado) setEditor({ modo: 'editar', id: seleccionado });
    }, [seleccionado]);

    useEffect(() => {
        if (detalle) {
            setP({ ...vacio, ...detalle.producto });
            setAliases(detalle.aliases.map((a) => ({ ...a })));
            setComisiones(detalle.comisiones.map((c) => ({ ...c })));
            setEliminados([]);
            setEnInventario(detalle.enInventario);
        }
    }, [detalle]);

    const ok = (m: string) => setMsg({ t: 'ok', m });
    const err = (e: unknown) => setMsg({ t: 'err', m: e instanceof Error ? e.message : String(e) });
    const correr = async (f: () => Promise<void>) => {
        setOcupado(true);
        setMsg(null);
        try {
            await f();
        } catch (e) {
            err(e);
        } finally {
            setOcupado(false);
        }
    };

    const total = comisiones.reduce((a, c) => a + toNum(c.peso), 0);
    const excede = total > 1.0001;
    const lineasComision = Array.from(new Set(catalogos.pares.map((x) => x.linea)));
    const equiposDe = (linea: string) => catalogos.pares.filter((x) => x.linea === linea).map((x) => x.equipo);
    const cargando = editor?.modo === 'editar' && detalle?.producto.producto_id !== editor.id;
    const editando = editor?.modo === 'editar' && !cargando;
    const [enInventario, setEnInventario] = useState(false);
    const [guardandoInventario, setGuardandoInventario] = useState(false);

    /** Muestra u oculta el producto en la pantalla Inventario (se guarda al instante, aparte de "Guardar cambios"). */
    const cambiarInventario = async (mostrar: boolean) => {
        setGuardandoInventario(true);
        try {
            await postJson('/admin_productos/inventario', { producto_id: p.producto_id, mostrar });
            setEnInventario(mostrar);
            ok(mostrar ? 'El producto se muestra en Inventario.' : 'El producto se ocultó de Inventario.');
        } catch (e) {
            err(e);
        } finally {
            setGuardandoInventario(false);
        }
    };

    const abrir = (id: string) => {
        setEditor({ modo: 'editar', id });
        visitar({ q, pagina: resultados.page, producto: id });
    };
    const cerrarEditor = () => {
        setEditor(null);
        setOriginal('');
        if (seleccionado) visitar({ q, pagina: resultados.page });
    };

    const guardar = () =>
        correr(async () => {
            if (!p.producto_id.trim() || !p.descripcion.trim()) throw new Error('Código y descripción son obligatorios.');
            const id = p.producto_id.trim().toUpperCase();
            const r = await postJson<{ historico?: { filas_actualizadas?: number } | null }>('/admin_productos/guardar', {
                producto: { ...p, producto_id: id },
                aliases: aliases.filter((a) => a.alias_nombre.trim()).map((a) => ({ ...a, cadena: a.cadena.trim().toUpperCase(), alias_nombre: a.alias_nombre.trim() })),
                comisiones: comisiones.filter((c) => c.linea && c.equipo).map((c) => ({ ...c, linea: c.linea.toUpperCase(), equipo: c.equipo.toUpperCase(), clasificacion: (c.clasificacion || p.tipo_producto || 'SECUNDARIO').toUpperCase(), peso: toNum(c.peso) })),
                aliases_eliminados: eliminados,
                producto_original: original,
                aplicar_historicos: historicos && !!original,
            });
            ok(r.historico ? `Producto guardado y aplicado a históricos (${int(r.historico.filas_actualizadas)} filas).` : 'Producto y aliases guardados correctamente.');
            setOriginal('');
            setEditor({ modo: 'editar', id });
            visitar({ q, pagina: resultados.page, producto: id });
        });

    const nuevoDesde = (nombre?: string) => {
        setP({ ...vacio, descripcion: nombre ?? '' });
        setAliases(nombre ? [{ cadena: catalogos.cadenas.includes('CRL') ? 'CRL' : (catalogos.cadenas[0] ?? ''), alias_nombre: nombre, factor_conversion: 1, confianza_manual: 100, activo: true }] : []);
        setComisiones([]);
        setEliminados([]);
        setOriginal(nombre ?? '');
        setMsg(null);
        setEditor({ modo: 'nuevo' });
    };

    const abrirSinMatch = () => {
        setFiltroSinMatch('');
        setVerSinMatch(true);
        if (!sinMatch) void correr(async () => setSinMatch((await getJson<{ productos: SinMatch[] }>('/admin_productos/sin-match')).productos));
    };

    const subirBase = (file: File) =>
        correr(async () => {
            const filas = (await leerExcel(file))
                .map((r) => ({
                    producto_id: String(col(r, 'CODIGO', 'PRODUCTO ID', 'CODIGO PRODUCTO') ?? '').trim(),
                    descripcion: (col(r, 'DESCRIPCION', 'PRODUCTO') as string) || null,
                    clasificacion: (col(r, 'CLASIFICACION') as string) || null,
                    linea: (col(r, 'LINEA', 'SUBCLASIFICACION') as string) || null,
                    tipo_producto: (col(r, 'TIPO PRODUCTO', 'TIPO') as string) || null,
                    precio_promedio: col(r, 'PRECIO PROMEDIO', 'PRECIO') !== undefined ? toNum(col(r, 'PRECIO PROMEDIO', 'PRECIO')) : null,
                    unidades_por_caja: col(r, 'UNIDADES POR CAJA') !== undefined ? toNum(col(r, 'UNIDADES POR CAJA')) : null,
                    activo: col(r, 'ACTIVO') === undefined ? null : !['NO', 'FALSE', '0', 'F'].includes(norm(col(r, 'ACTIVO'))),
                }))
                .filter((r) => r.producto_id);
            if (!filas.length) throw new Error('No encontré filas con CODIGO.');
            const r = await postJson<{ updated: number; inserted: number; skipped: number }>('/admin_productos/importar', { rows: filas });
            ok(`Base cargada: ${r.updated} actualizados, ${r.inserted} nuevos, ${r.skipped} filas omitidas.`);
            router.reload();
        });

    const clasificacionSap = () =>
        correr(async () => {
            const r = await postJson<{ resultado?: unknown }>('/admin_productos/clasificacion-sap', {});
            ok(`Clasificación SAP actualizada: ${JSON.stringify(r.resultado).slice(0, 200)}`);
            router.reload();
        });

    /** CoMarketing, paso 1: lee el archivo y pide la vista previa al servidor (no aplica nada). */
    const previsualizarComarketing = (file: File) =>
        correr(async () => {
            const rows = (await leerExcel(file))
                .map((r) => ({
                    producto_id: String(col(r, 'CODIGO', 'PRODUCTO ID', 'CODIGO PRODUCTO') ?? '').trim(),
                    producto: String(col(r, 'PRODUCTO', 'DESCRIPCION') ?? ''),
                    linea: norm(col(r, 'LINEA')),
                    equipo: norm(col(r, 'EQUIPO')),
                    clasificacion: norm(col(r, 'CLASIFICACION', 'TIPO')) || 'SECUNDARIO',
                    peso: toNum(col(r, 'PESO', 'PORCENTAJE')),
                }))
                .filter((r) => r.producto_id || r.linea);
            const prev = await postJson<{ resultado?: Record<string, unknown> }>('/admin_productos/comarketing', { vigencia: `${cm.vigencia}-01`, aplicar: false, rows });
            setCm((c) => ({ ...c, archivo: file.name, rows, preview: prev.resultado ?? {} }));
        });

    /** CoMarketing, paso 2: aplica lo previsualizado. */
    const aplicarComarketing = () =>
        correr(async () => {
            const r = await postJson<{ resultado?: { products?: number; insertedRows?: number; recalculatedMonths?: string[] } }>('/admin_productos/comarketing', { vigencia: `${cm.vigencia}-01`, aplicar: true, rows: cm.rows });
            ok(`CoMarketing actualizado: ${int(r.resultado?.insertedRows)} asignaciones para ${int(r.resultado?.products)} productos.`);
            setCm((c) => ({ abierto: false, vigencia: c.vigencia }));
            router.reload();
        });

    const setAlias = (i: number, patch: Partial<Alias>) => setAliases(aliases.map((x, j) => (j === i ? { ...x, ...patch } : x)));
    const setComision = (i: number, patch: Partial<Comision>) => setComisiones(comisiones.map((x, j) => (j === i ? { ...x, ...patch } : x)));

    const Mensaje = ({ className }: { className?: string }) =>
        msg && (
            <div className={clsx('flex items-start justify-between gap-3 rounded-lg border px-4 py-2.5 text-sm whitespace-pre-line', msg.t === 'ok' ? 'border-emerald-200 bg-emerald-50 text-emerald-800' : 'border-red-200 bg-red-50 text-red-800', className)}>
                <span>{msg.m}</span>
                <button type="button" onClick={() => setMsg(null)} className="opacity-60 hover:opacity-100" aria-label="Cerrar mensaje">
                    <X className="size-4" />
                </button>
            </div>
        );

    const sinMatchFiltrados = (sinMatch ?? []).filter((s) => !filtroSinMatch.trim() || norm(s.producto_original).includes(norm(filtroSinMatch)));

    return (
        <AppLayout>
            <Head title="Productos" />
            <div className="mb-5 flex flex-wrap items-end justify-between gap-4">
                <div>
                    <h1 className="text-2xl font-bold tracking-tight">Productos</h1>
                    <p className="mt-1 text-sm text-muted-foreground">Catálogo, alias por cadena, precios, factores de conversión y distribución de comisión.</p>
                </div>
                <div className="flex flex-wrap items-center gap-2">
                    <Button variant="outline" disabled={ocupado} onClick={abrirSinMatch}>
                        <SearchX className="size-4 text-muted-foreground" /> Pendientes sin match
                    </Button>
                    <DropdownMenu>
                        <DropdownMenuTrigger asChild>
                            <Button variant="outline" disabled={ocupado}>
                                <MoreHorizontal className="size-4 text-muted-foreground" /> Más acciones <ChevronDown className="size-3.5 text-muted-foreground" />
                            </Button>
                        </DropdownMenuTrigger>
                        <DropdownMenuContent align="end" className="w-64">
                            <DropdownMenuItem asChild>
                                <a href="/admin_productos/exportar">
                                    <Download className="size-4" /> Descargar base
                                </a>
                            </DropdownMenuItem>
                            <DropdownMenuItem onSelect={() => inputBase.current?.click()}>
                                <Upload className="size-4" /> Subir base…
                            </DropdownMenuItem>
                            <DropdownMenuSeparator />
                            <DropdownMenuItem onSelect={() => setCm((c) => ({ abierto: true, vigencia: c.vigencia }))}>
                                <FileUp className="size-4" /> Importar comarketing…
                            </DropdownMenuItem>
                            <DropdownMenuItem onSelect={() => setConfirmarSap(true)}>
                                <RefreshCw className="size-4" /> Actualizar clasificación desde SAP
                            </DropdownMenuItem>
                        </DropdownMenuContent>
                    </DropdownMenu>
                    <input
                        ref={inputBase}
                        type="file"
                        accept=".xlsx,.xls,.csv"
                        className="hidden"
                        onChange={(e) => {
                            const f = e.target.files?.[0];
                            e.target.value = '';
                            if (f) setArchivoBase(f);
                        }}
                    />
                    <Button onClick={() => nuevoDesde()}>
                        <Plus className="size-4" /> Nuevo producto
                    </Button>
                </div>
            </div>

            {!editor && <Mensaje className="mb-4" />}
            {ocupado && !editor && <p className="mb-4 rounded-lg border border-border bg-white px-4 py-2.5 text-sm text-muted-foreground">Procesando…</p>}

            {/* Búsqueda y resultados */}
            <div className="overflow-hidden rounded-xl border border-border bg-white">
                <form
                    className="flex flex-wrap items-center gap-2 border-b border-border p-3"
                    onSubmit={(e) => {
                        e.preventDefault();
                        visitar({ q: buscar.trim() });
                    }}
                >
                    <div className="relative min-w-60 flex-1 sm:max-w-96">
                        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-muted-foreground" />
                        <Input value={buscar} onChange={(e) => setBuscar(e.target.value)} placeholder="Buscar por código o descripción" className="h-10 pl-9" />
                    </div>
                    <Button type="submit" variant="outline" className="h-10">
                        Buscar
                    </Button>
                    {q !== '' && (
                        <Button
                            type="button"
                            variant="ghost"
                            className="h-10 text-muted-foreground"
                            onClick={() => {
                                setBuscar('');
                                visitar({});
                            }}
                        >
                            <X className="size-4" /> Limpiar
                        </Button>
                    )}
                </form>

                <div className="overflow-x-auto">
                    <table className="w-full text-sm">
                        <thead>
                            <tr className="border-b border-border bg-slate-50 text-left text-xs text-muted-foreground">
                                <th className="px-4 py-3 font-medium">Producto</th>
                                <th className="px-4 py-3 font-medium">Clasificación</th>
                                <th className="px-4 py-3 font-medium">Línea</th>
                                <th className="px-4 py-3 font-medium">Tipo</th>
                                <th className="px-4 py-3 font-medium">Estado</th>
                                <th className="w-10" />
                            </tr>
                        </thead>
                        <tbody>
                            {resultados.rows.map((r) => {
                                const sel = editor?.modo === 'editar' && editor.id === r.producto_id;
                                return (
                                    <tr
                                        key={r.producto_id}
                                        tabIndex={0}
                                        onClick={() => abrir(r.producto_id)}
                                        onKeyDown={(e) => e.key === 'Enter' && abrir(r.producto_id)}
                                        aria-selected={sel}
                                        className={clsx(
                                            'group cursor-pointer border-b border-border last:border-0 focus-visible:bg-slate-50 focus-visible:outline-none',
                                            sel ? 'bg-slate-50 shadow-[inset_3px_0_0_var(--color-ibero-orange)]' : 'hover:bg-slate-50',
                                        )}
                                    >
                                        <td className="px-4 py-3">
                                            <p className="font-medium">{r.descripcion}</p>
                                            <p className="text-xs text-muted-foreground tabular-nums">{r.producto_id}</p>
                                        </td>
                                        <td className="px-4 py-3">{r.clasificacion ? <span className="inline-flex rounded-full bg-slate-100 px-2.5 py-0.5 text-xs font-medium whitespace-nowrap text-slate-700">{r.clasificacion}</span> : <span className="text-muted-foreground">—</span>}</td>
                                        <td className="px-4 py-3 text-xs">{r.linea || <span className="text-muted-foreground">—</span>}</td>
                                        <td className="px-4 py-3 text-xs">{r.tipo_producto || <span className="text-muted-foreground">—</span>}</td>
                                        <td className="px-4 py-3">
                                            <EtiquetaActivo activo={r.activo} />
                                        </td>
                                        <td className={clsx('pr-3', sel ? 'text-slate-500' : 'text-slate-300 group-hover:text-slate-500')}>
                                            <ChevronRight className="size-4" />
                                        </td>
                                    </tr>
                                );
                            })}
                            {resultados.rows.length === 0 && (
                                <tr>
                                    <td colSpan={6} className="px-4 py-12 text-center">
                                        <p className="font-medium">{q ? `Ningún producto coincide con «${q}»` : 'No hay productos en el catálogo'}</p>
                                        <p className="mt-1 text-sm text-muted-foreground">Prueba con otro código o descripción, o crea el producto.</p>
                                    </td>
                                </tr>
                            )}
                        </tbody>
                    </table>
                </div>

                <Paginacion pagina={resultados.page} total={resultados.total} porPagina={resultados.pageSize} onChange={(n) => visitar({ q, pagina: n })} />
            </div>

            {/* Editor del producto: panel que se desliza desde la derecha. */}
            <Sheet open={editor !== null} onOpenChange={(o) => !o && !ocupado && cerrarEditor()}>
                <SheetContent className="w-full gap-0 bg-white p-0 sm:max-w-3xl">
                    <SheetHeader className="border-b border-border px-6 py-4 pr-12">
                        {editor?.modo === 'nuevo' ? (
                            <>
                                <SheetTitle className="text-lg font-bold tracking-tight">Nuevo producto</SheetTitle>
                                <SheetDescription>{original ? `Se creará a partir del nombre «${original}».` : 'Completa los datos y guarda para crearlo.'}</SheetDescription>
                            </>
                        ) : (
                            <>
                                <p className="text-xs text-muted-foreground tabular-nums">{editor?.modo === 'editar' ? editor.id : ''}</p>
                                <SheetTitle className="text-lg font-bold tracking-tight">{editando ? p.descripcion || 'Sin descripción' : 'Cargando producto…'}</SheetTitle>
                                <SheetDescription className="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs">
                                    {editando && <EtiquetaActivo activo={detalle!.producto.activo} />}
                                    {editando && detalle!.producto.clasificacion && <span>{detalle!.producto.clasificacion}</span>}
                                </SheetDescription>
                            </>
                        )}
                    </SheetHeader>

                    <div className="flex-1 overflow-y-auto">
                        {cargando ? (
                            <div className="space-y-4 p-6" aria-busy="true" aria-label="Cargando producto">
                                <Skeleton className="h-4 w-40" />
                                <div className="grid grid-cols-2 gap-4">
                                    <Skeleton className="h-9" />
                                    <Skeleton className="h-9" />
                                </div>
                                <Skeleton className="h-20 w-full" />
                                <Skeleton className="mt-6 h-4 w-40" />
                                <Skeleton className="h-24 w-full" />
                            </div>
                        ) : (
                            <>
                                <Mensaje className="mx-6 mt-5" />

                                <Seccion titulo="Datos del producto">
                                    <div className="grid gap-4 sm:grid-cols-2">
                                        <div>
                                            <label htmlFor="p-codigo" className={etiqueta}>
                                                Código
                                            </label>
                                            <Input id="p-codigo" value={p.producto_id} onChange={(e) => setP({ ...p, producto_id: e.target.value })} disabled={editando} placeholder="Ej. P00123" />
                                        </div>
                                        <div>
                                            <span className={etiqueta}>Estado</span>
                                            <Segmentado
                                                label="Estado del producto"
                                                valor={p.activo}
                                                onChange={(v) => setP({ ...p, activo: v })}
                                                opciones={[
                                                    { v: true, l: 'Activo', punto: 'bg-emerald-600' },
                                                    { v: false, l: 'Inactivo', punto: 'bg-slate-400' },
                                                ]}
                                            />
                                        </div>
                                        {editando && /^PT/i.test(p.producto_id) && (
                                            <div className="flex flex-wrap items-center justify-between gap-3 rounded-lg border border-border bg-slate-50 px-4 py-3 sm:col-span-2">
                                                <div>
                                                    <p className="text-sm font-medium">Pantalla Inventario</p>
                                                    <p className="text-xs text-muted-foreground">Se guarda al instante. Si está activo en SAP, aparece en la lista de existencias.</p>
                                                </div>
                                                <span className={clsx(guardandoInventario && 'pointer-events-none opacity-60')}>
                                                    <Segmentado
                                                        label="Mostrar en Inventario"
                                                        valor={enInventario}
                                                        onChange={(v) => v !== enInventario && void cambiarInventario(v)}
                                                        opciones={[
                                                            { v: true, l: 'Mostrar', punto: 'bg-emerald-600' },
                                                            { v: false, l: 'Ocultar', punto: 'bg-slate-400' },
                                                        ]}
                                                    />
                                                </span>
                                            </div>
                                        )}
                                        <div className="sm:col-span-2">
                                            <label htmlFor="p-desc" className={etiqueta}>
                                                Descripción
                                            </label>
                                            <textarea
                                                id="p-desc"
                                                rows={2}
                                                value={p.descripcion}
                                                onChange={(e) => setP({ ...p, descripcion: e.target.value })}
                                                className="block w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50"
                                            />
                                        </div>
                                        <div>
                                            <label htmlFor="p-clasif" className={etiqueta}>
                                                Clasificación
                                            </label>
                                            <SelectBuscable id="p-clasif" value={p.clasificacion ?? ''} onChange={(v) => setP({ ...p, clasificacion: v })} options={catalogos.clasificaciones.map((c) => ({ value: c, label: c }))} buscarPlaceholder="Buscar clasificación…" />
                                        </div>
                                        <div>
                                            <label htmlFor="p-linea" className={etiqueta}>
                                                Subclasificación / línea
                                            </label>
                                            <SelectBuscable id="p-linea" value={p.linea ?? ''} onChange={(v) => setP({ ...p, linea: v })} options={catalogos.lineas.map((c) => ({ value: c, label: c }))} buscarPlaceholder="Buscar línea…" />
                                        </div>
                                        <div className="sm:col-span-2">
                                            <span className={etiqueta}>Tipo de producto</span>
                                            <Segmentado label="Tipo de producto" valor={p.tipo_producto ?? ''} onChange={(v) => setP({ ...p, tipo_producto: v })} opciones={catalogos.tipos.map((t) => ({ v: t, l: t.charAt(0) + t.slice(1).toLowerCase() }))} />
                                        </div>
                                        <div>
                                            <label htmlFor="p-precio" className={etiqueta}>
                                                Precio promedio
                                            </label>
                                            <Input id="p-precio" type="number" step="0.01" value={p.precio_promedio ?? 0} onChange={(e) => setP({ ...p, precio_promedio: e.target.value })} />
                                        </div>
                                        <div>
                                            <label htmlFor="p-uds" className={etiqueta}>
                                                Unidades por caja
                                            </label>
                                            <Input id="p-uds" type="number" step="1" value={p.unidades_por_caja ?? 1} onChange={(e) => setP({ ...p, unidades_por_caja: e.target.value })} />
                                        </div>
                                    </div>
                                </Seccion>

                                <Seccion
                                    titulo="Alias por cadena"
                                    ayuda="Nombres con los que cada cadena puede reportar el producto."
                                    accion={
                                        <div className="flex gap-2">
                                            <Button type="button" size="sm" variant="outline" onClick={abrirSinMatch}>
                                                <SearchX className="size-4" /> Desde sin match
                                            </Button>
                                            <Button type="button" size="sm" variant="outline" onClick={() => setAliases([...aliases, { cadena: catalogos.cadenas[0] ?? '', alias_nombre: '', factor_conversion: 1, confianza_manual: 100, activo: true }])}>
                                                <Plus className="size-4" /> Agregar alias
                                            </Button>
                                        </div>
                                    }
                                >
                                    {aliases.length === 0 ? (
                                        <p className="rounded-lg bg-slate-50 px-4 py-3 text-sm text-muted-foreground">Este producto todavía no tiene alias registrados.</p>
                                    ) : (
                                        <div className="overflow-x-auto rounded-lg border border-border">
                                            <table className="w-full text-sm">
                                                <thead>
                                                    <tr className="border-b border-border bg-slate-50 text-left text-xs text-muted-foreground">
                                                        <th className="px-3 py-2 font-medium">Cadena</th>
                                                        <th className="px-3 py-2 font-medium">Alias</th>
                                                        <th className="px-3 py-2 font-medium">Factor</th>
                                                        <th className="px-3 py-2 font-medium">Confianza</th>
                                                        <th className="px-3 py-2 text-center font-medium">Activo</th>
                                                        <th className="w-10" />
                                                    </tr>
                                                </thead>
                                                <tbody>
                                                    {aliases.map((a, i) => (
                                                        <tr key={i} className="border-b border-border last:border-0">
                                                            <td className="px-3 py-2">
                                                                <input list="cadenas" aria-label="Cadena" value={a.cadena} onChange={(e) => setAlias(i, { cadena: e.target.value })} className={clsx(celda, 'h-8 w-24')} />
                                                            </td>
                                                            <td className="px-3 py-2">
                                                                <input aria-label="Alias" value={a.alias_nombre} onChange={(e) => setAlias(i, { alias_nombre: e.target.value })} className={clsx(celda, 'h-8 min-w-48')} />
                                                            </td>
                                                            <td className="px-3 py-2">
                                                                <input aria-label="Factor de conversión" type="number" step="0.0001" value={a.factor_conversion} onChange={(e) => setAlias(i, { factor_conversion: e.target.value })} className={clsx(celda, 'h-8 w-24 text-right tabular-nums')} />
                                                            </td>
                                                            <td className="px-3 py-2">
                                                                <input aria-label="Confianza" type="number" min={0} max={100} value={a.confianza_manual} onChange={(e) => setAlias(i, { confianza_manual: e.target.value })} className={clsx(celda, 'h-8 w-20 text-right tabular-nums')} />
                                                            </td>
                                                            <td className="px-3 py-2 text-center">
                                                                <Checkbox aria-label="Alias activo" checked={a.activo} onCheckedChange={(v) => setAlias(i, { activo: v === true })} />
                                                            </td>
                                                            <td className="pr-2">
                                                                <button type="button" onClick={() => (setEliminados([...eliminados, a]), setAliases(aliases.filter((_, j) => j !== i)))} className="grid size-7 place-items-center rounded-md text-muted-foreground hover:bg-red-50 hover:text-red-600" aria-label="Quitar alias">
                                                                    <Trash2 className="size-4" />
                                                                </button>
                                                            </td>
                                                        </tr>
                                                    ))}
                                                </tbody>
                                            </table>
                                        </div>
                                    )}
                                    <datalist id="cadenas">
                                        {catalogos.cadenas.map((c) => (
                                            <option key={c} value={c} />
                                        ))}
                                    </datalist>
                                </Seccion>

                                <Seccion
                                    titulo="Distribución de comisión"
                                    ayuda="Cómo se reparte la venta del producto por línea / equipo."
                                    accion={
                                        <Button type="button" size="sm" variant="outline" onClick={() => setComisiones([...comisiones, { linea: '', equipo: '', clasificacion: p.tipo_producto || 'SECUNDARIO', peso: 0 }])}>
                                            <Plus className="size-4" /> Agregar línea
                                        </Button>
                                    }
                                >
                                    {comisiones.length > 0 && (
                                        <div className="mb-4 overflow-x-auto rounded-lg border border-border">
                                            <table className="w-full text-sm">
                                                <thead>
                                                    <tr className="border-b border-border bg-slate-50 text-left text-xs text-muted-foreground">
                                                        <th className="px-3 py-2 font-medium">Línea</th>
                                                        <th className="px-3 py-2 font-medium">Equipo</th>
                                                        <th className="px-3 py-2 font-medium">Clasificación</th>
                                                        <th className="px-3 py-2 font-medium">Peso</th>
                                                        <th className="px-3 py-2 text-right font-medium">%</th>
                                                        <th className="w-10" />
                                                    </tr>
                                                </thead>
                                                <tbody>
                                                    {comisiones.map((c, i) => (
                                                        <tr key={i} className="border-b border-border last:border-0">
                                                            <td className="min-w-36 px-3 py-2">
                                                                <SelectBuscable value={c.linea} onChange={(v) => setComision(i, { linea: v, equipo: '' })} options={lineasComision.map((l) => ({ value: l, label: l }))} placeholder="Línea" buscarPlaceholder="Buscar línea…" />
                                                            </td>
                                                            <td className="min-w-36 px-3 py-2">
                                                                <SelectBuscable value={c.equipo} onChange={(v) => setComision(i, { equipo: v })} options={equiposDe(c.linea).map((e) => ({ value: e, label: e }))} placeholder={c.linea ? 'Equipo' : 'Elige línea'} disabled={!c.linea} buscarPlaceholder="Buscar equipo…" />
                                                            </td>
                                                            <td className="px-3 py-2">
                                                                <select aria-label="Clasificación" value={c.clasificacion} onChange={(e) => setComision(i, { clasificacion: e.target.value })} className={clsx(celda, 'h-9 w-32')}>
                                                                    {catalogos.tipos.map((t) => (
                                                                        <option key={t}>{t}</option>
                                                                    ))}
                                                                </select>
                                                            </td>
                                                            <td className="px-3 py-2">
                                                                <input aria-label="Peso" type="number" step="0.0001" value={c.peso} onChange={(e) => setComision(i, { peso: e.target.value })} className={clsx(celda, 'h-9 w-24 text-right tabular-nums')} />
                                                            </td>
                                                            <td className="px-3 py-2 text-right tabular-nums">{pct(toNum(c.peso) * 100)}</td>
                                                            <td className="pr-2">
                                                                <button type="button" onClick={() => setComisiones(comisiones.filter((_, j) => j !== i))} className="grid size-7 place-items-center rounded-md text-muted-foreground hover:bg-red-50 hover:text-red-600" aria-label="Quitar línea de comisión">
                                                                    <Trash2 className="size-4" />
                                                                </button>
                                                            </td>
                                                        </tr>
                                                    ))}
                                                </tbody>
                                            </table>
                                        </div>
                                    )}

                                    {/* Total configurado vs. restante GENERAL */}
                                    <div className={clsx('rounded-lg px-4 py-3', excede ? 'bg-red-50' : 'bg-slate-50')}>
                                        <div className="mb-2 flex flex-wrap items-baseline justify-between gap-2 text-sm">
                                            <span className={clsx('font-medium', excede && 'text-red-700')}>Configurado: {pct(total * 100)}</span>
                                            <span className={clsx('text-xs', excede ? 'text-red-700' : 'text-muted-foreground')}>
                                                {excede ? 'Supera el 100%; ajusta los pesos.' : comisiones.length === 0 ? 'Sin distribución: irá 100% a GENERAL.' : `El restante ${pct(Math.max(0, 1 - total) * 100)} será GENERAL.`}
                                            </span>
                                        </div>
                                        <div className="h-1.5 overflow-hidden rounded-full bg-slate-200" role="img" aria-label={`${pct(total * 100)} configurado`}>
                                            <div className={clsx('h-full rounded-full', excede ? 'bg-red-500' : 'bg-ibero-navy')} style={{ width: `${Math.min(100, total * 100)}%` }} />
                                        </div>
                                    </div>
                                </Seccion>
                            </>
                        )}
                    </div>

                    {/* Pie fijo con la acción principal */}
                    {!cargando && (
                        <div className="flex flex-wrap items-center justify-between gap-3 border-t border-border bg-white px-6 py-4">
                            <label className={clsx('flex items-center gap-2 text-sm', !original && 'text-muted-foreground')}>
                                <Checkbox checked={historicos && !!original} disabled={!original} onCheckedChange={(v) => setHistoricos(v === true)} />
                                <span>
                                    Aplicar a históricos y recalcular dashboards
                                    {original && <span className="block text-xs text-amber-700">Nombre sin match pendiente: {original}</span>}
                                </span>
                            </label>
                            <div className="flex gap-2">
                                <Button variant="outline" disabled={ocupado} onClick={cerrarEditor}>
                                    Cancelar
                                </Button>
                                <Button disabled={ocupado || excede} onClick={() => void guardar()}>
                                    {ocupado ? 'Guardando…' : editor?.modo === 'nuevo' ? 'Crear producto' : 'Guardar cambios'}
                                </Button>
                            </div>
                        </div>
                    )}
                </SheetContent>
            </Sheet>

            {/* Pendientes sin match: nombres que reportan las cadenas sin producto asignado. */}
            <Dialog open={verSinMatch} onOpenChange={setVerSinMatch}>
                <DialogContent className="sm:max-w-2xl">
                    <DialogHeader>
                        <DialogTitle>Pendientes sin match</DialogTitle>
                        <DialogDescription>
                            {sinMatch ? `${int(sinMatch.length)} nombres reportados por cadenas sin producto asignado.` : 'Cargando…'} {editando || editor?.modo === 'nuevo' ? 'Puedes agregarlos como alias del producto abierto o crear uno nuevo.' : 'Crea un producto a partir del nombre, o abre un producto para asignárselo como alias.'}
                        </DialogDescription>
                    </DialogHeader>
                    <div className="relative">
                        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-muted-foreground" />
                        <Input value={filtroSinMatch} onChange={(e) => setFiltroSinMatch(e.target.value)} placeholder="Filtrar por nombre" className="pl-9" />
                    </div>
                    <ul className="-mx-1 max-h-96 space-y-1 overflow-y-auto px-1">
                        {!sinMatch &&
                            Array.from({ length: 4 }, (_, i) => (
                                <li key={i}>
                                    <Skeleton className="h-12 w-full" />
                                </li>
                            ))}
                        {sinMatchFiltrados.map((s) => (
                            <li key={s.producto_original} className="flex flex-wrap items-center justify-between gap-2 rounded-lg border border-border px-3 py-2">
                                <div className="min-w-0">
                                    <p className="truncate text-sm font-medium">{s.producto_original}</p>
                                    <p className="text-xs text-muted-foreground tabular-nums">
                                        {int(s.filas)} filas · {money(s.venta)}
                                    </p>
                                </div>
                                <div className="flex gap-2">
                                    {(editando || editor?.modo === 'nuevo') && (
                                        <Button
                                            size="sm"
                                            variant="outline"
                                            onClick={() => {
                                                setOriginal(s.producto_original);
                                                setAliases((a) => [...a, { cadena: 'CRL', alias_nombre: s.producto_original, factor_conversion: 1, confianza_manual: 100, activo: true }]);
                                                setVerSinMatch(false);
                                            }}
                                        >
                                            Agregar como alias
                                        </Button>
                                    )}
                                    <Button
                                        size="sm"
                                        variant={editando || editor?.modo === 'nuevo' ? 'ghost' : 'outline'}
                                        onClick={() => {
                                            nuevoDesde(s.producto_original);
                                            setVerSinMatch(false);
                                        }}
                                    >
                                        <Plus className="size-4" /> Crear producto
                                    </Button>
                                </div>
                            </li>
                        ))}
                        {sinMatch && sinMatchFiltrados.length === 0 && <li className="py-8 text-center text-sm text-muted-foreground">{sinMatch.length === 0 ? 'No hay pendientes. Todo tiene producto asignado.' : 'Ningún nombre coincide con el filtro.'}</li>}
                    </ul>
                </DialogContent>
            </Dialog>

            {/* CoMarketing: elegir vigencia y archivo → vista previa → aplicar. */}
            <Dialog open={cm.abierto} onOpenChange={(o) => !o && !ocupado && setCm((c) => ({ abierto: false, vigencia: c.vigencia }))}>
                <DialogContent>
                    <DialogHeader>
                        <DialogTitle>Importar comarketing</DialogTitle>
                        <DialogDescription>Excel con CODIGO | LINEA | EQUIPO | CLASIFICACION | PESO. Los productos que no estén en el archivo no se modifican. Primero verás una vista previa; nada cambia hasta que aplicas.</DialogDescription>
                    </DialogHeader>
                    <div className="grid gap-4 sm:grid-cols-2">
                        <div>
                            <label htmlFor="cm-vigencia" className={etiqueta}>
                                Aplicar desde
                            </label>
                            <Input id="cm-vigencia" type="month" value={cm.vigencia} onChange={(e) => setCm((c) => ({ ...c, vigencia: e.target.value, preview: undefined, rows: undefined, archivo: undefined }))} />
                        </div>
                        <div>
                            <span className={etiqueta}>Archivo</span>
                            <Button type="button" variant="outline" className="w-full justify-start" disabled={ocupado} onClick={() => inputCm.current?.click()}>
                                <FileUp className="size-4 text-muted-foreground" />
                                <span className="truncate">{cm.archivo ?? 'Elegir archivo…'}</span>
                            </Button>
                            <input
                                ref={inputCm}
                                type="file"
                                accept=".xlsx,.xls,.csv"
                                className="hidden"
                                onChange={(e) => {
                                    const f = e.target.files?.[0];
                                    e.target.value = '';
                                    if (f) void previsualizarComarketing(f);
                                }}
                            />
                        </div>
                    </div>
                    {ocupado && !cm.preview && <p className="text-sm text-muted-foreground">Leyendo el archivo y preparando la vista previa…</p>}
                    {cm.preview && (
                        <div className="rounded-lg bg-amber-50 px-4 py-3 text-sm text-amber-900">
                            <p className="mb-1 font-medium">Vista previa desde {cm.vigencia}-01</p>
                            <dl className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-0.5 text-xs">
                                {Object.entries(cm.preview)
                                    .filter(([, v]) => typeof v !== 'object')
                                    .map(([k, v]) => (
                                        <div key={k} className="contents">
                                            <dt className="text-amber-800/80">{k}</dt>
                                            <dd className="font-medium tabular-nums">{String(v)}</dd>
                                        </div>
                                    ))}
                            </dl>
                        </div>
                    )}
                    {msg?.t === 'err' && <Mensaje />}
                    <DialogFooter>
                        <Button variant="outline" disabled={ocupado} onClick={() => setCm((c) => ({ abierto: false, vigencia: c.vigencia }))}>
                            Cancelar
                        </Button>
                        <Button disabled={!cm.preview || ocupado} onClick={() => void aplicarComarketing()}>
                            {ocupado && cm.preview ? 'Aplicando…' : 'Aplicar comarketing'}
                        </Button>
                    </DialogFooter>
                </DialogContent>
            </Dialog>

            <Confirmar
                abierto={archivoBase !== null}
                titulo="¿Subir la base de productos?"
                descripcion={
                    <>
                        Se actualizarán por su código los productos de <strong className="text-foreground">{archivoBase?.name}</strong>. Los que no vienen en el archivo no cambian.
                    </>
                }
                accion="Sí, subir base"
                onCerrar={() => setArchivoBase(null)}
                onConfirmar={() => archivoBase && void subirBase(archivoBase)}
            />

            <Confirmar abierto={confirmarSap} titulo="¿Actualizar la clasificación desde SAP?" descripcion="Se actualizará la clasificación de los productos con los datos de SAP." accion="Sí, actualizar" onCerrar={() => setConfirmarSap(false)} onConfirmar={() => void clasificacionSap()} />
        </AppLayout>
    );
}
