import { RotateCcw, Save, Search } from 'lucide-react';
import clsx from 'clsx';
import { useEffect, useMemo, useState } from 'react';
import { Paginacion } from '@/components/Paginacion';
import { int, pct, toNum } from '@/lib/format';
import { leer, primeroDeMes, useAccion, useLectura } from './api';
import { Btn, Caja, Estado, input, Msg, Tabla } from './ui';
import type { VendedoresConfig } from './tipos';

const total = (xs: { weightPct: number | string }[]) => xs.reduce((a, x) => a + toNum(x.weightPct), 0);
function Total({ v }: { v: number }) {
    const ok = Math.abs(v - 100) < 0.01;
    return <span className={clsx('rounded-full px-2.5 py-1 text-xs font-medium tabular-nums', ok ? 'bg-emerald-50 text-emerald-700' : 'bg-red-50 text-red-700')}>Total {pct(v, 2)}{ok ? '' : ' (debe sumar 100%)'}</span>;
}

/* ---------- Distribución por tipo (zona 1 / zona 2 por grupo) ---------- */
export function TabDistribucion({ anio, mes, cfg, recargar }: { anio: number; mes: number; cfg: VendedoresConfig; recargar: () => void }) {
    const dist = useLectura<{ rows: { tipo_producto: string; zona1_pct: number; zona2_pct: number; total_pct: number; completo: boolean; vigente_desde?: string }[]; regla?: string }>('get_distribucion_tipo_producto_unificada_v1', { p_mes: primeroDeMes(anio, mes) });
    const grupos = useMemo(() => Array.from(new Set(cfg.zoneWeights.filter((z) => z.active).map((z) => z.group))).sort(), [cfg.zoneWeights]);
    const [w, setW] = useState<Record<string, number>>({});
    useEffect(() => setW(Object.fromEntries(cfg.zoneWeights.filter((z) => z.active).map((z) => [`${z.group}|${z.zone}`, toNum(z.weightPct)]))), [cfg.zoneWeights]);
    const { msg, ocupado, ejecutar } = useAccion(() => (recargar(), void dist.recargar()));

    return (
        <>
            <Msg msg={msg} />
            <Caja titulo="Distribución por tipo de producto" sub={dist.data?.regla ?? 'Cada tipo de producto distribuye 100% entre Zona 1 y Zona 2.'}>
                <Estado cargando={dist.cargando} error={dist.error} />
                <Tabla cols={['Tipo', ['Zona 1 %', 'r'], ['Zona 2 %', 'r'], ['Total', 'r'], 'Vigente desde']} min="min-w-[500px]">
                    {(dist.data?.rows ?? []).map((r) => (
                        <tr key={r.tipo_producto} className="border-t border-border">
                            <td className="font-medium">{r.tipo_producto}</td>
                            <td className="px-2 text-right">{pct(r.zona1_pct)}</td>
                            <td className="px-2 text-right">{pct(r.zona2_pct)}</td>
                            <td className={clsx('px-2 text-right font-bold', r.completo ? 'text-emerald-700' : 'text-red-600')}>{pct(r.total_pct)}</td>
                            <td className="px-2">{r.vigente_desde}</td>
                        </tr>
                    ))}
                </Tabla>
            </Caja>
            <Caja titulo={`Editar pesos por zona · ${anio}`} sub="Para cada grupo, Zona 1 + Zona 2 debe sumar 100%." className="mt-4">
                <Tabla cols={['Grupo', ['Zona 1 %', 'r'], ['Zona 2 %', 'r'], ['Total', 'r']]} min="min-w-[500px]">
                    {grupos.map((g) => {
                        const t = (w[`${g}|ZONA 1`] ?? 0) + (w[`${g}|ZONA 2`] ?? 0);
                        return (
                            <tr key={g} className="border-t border-border">
                                <td className="font-medium">{g}</td>
                                {['ZONA 1', 'ZONA 2'].map((z) => (
                                    <td key={z} className="px-2 text-right">
                                        <input type="number" step="0.01" value={w[`${g}|${z}`] ?? 0} onChange={(e) => setW({ ...w, [`${g}|${z}`]: Number(e.target.value) })} className={`${input} w-24 text-right`} />
                                    </td>
                                ))}
                                <td className={clsx('px-2 text-right font-bold', Math.abs(t - 100) < 0.01 ? 'text-emerald-700' : 'text-red-600')}>{pct(t, 2)}</td>
                            </tr>
                        );
                    })}
                </Tabla>
                <div className="mt-4 flex justify-end">
                    <Btn
                        disabled={ocupado || grupos.some((g) => Math.abs((w[`${g}|ZONA 1`] ?? 0) + (w[`${g}|ZONA 2`] ?? 0) - 100) > 0.01)}
                        onClick={() => void ejecutar('guardar_presupuesto_vendedor_pesos_zona', { p_anio: anio, p_rows: grupos.flatMap((g) => ['ZONA 1', 'ZONA 2'].map((z) => ({ group: g, zone: z, weightPct: w[`${g}|${z}`] ?? 0 }))) }, 'Pesos por zona guardados.')}
                    >
                        <Save className="size-4" /> Guardar distribución
                    </Btn>
                </div>
            </Caja>
        </>
    );
}

/* ---------- Pesos generales de vendedores (por grupo y zona) ---------- */
export function TabPesosVendedores({ anio, cfg, recargar }: { anio: number; cfg: VendedoresConfig; recargar: () => void }) {
    const combos = useMemo(() => Array.from(new Set(cfg.sellerWeights.map((s) => `${s.group}|${s.zone}`))).sort(), [cfg.sellerWeights]);
    const [combo, setCombo] = useState(combos[0] ?? '');
    const [grupo, zona] = combo.split('|') as [string, string];
    const [filas, setFilas] = useState<{ sellerCode: string; seller: string; weightPct: number }[]>([]);
    useEffect(() => setFilas(cfg.sellerWeights.filter((s) => s.group === grupo && s.zone === zona && s.active).map((s) => ({ sellerCode: s.sellerCode, seller: s.seller, weightPct: toNum(s.weightPct) }))), [cfg.sellerWeights, grupo, zona]);
    const [nuevo, setNuevo] = useState('');
    const { msg, ocupado, ejecutar } = useAccion(recargar);
    const t = total(filas);

    return (
        <>
            <Msg msg={msg} />
            <Caja
                titulo="Pesos generales de vendedores"
                sub="Cómo se reparte el presupuesto de cada grupo y zona entre los vendedores. Debe sumar 100%."
                derecha={
                    <select value={combo} onChange={(e) => setCombo(e.target.value)} className={input}>
                        {combos.map((c) => (
                            <option key={c} value={c}>
                                {c.replace('|', ' · ')}
                            </option>
                        ))}
                    </select>
                }
            >
                <Tabla cols={['Código', 'Vendedor', ['Peso %', 'r'], '']} min="min-w-[500px]">
                    {filas.map((f, i) => (
                        <tr key={f.sellerCode} className="border-t border-border">
                            <td className="px-2 py-1.5 font-medium text-muted-foreground">{f.sellerCode}</td>
                            <td className="px-2">{f.seller}</td>
                            <td className="px-2 text-right">
                                <input type="number" step="0.01" value={f.weightPct} onChange={(e) => setFilas(filas.map((x, j) => (j === i ? { ...x, weightPct: Number(e.target.value) } : x)))} className={`${input} w-24 text-right`} />
                            </td>
                            <td className="px-2 text-right">
                                <button type="button" onClick={() => setFilas(filas.filter((_, j) => j !== i))} className="text-sm text-red-600 hover:underline">
                                    Quitar
                                </button>
                            </td>
                        </tr>
                    ))}
                </Tabla>
                <div className="mt-4 flex flex-wrap items-center justify-between gap-3">
                    <span className="flex gap-2">
                        <select value={nuevo} onChange={(e) => setNuevo(e.target.value)} className={input}>
                            <option value="">Agregar vendedor…</option>
                            {cfg.sellers
                                .filter((s) => s.active && !filas.some((f) => f.sellerCode === s.sellerCode))
                                .map((s) => (
                                    <option key={s.sellerCode} value={s.sellerCode}>
                                        {s.sellerCode} · {s.seller} · {s.zone}
                                    </option>
                                ))}
                        </select>
                        <Btn tono="neutro" disabled={!nuevo} onClick={() => (setFilas([...filas, { sellerCode: nuevo, seller: cfg.sellers.find((s) => s.sellerCode === nuevo)?.seller ?? nuevo, weightPct: 0 }]), setNuevo(''))}>
                            Agregar
                        </Btn>
                    </span>
                    <span className="flex items-center gap-2">
                        <Total v={t} />
                        <Btn disabled={ocupado || Math.abs(t - 100) > 0.01} onClick={() => void ejecutar('guardar_presupuesto_vendedor_pesos', { p_anio: anio, p_grupo: grupo, p_zona: zona, p_rows: filas.map((f) => ({ sellerCode: f.sellerCode, weightPct: f.weightPct })) }, `Pesos de ${grupo} · ${zona} guardados.`)}>
                            <Save className="size-4" /> Guardar
                        </Btn>
                    </span>
                </div>
            </Caja>
        </>
    );
}

/* ---------- Pesos por producto (excepción a los pesos generales) ---------- */
export function TabPesosProducto({ anio, cfg, recargar }: { anio: number; cfg: VendedoresConfig; recargar: () => void }) {
    const [producto, setProducto] = useState('');
    const [zona, setZona] = useState('ZONA 1');
    const [data, setData] = useState<{ product?: { productId: string; product: string; group: string }; rows: { sellerCode: string; seller?: string; weightPct: number }[] } | null>(null);
    const [motivo, setMotivo] = useState('');
    const [err, setErr] = useState<string | null>(null);
    const cargar = async () => {
        setErr(null);
        try {
            const r = await leer<{ product?: { productId: string; product: string; group: string }; rows?: { sellerCode: string; seller?: string; weightPct: number }[] }>('get_presupuesto_vendedor_producto_config', { p_anio: anio, p_producto_id: producto.trim().toUpperCase(), p_zona: zona });
            setData({ product: r.product, rows: (r.rows ?? []).map((x) => ({ ...x, weightPct: toNum(x.weightPct) })) });
        } catch (e) {
            setErr(e instanceof Error ? e.message : String(e));
        }
    };
    const { msg, ocupado, ejecutar } = useAccion(() => (recargar(), void cargar()));
    const t = total(data?.rows ?? []);

    return (
        <>
            <Msg msg={msg} />
            <Caja titulo="Pesos por producto" sub="Excepción: reparto específico de un producto entre vendedores, distinto al general del grupo.">
                <form
                    className="mb-4 flex flex-wrap gap-2"
                    onSubmit={(e) => {
                        e.preventDefault();
                        void cargar();
                    }}
                >
                    <div className="relative">
                        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-muted-foreground" />
                        <input required value={producto} onChange={(e) => setProducto(e.target.value)} placeholder="Código producto (ej. PT000386)" className={`${input} pl-9`} />
                    </div>
                    <select value={zona} onChange={(e) => setZona(e.target.value)} className={input}>
                        <option>ZONA 1</option>
                        <option>ZONA 2</option>
                    </select>
                    <Btn type="submit" tono="neutro">
                        Consultar
                    </Btn>
                </form>
                {err && <p className="mb-2 text-sm text-red-600">{err}</p>}
                {data && (
                    <>
                        <p className="mb-2 text-sm">
                            <b>{data.product?.product}</b> <span className="text-muted-foreground">· {data.product?.group} · {zona}</span>
                        </p>
                        {data.rows.length === 0 && <p className="mb-2 text-xs text-muted-foreground">Sin excepción: usa los pesos generales del grupo. Agrega vendedores para crear una.</p>}
                        <Tabla cols={['Vendedor', ['Peso %', 'r'], '']} min="min-w-[400px]">
                            {data.rows.map((f, i) => (
                                <tr key={f.sellerCode} className="border-t border-border">
                                    <td className="px-2 py-1.5">
                                        {f.sellerCode} · {f.seller ?? cfg.sellers.find((s) => s.sellerCode === f.sellerCode)?.seller}
                                    </td>
                                    <td className="px-2 text-right">
                                        <input type="number" step="0.01" value={f.weightPct} onChange={(e) => setData({ ...data, rows: data.rows.map((x, j) => (j === i ? { ...x, weightPct: Number(e.target.value) } : x)) })} className={`${input} w-24 text-right`} />
                                    </td>
                                    <td className="px-2 text-right">
                                        <button type="button" onClick={() => setData({ ...data, rows: data.rows.filter((_, j) => j !== i) })} className="text-sm text-red-600 hover:underline">
                                            Quitar
                                        </button>
                                    </td>
                                </tr>
                            ))}
                        </Tabla>
                        <div className="mt-4 flex flex-wrap items-center justify-between gap-3">
                            <select
                                value=""
                                onChange={(e) => e.target.value && setData({ ...data, rows: [...data.rows, { sellerCode: e.target.value, weightPct: 0 }] })}
                                className={input}
                            >
                                <option value="">Agregar vendedor…</option>
                                {cfg.sellers.filter((s) => s.active && s.zone === zona && !data.rows.some((r) => r.sellerCode === s.sellerCode)).map((s) => (
                                    <option key={s.sellerCode} value={s.sellerCode}>
                                        {s.sellerCode} · {s.seller}
                                    </option>
                                ))}
                            </select>
                            <span className="flex items-center gap-2">
                                <input value={motivo} onChange={(e) => setMotivo(e.target.value)} placeholder="Motivo (opcional)" className={input} />
                                <Total v={t} />
                                <Btn tono="neutro" disabled={ocupado} onClick={() => void ejecutar('restaurar_presupuesto_vendedor_producto_pesos', { p_anio: anio, p_producto_id: data.product?.productId, p_zona: zona }, 'Restaurado a los pesos generales.', '¿Quitar la excepción y volver a los pesos generales?')}>
                                    <RotateCcw className="size-4" /> Restaurar
                                </Btn>
                                <Btn disabled={ocupado || !data.rows.length || Math.abs(t - 100) > 0.01} onClick={() => void ejecutar('guardar_presupuesto_vendedor_producto_pesos', { p_anio: anio, p_producto_id: data.product?.productId, p_zona: zona, p_rows: data.rows.map((r) => ({ sellerCode: r.sellerCode, weightPct: r.weightPct })), p_motivo: motivo || null }, 'Pesos del producto guardados.')}>
                                    <Save className="size-4" /> Guardar
                                </Btn>
                            </span>
                        </div>
                    </>
                )}
            </Caja>
        </>
    );
}

/* ---------- Exclusiones producto × vendedor ---------- */
export function TabExclusiones({ anio, cfg }: { anio: number; cfg: VendedoresConfig }) {
    const [buscar, setBuscar] = useState('');
    const [q, setQ] = useState('');
    const [pagina, setPagina] = useState(1);
    const ex = useLectura<{ rows: { id: number; zone: string; group: string; active: boolean; reason?: string; seller: string; sellerCode: string; product: string; productId: string; validFrom?: string }[]; total: number; totalPages: number }>('get_presupuesto_vendedor_exclusiones', { p_anio: anio, p_search: q || null, p_page: pagina, p_page_size: 50 });
    const { msg, ocupado, ejecutar } = useAccion(() => void ex.recargar());
    const [nueva, setNueva] = useState({ producto: '', vendedor: '', motivo: '' });

    return (
        <>
            <Msg msg={msg} />
            <Caja titulo="Exclusiones producto × vendedor" sub={`Productos que un vendedor no debe recibir en su presupuesto · ${int(ex.data?.total)} registradas.`}>
                <div className="mb-4 flex flex-wrap items-end justify-between gap-3">
                    <form
                        className="flex gap-2"
                        onSubmit={(e) => {
                            e.preventDefault();
                            setPagina(1);
                            setQ(buscar.trim());
                        }}
                    >
                        <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={buscar} onChange={(e) => setBuscar(e.target.value)} placeholder="Buscar producto o vendedor" className={`${input} w-64 pl-9`} />
                        </div>
                        <Btn type="submit" tono="neutro">
                            Buscar
                        </Btn>
                    </form>
                    <span className="flex flex-wrap gap-2">
                        <input value={nueva.producto} onChange={(e) => setNueva({ ...nueva, producto: e.target.value })} placeholder="Código producto" className={`${input} w-32`} />
                        <select value={nueva.vendedor} onChange={(e) => setNueva({ ...nueva, vendedor: e.target.value })} className={input}>
                            <option value="">Vendedor…</option>
                            {cfg.sellers.filter((s) => s.active).map((s) => (
                                <option key={s.sellerCode} value={s.sellerCode}>
                                    {s.sellerCode} · {s.seller}
                                </option>
                            ))}
                        </select>
                        <input value={nueva.motivo} onChange={(e) => setNueva({ ...nueva, motivo: e.target.value })} placeholder="Motivo" className={input} />
                        <Btn disabled={ocupado || !nueva.producto || !nueva.vendedor} onClick={() => void ejecutar('guardar_presupuesto_vendedor_exclusion', { p_anio: anio, p_producto_id: nueva.producto.trim().toUpperCase(), p_codigo_vendedor: nueva.vendedor, p_activo: true, p_motivo: nueva.motivo || null }, 'Exclusión agregada.').then((r) => r && setNueva({ producto: '', vendedor: '', motivo: '' }))}>
                            Agregar exclusión
                        </Btn>
                    </span>
                </div>
                <Estado cargando={ex.cargando} error={ex.error} />
                <Tabla cols={['Producto', 'Grupo', 'Vendedor', 'Zona', 'Motivo', 'Desde', 'Estado']} min="min-w-[900px]">
                    {(ex.data?.rows ?? []).map((r) => (
                        <tr key={r.id} className="border-t border-border">
                            <td className="px-2 py-1.5">
                                <span className="block font-semibold">{r.product}</span>
                                <span className="text-xs text-muted-foreground">{r.productId}</span>
                            </td>
                            <td className="px-2">{r.group}</td>
                            <td className="px-2">
                                {r.sellerCode} · {r.seller}
                            </td>
                            <td className="px-2">{r.zone}</td>
                            <td className="px-2">{r.reason}</td>
                            <td className="px-2">{r.validFrom}</td>
                            <td className="px-2">
                                <button type="button" disabled={ocupado} onClick={() => void ejecutar('guardar_presupuesto_vendedor_exclusion', { p_anio: anio, p_producto_id: r.productId, p_codigo_vendedor: r.sellerCode, p_activo: !r.active, p_motivo: r.reason ?? null }, r.active ? 'Exclusión desactivada.' : 'Exclusión activada.')} className={clsx('rounded-full px-2 py-0.5 text-xs font-medium', r.active ? 'bg-emerald-50 text-emerald-700' : 'bg-slate-100 text-muted-foreground')}>
                                    {r.active ? 'ACTIVA' : 'INACTIVA'}
                                </button>
                            </td>
                        </tr>
                    ))}
                </Tabla>
                <div className="-mx-5 -mb-5 mt-4">
                    <Paginacion pagina={pagina} total={ex.data?.total ?? 0} porPagina={50} onChange={setPagina} />
                </div>
            </Caja>
        </>
    );
}
