import type { PromocaoVigente, RegraVigente } from '@sar/api-interface';
import { usePromocoesVigentes, useRegrasVigentes, useMinhaAlcada } from './queries/politicas';

// Condição comercial vigente que alcança um produto: promoção (por produto ou
// grupo) ou regra de desconto (por grupo/subgrupo/rep). Usada para sinalizar no
// catálogo do rep que o produto tem proposta diferenciada e detalhar qual é.

export interface CondicaoComercial {
  tipo: 'promocao' | 'regra';
  descricao: string;
  descPct: number;
  dataFim: string;
}

export interface ProdutoRef {
  codigo: string;
  codGrupo: number | null;
  codSubgrupo: number | null;
}

export function condicoesDoProduto(
  p: ProdutoRef,
  promocoes: PromocaoVigente[] | undefined,
  regras: RegraVigente[] | undefined,
): CondicaoComercial[] {
  const conds: CondicaoComercial[] = [];

  for (const promo of promocoes ?? []) {
    const porProduto = promo.codProduto && promo.codProduto.trim() === p.codigo.trim();
    const porGrupo =
      promo.grpProd && p.codGrupo != null && promo.grpProd.trim() === String(p.codGrupo);
    if (porProduto || porGrupo) {
      conds.push({
        tipo: 'promocao',
        descricao: promo.descricao,
        descPct: promo.descPct,
        dataFim: promo.dataFim,
      });
    }
  }

  for (const regra of regras ?? []) {
    const grupoOk = regra.codGrupo == null || (p.codGrupo != null && regra.codGrupo === p.codGrupo);
    const subgrupoOk =
      regra.codSubgrupo == null || (p.codSubgrupo != null && regra.codSubgrupo === p.codSubgrupo);
    if (grupoOk && subgrupoOk) {
      conds.push({
        tipo: 'regra',
        descricao: regra.descricao,
        descPct: regra.descPct,
        dataFim: regra.dataFim,
      });
    }
  }

  return conds.sort((a, b) => b.descPct - a.descPct);
}

// Hook: função de lookup por produto, com promoções e regras vigentes em cache
export function useCondicoesComerciais(): (p: ProdutoRef) => CondicaoComercial[] {
  const { data: promos } = usePromocoesVigentes();
  const { data: regras } = useRegrasVigentes();
  return (p) => condicoesDoProduto(p, promos?.promocoes, regras?.regras);
}

// Teto de desconto do item — espelha assertAlcadaItens do backend: vale o MAIOR
// entre a alçada do grupo (codGrupo 0 = default; sem linha, 5%) e a melhor
// promoção/regra vigente que alcança o produto.
export function useTetoDesconto(): (p: ProdutoRef) => number {
  const condicoesDe = useCondicoesComerciais();
  const { data: alcada } = useMinhaAlcada();
  return (p) => {
    const limites = new Map((alcada?.limites ?? []).map((l) => [l.codGrupo, l.limitePerc]));
    const base = (p.codGrupo != null ? limites.get(p.codGrupo) : undefined) ?? limites.get(0) ?? 5;
    const cond = condicoesDe(p).reduce((max, c) => Math.max(max, c.descPct), 0);
    return Math.max(base, cond);
  };
}
