import { REQUIRE_MODULE_KEY } from 'src/auth/decorators/require-module.decorator';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { resolverAlcancePropio } from 'src/utils/alcance-propio';
import { alcanceCubreEmpresa, alcanceSucursalUsuario, esAlcanceTotal } from 'src/utils/alcance-sucursal';
import { TableroController } from './tablero.controller';
import { TableroService } from './tablero.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
  esAlcanceTotal: jest.fn(),
  alcanceCubreEmpresa: jest.fn(),
}));
jest.mock('src/utils/alcance-propio', () => ({
  ...jest.requireActual('src/utils/alcance-propio'),
  resolverAlcancePropio: jest.fn(),
}));
// La regla del alcance propio se prueba en alcance-propio.spec.ts; acá, que el contexto la exponga.
const propioMock = resolverAlcancePropio as jest.Mock;
const alcanceMock = alcanceSucursalUsuario as jest.Mock;
// La regla de «total» (F1, sucursal o rubro) se prueba en alcance-sucursal.spec.ts; acá, que el contexto la use.
const totalMock = esAlcanceTotal as jest.Mock;
const cubreMock = alcanceCubreEmpresa as jest.Mock;

const PYG = { id: 'm-pyg', codigo: 'PYG', descripcion: 'Guaraní' };
const USD = { id: 'm-usd', codigo: 'USD', descripcion: 'Dólar' };
const EUR = { id: 'm-eur', codigo: 'EUR', descripcion: 'Euro' };
const SUCURSALES = [
  { id: 's1', descripcion: 'Casa central', empresa_id: 'emp', active: true },
  { id: 's2', descripcion: 'Sucursal 2', empresa_id: 'emp', active: true },
];
const EMPRESA_MONEDAS = [
  { moneda_id: PYG.id, es_principal: true, active: true, moneda: PYG },
  { moneda_id: USD.id, es_principal: false, active: true, moneda: USD },
  { moneda_id: EUR.id, es_principal: false, active: false, moneda: EUR },
];

const crearPrisma = () => ({
  empresas_sucursales: {
    findMany: jest.fn(({ where }) => {
      const ids: string[] | undefined = where?.id?.in;
      return Promise.resolve(
        SUCURSALES.filter((s) => s.empresa_id === where.empresa_id && (!ids || ids.includes(s.id))).map(({ id, descripcion }) => ({
          id,
          descripcion,
        })),
      );
    }),
  },
  empresa_monedas: {
    findFirst: jest.fn(({ where }) =>
      Promise.resolve(EMPRESA_MONEDAS.find((m) => m.es_principal === where.es_principal) ?? null),
    ),
    findMany: jest.fn(({ where }) =>
      Promise.resolve(EMPRESA_MONEDAS.filter((m) => (where.active?.not === false ? m.active !== false : true))),
    ),
  },
  moneda: {
    findUnique: jest.fn(({ where }) => Promise.resolve([PYG, USD, EUR].find((m) => m.id === where.id) ?? null)),
    findFirst: jest.fn(({ where }) => Promise.resolve([PYG, USD, EUR].find((m) => m.codigo === where.codigo) ?? null)),
  },
});

describe('TableroService.contexto', () => {
  beforeEach(() => {
    alcanceMock.mockReset();
    totalMock.mockReset();
    cubreMock.mockReset();
    propioMock.mockReset();
    propioMock.mockResolvedValue({ tipo: 'TODO' });
  });

  it('alcance null: total, con todas las sucursales activas', async () => {
    alcanceMock.mockResolvedValue(null);
    totalMock.mockResolvedValue(true);
    const prisma: any = crearPrisma();
    const ctx = await new TableroService(prisma).contexto('emp', 'usr');
    expect(ctx.alcance_total).toBe(true);
    expect(ctx.sucursales).toEqual([
      { id: 's1', nombre: 'Casa central' },
      { id: 's2', nombre: 'Sucursal 2' },
    ]);
    expect(prisma.empresas_sucursales.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: expect.objectContaining({ empresa_id: 'emp', active: { not: false } }) }),
    );
  });

  it('alcance { sucursalIds: ["s1"] }: no es total y solo s1', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s1'], puntosEstablecimiento: ['001'], depositoIds: [] });
    totalMock.mockResolvedValue(false);
    const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
    expect(ctx.alcance_total).toBe(false);
    expect(ctx.sucursales).toEqual([{ id: 's1', nombre: 'Casa central' }]);
  });

  it('asignado a todas las sucursales activas: total (F1), con la regla de esAlcanceTotal', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s1', 's2'], puntosEstablecimiento: [], depositoIds: [] });
    totalMock.mockResolvedValue(true);
    const prisma: any = crearPrisma();
    const ctx = await new TableroService(prisma).contexto('emp', 'usr');
    expect(totalMock).toHaveBeenCalledWith(prisma, 'usr', 'emp');
    expect(ctx.alcance_total).toBe(true);
    expect(ctx.sucursales.map((s) => s.id)).toEqual(['s1', 's2']);
  });

  it('todas las sucursales pero con rubro elegido: no es total y ofrece las del alcance', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s1', 's2'], puntosEstablecimiento: [], depositoIds: [] });
    totalMock.mockResolvedValue(false);
    const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
    expect(ctx.alcance_total).toBe(false);
    expect(ctx.sucursales.map((s) => s.id)).toEqual(['s1', 's2']);
  });

  describe('ia_bloqueada (I2): por qué no se ve la IA aunque tenga el permiso', () => {
    it('alcance total: null, sin mirar nada más', async () => {
      alcanceMock.mockResolvedValue(null);
      totalMock.mockResolvedValue(true);
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.ia_bloqueada).toBeNull();
      expect(cubreMock).not.toHaveBeenCalled();
    });

    it('ve toda la empresa pero eligió un rubro: RUBRO_ELEGIDO', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: ['s1'], puntosEstablecimiento: [], depositoIds: [] });
      totalMock.mockResolvedValue(false);
      cubreMock.mockResolvedValue(true);
      const prisma: any = crearPrisma();
      const ctx = await new TableroService(prisma).contexto('emp', 'usr');
      expect(cubreMock).toHaveBeenCalledWith(prisma, 'usr', 'emp');
      expect(ctx.ia_bloqueada).toBe('RUBRO_ELEGIDO');
    });

    it('limitado a sucursales (con o sin rubro): SUCURSALES_LIMITADAS, elegir «Todos los rubros» no lo arregla', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: ['s1'], puntosEstablecimiento: [], depositoIds: [] });
      totalMock.mockResolvedValue(false);
      cubreMock.mockResolvedValue(false);
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.ia_bloqueada).toBe('SUCURSALES_LIMITADAS');
    });
  });

  describe('solo_propio (A2): vinculado como vendedor/cobrador sin REP_DSH_VER_TODO', () => {
    it('alcance TODO: solo_propio null y la IA según sucursal/rubro', async () => {
      alcanceMock.mockResolvedValue(null);
      totalMock.mockResolvedValue(true);
      const prisma: any = crearPrisma();
      const ctx = await new TableroService(prisma).contexto('emp', 'usr');
      expect(propioMock).toHaveBeenCalledWith(prisma, 'usr', 'emp');
      expect(ctx.solo_propio).toBeNull();
      expect(ctx.ia_bloqueada).toBeNull();
    });

    it('vendedor: { vendedor: true, cobrador: false, nombre } e ia_bloqueada SOLO_PROPIO aunque el alcance sea total', async () => {
      alcanceMock.mockResolvedValue(null);
      totalMock.mockResolvedValue(true);
      propioMock.mockResolvedValue({ tipo: 'PROPIO', vendedorId: 'vc', cobradorId: null, nombre: 'Ana Gómez', sinVinculo: false });
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.solo_propio).toEqual({ vendedor: true, cobrador: false, nombre: 'Ana Gómez', sin_vinculo: false });
      expect(ctx.alcance_total).toBe(true);
      expect(ctx.ia_bloqueada).toBe('SOLO_PROPIO');
    });

    it('ambos: los dos en true', async () => {
      alcanceMock.mockResolvedValue(null);
      totalMock.mockResolvedValue(true);
      propioMock.mockResolvedValue({ tipo: 'PROPIO', vendedorId: 'vc', cobradorId: 'vc', nombre: 'Ana', sinVinculo: false });
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.solo_propio).toEqual({ vendedor: true, cobrador: true, nombre: 'Ana', sin_vinculo: false });
    });

    it('cobrador limitado a una sucursal: SOLO_PROPIO va antes que SUCURSALES_LIMITADAS', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: ['s1'], puntosEstablecimiento: [], depositoIds: [] });
      totalMock.mockResolvedValue(false);
      cubreMock.mockResolvedValue(false);
      propioMock.mockResolvedValue({ tipo: 'PROPIO', vendedorId: null, cobradorId: 'vc', nombre: 'Ana', sinVinculo: false });
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.solo_propio).toEqual({ vendedor: false, cobrador: true, nombre: 'Ana', sin_vinculo: false });
      expect(ctx.ia_bloqueada).toBe('SOLO_PROPIO');
      expect(ctx.sucursales).toEqual([{ id: 's1', nombre: 'Casa central' }]);
    });

    it('sin vínculo (regla estricta): solo_propio con sin_vinculo, los dos en false, e ia_bloqueada SOLO_PROPIO', async () => {
      alcanceMock.mockResolvedValue(null);
      totalMock.mockResolvedValue(true);
      propioMock.mockResolvedValue({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
      const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
      expect(ctx.solo_propio).toEqual({ vendedor: false, cobrador: false, nombre: '', sin_vinculo: true });
      expect(ctx.ia_bloqueada).toBe('SOLO_PROPIO');
    });
  });

  it('sin moneda base resoluble: moneda_base null, no un código vacío', async () => {
    alcanceMock.mockResolvedValue(null);
    totalMock.mockResolvedValue(true);
    const prisma: any = crearPrisma();
    prisma.empresa_monedas.findFirst = jest.fn().mockResolvedValue(null);
    prisma.moneda.findFirst = jest.fn().mockResolvedValue(null);
    const ctx = await new TableroService(prisma).contexto('emp', 'usr');
    expect(ctx.moneda_base).toBeNull();
  });

  it('moneda base PYG y monedas sin las inactivas', async () => {
    alcanceMock.mockResolvedValue(null);
    totalMock.mockResolvedValue(true);
    const ctx = await new TableroService(crearPrisma() as any).contexto('emp', 'usr');
    expect(ctx.moneda_base).toEqual({ id: 'm-pyg', codigo: 'PYG' });
    expect(ctx.monedas).toEqual([
      { id: 'm-pyg', codigo: 'PYG', descripcion: 'Guaraní' },
      { id: 'm-usd', codigo: 'USD', descripcion: 'Dólar' },
    ]);
  });
});

describe('TableroController', () => {
  it('pide el módulo REPORTES con ModuleGuard', () => {
    expect(Reflect.getMetadata(REQUIRE_MODULE_KEY, TableroController)).toBe('REPORTES');
    const guards = Reflect.getMetadata('__guards__', TableroController) ?? [];
    expect(guards).toContain(ModuleGuard);
  });
});
