import { BadRequestException, ForbiddenException, Injectable } from '@nestjs/common';
import { PrismaService } from 'src/prisma/prisma.service';
import {
  INCLUDE_DOCUMENTO_MONEDA,
  MonedaApi,
  monedaBaseEmpresa,
  monedaDeComision,
  parseYmd,
  resolverRecibosMulti,
  whereEstadoComision,
  whereFechaDocumento,
} from 'src/vendedores-cobradores/comisiones-moneda';
import { ymdInAsuncion } from 'src/utils/utilidades';

export const CODIGO_SIN_VINCULO = 'SIN_VINCULO_VENDEDOR_COBRADOR';
const MAX_PROXIMAS = 10;

type Vinculo = { id: string; tipo: string };
type Moneda = { codigo: string };

export type MiComision = {
  por_moneda: {
    moneda: Moneda;
    por_tipo: { tipo: string; por_estado: { estado: string; monto: number; cantidad: number }[] }[];
  }[];
  /** Comisiones sin moneda resoluble (ni del documento ni base de la empresa): se cuentan aparte, no se suman. */
  sin_moneda: { cantidad: number; por_tipo: { tipo: string; cantidad: number }[] };
};

export type MisPromesas =
  | { aplica: false }
  | {
      aplica: true;
      por_estado: { estado: string; cantidad: number; monto: number; moneda: Moneda }[];
      /** Promesas del período sin moneda resoluble (ni de su factura ni base): se cuentan aparte, sin monto. */
      sin_moneda: { cantidad: number };
      proximas: { id: string; cliente: string; fecha: string; monto: number | null; moneda: Moneda | null }[];
    };

@Injectable()
export class TableroPropioService {
  constructor(private readonly prisma: PrismaService) {}

  /** Vínculos activos del usuario en ESA empresa. Sin ninguno: 403. */
  private async vinculos(empresaId: string, usuarioId: string): Promise<Vinculo[]> {
    const v = await this.prisma.vendedores_cobradores.findMany({
      where: { empresa_id: empresaId, usuario_id: usuarioId, active: true },
      select: { id: true, tipo: true },
      orderBy: { id: 'asc' },
    });
    if (v.length === 0) {
      throw new ForbiddenException({
        message: 'Su usuario no está vinculado como vendedor o cobrador.',
        codigo: CODIGO_SIN_VINCULO,
      });
    }
    return v;
  }

  private periodo(desde?: string, hasta?: string) {
    const d = parseYmd(desde, 'fecha desde');
    const h = parseYmd(hasta, 'fecha hasta');
    if (d && h && d > h) throw new BadRequestException('La fecha desde no puede ser posterior a la hasta');
    return { desde: d, hasta: h };
  }

  /** Comisiones propias del período (fecha del documento), agrupadas moneda → tipo → estado. */
  async miComision(empresaId: string, usuarioId: string, desdeIn?: string, hastaIn?: string): Promise<MiComision> {
    const vinculos = await this.vinculos(empresaId, usuarioId);
    const { desde, hasta } = this.periodo(desdeIn, hastaIn);

    const encontradas = await this.prisma.comisiones.findMany({
      where: {
        empresa_id: empresaId,
        vendedor_cobrador_id: { in: vinculos.map((v) => v.id) },
        AND: [whereFechaDocumento(desde, hasta), whereEstadoComision()],
      },
      include: INCLUDE_DOCUMENTO_MONEDA,
    });
    const comisiones = await resolverRecibosMulti(this.prisma, encontradas, desde, hasta);
    const base = await monedaBaseEmpresa(this.prisma, empresaId);

    const porMoneda = new Map<string, { moneda: MonedaApi; celdas: Map<string, { monto: number; cantidad: number }> }>();
    const sinMoneda = new Map<string, number>();
    for (const c of comisiones) {
      const moneda = monedaDeComision(c, base);
      if (!moneda) {
        sinMoneda.set(c.tipo, (sinMoneda.get(c.tipo) ?? 0) + 1);
        continue;
      }
      const g = porMoneda.get(moneda.id) ?? { moneda, celdas: new Map() };
      porMoneda.set(moneda.id, g);
      // El estado nunca es NULL acá: `whereEstadoComision` (notIn) deja afuera las filas sin estado.
      const clave = `${c.tipo}|${c.estado}`;
      const celda = g.celdas.get(clave) ?? { monto: 0, cantidad: 0 };
      celda.monto += Number(c.monto_comision);
      celda.cantidad += 1;
      g.celdas.set(clave, celda);
    }

    const orden = ['venta', 'cobranza'];
    const tiposDe = (celdas: Map<string, unknown>) => {
      const tipos = [...new Set([...celdas.keys()].map((k) => k.split('|')[0]))];
      return [...orden.filter((t) => tipos.includes(t)), ...tipos.filter((t) => !orden.includes(t)).sort()];
    };

    return {
      sin_moneda: {
        cantidad: [...sinMoneda.values()].reduce((a, b) => a + b, 0),
        por_tipo: [...sinMoneda.entries()].map(([tipo, cantidad]) => ({ tipo, cantidad })).sort((a, b) => a.tipo.localeCompare(b.tipo)),
      },
      por_moneda: [...porMoneda.values()]
        .sort((a, b) => a.moneda.codigo.localeCompare(b.moneda.codigo))
        .map(({ moneda, celdas }) => ({
          moneda: { codigo: moneda.codigo },
          por_tipo: tiposDe(celdas)
            .map((tipo) => ({
              tipo,
              por_estado: [...celdas.entries()]
                .filter(([k]) => k.startsWith(`${tipo}|`))
                .map(([k, v]) => ({ estado: k.slice(tipo.length + 1), monto: v.monto, cantidad: v.cantidad }))
                .sort((a, b) => a.estado.localeCompare(b.estado)),
            })),
        })),
    };
  }

  /** Promesas de pago propias (solo cobrador/ambos). La moneda es la de la factura de la promesa. */
  async misPromesas(empresaId: string, usuarioId: string, desdeIn?: string, hastaIn?: string): Promise<MisPromesas> {
    const vinculos = await this.vinculos(empresaId, usuarioId);
    const cobradorIds = vinculos.filter((v) => v.tipo === 'cobrador' || v.tipo === 'ambos').map((v) => v.id);
    if (cobradorIds.length === 0) return { aplica: false };
    const { desde, hasta } = this.periodo(desdeIn, hastaIn);

    const fecha = {
      ...(desde ? { gte: new Date(`${desde}T00:00:00.000Z`) } : {}),
      ...(hasta ? { lte: new Date(`${hasta}T00:00:00.000Z`) } : {}),
    };
    const base = await monedaBaseEmpresa(this.prisma, empresaId);
    const selectFactura = { select: { moneda: { select: { id: true, codigo: true, simbolo: true } } } };

    const delPeriodo = await this.prisma.promesas_pago.findMany({
      where: {
        empresa_id: empresaId,
        cobrador_id: { in: cobradorIds },
        ...(desde || hasta ? { fecha_prometida: fecha } : {}),
      },
      select: { estado: true, monto_prometido: true, factura: selectFactura },
    });

    const grupos = new Map<string, { estado: string; moneda: Moneda; cantidad: number; monto: number }>();
    let sinMoneda = 0;
    for (const p of delPeriodo) {
      const moneda = p.factura?.moneda ?? base;
      if (!moneda) {
        sinMoneda += 1;
        continue;
      }
      const clave = `${p.estado}|${moneda.id}`;
      const g = grupos.get(clave) ?? { estado: p.estado, moneda: { codigo: moneda.codigo ?? '' }, cantidad: 0, monto: 0 };
      g.cantidad += 1;
      g.monto += Number(p.monto_prometido ?? 0);
      grupos.set(clave, g);
    }

    // Próximas: abiertas (pendiente) desde hoy en adelante, sin importar el período elegido.
    const proximasDb = await this.prisma.promesas_pago.findMany({
      where: {
        empresa_id: empresaId,
        cobrador_id: { in: cobradorIds },
        estado: 'pendiente',
        fecha_prometida: { gte: new Date(`${ymdInAsuncion()}T00:00:00.000Z`) },
      },
      orderBy: [{ fecha_prometida: 'asc' }, { id: 'asc' }],
      take: MAX_PROXIMAS,
      select: {
        id: true,
        fecha_prometida: true,
        monto_prometido: true,
        cliente: { select: { nombre_fantasia: true, personas: { select: { razon_social: true } } } },
        factura: selectFactura,
      },
    });

    return {
      aplica: true,
      por_estado: [...grupos.values()].sort(
        (a, b) => a.estado.localeCompare(b.estado) || a.moneda.codigo.localeCompare(b.moneda.codigo),
      ),
      sin_moneda: { cantidad: sinMoneda },
      proximas: proximasDb.map((p) => {
        const moneda = p.factura?.moneda ?? base;
        return {
          id: p.id,
          cliente: p.cliente?.personas?.razon_social ?? p.cliente?.nombre_fantasia ?? '',
          fecha: p.fecha_prometida.toISOString().slice(0, 10),
          monto: p.monto_prometido == null ? null : Number(p.monto_prometido),
          moneda: moneda ? { codigo: moneda.codigo ?? '' } : null,
        };
      }),
    };
  }
}
