import { PRIVILEGIO_VER_TODO_TABLERO, resolverAlcancePropio, UUID_NULO } from './alcance-propio';

/**
 * Alcance propio del Tablero: quien está vinculado como vendedor/cobrador en la empresa y no tiene REP_DSH_VER_TODO en
 * un perfil de esa empresa ve solo sus números. El mock filtra de verdad por empresa, usuario y activo, así los casos
 * «otra empresa» e «inactivo» prueban la consulta y no el mock.
 */
type Vinculo = {
  id: string;
  empresa_id: string;
  usuario_id: string;
  active: boolean;
  tipo: string;
  nombre: string;
  apellido: string | null;
};
type Asignacion = { perfil_empresa: string; user_id: string; codigo: string; pp_active: boolean; pr_active: boolean };

const USR = 'usr-1';
const EMP = 'emp-1';
const OTRA = 'emp-2';

const crearPrisma = ({
  superadmin = false,
  tipoEmpresa = 'subsidiary',
  vinculos = [] as Vinculo[],
  asignaciones = [] as Asignacion[],
} = {}) =>
  ({
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: tipoEmpresa }) },
    vendedores_cobradores: {
      findMany: jest.fn(({ where }) =>
        Promise.resolve(
          vinculos
            .filter(
              (v) =>
                v.empresa_id === where.empresa_id && v.usuario_id === where.usuario_id && v.active === where.active,
            )
            .sort((a, b) => a.id.localeCompare(b.id))
            .map(({ id, nombre, apellido, tipo }) => ({ id, nombre, apellido, tipo })),
        ),
      ),
    },
    perfiles_privilegios: {
      findFirst: jest.fn(({ where }) => {
        const hit = asignaciones.find(
          (a) =>
            a.pp_active === where.active &&
            a.codigo === where.privilegios.codigo &&
            a.pr_active === where.privilegios.active &&
            a.perfil_empresa === where.perfiles.empresa_id &&
            a.user_id === where.perfiles.usuario_perfiles.some.user_id,
        );
        return Promise.resolve(hit ? { id: 'pp-1' } : null);
      }),
    },
  }) as any;

const vinculo = (over: Partial<Vinculo> = {}): Vinculo => ({
  id: 'vc-1',
  empresa_id: EMP,
  usuario_id: USR,
  active: true,
  tipo: 'vendedor',
  nombre: 'Ana',
  apellido: 'Gómez',
  ...over,
});
const verTodo = (over: Partial<Asignacion> = {}): Asignacion => ({
  perfil_empresa: EMP,
  user_id: USR,
  codigo: PRIVILEGIO_VER_TODO_TABLERO,
  pp_active: true,
  pr_active: true,
  ...over,
});

describe('resolverAlcancePropio', () => {
  it('el código del privilegio y el UUID nulo son los acordados', () => {
    expect(PRIVILEGIO_VER_TODO_TABLERO).toBe('REP_DSH_VER_TODO');
    expect(UUID_NULO).toBe('00000000-0000-0000-0000-000000000000');
  });

  it('sin vínculo y sin VER_TODO: PROPIO sin vínculo, los dos ids null (todo vacío, nunca la empresa)', async () => {
    expect(await resolverAlcancePropio(crearPrisma(), USR, EMP)).toEqual({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
  });

  it('sin vínculo con REP_DSH_VER_TODO en un perfil de la empresa: TODO', async () => {
    expect(await resolverAlcancePropio(crearPrisma({ asignaciones: [verTodo()] }), USR, EMP)).toEqual({ tipo: 'TODO' });
  });

  it('sin vínculo con VER_TODO solo en otra empresa: PROPIO sin vínculo', async () => {
    const prisma = crearPrisma({ asignaciones: [verTodo({ perfil_empresa: OTRA })] });
    expect(await resolverAlcancePropio(prisma, USR, EMP)).toEqual({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
  });

  it('superadmin sin vínculo: TODO', async () => {
    expect(await resolverAlcancePropio(crearPrisma({ superadmin: true }), USR, EMP)).toEqual({ tipo: 'TODO' });
  });

  it.each(['holding', 'reseller'])('empresa %s sin vínculo: TODO', async (tipoEmpresa) => {
    expect(await resolverAlcancePropio(crearPrisma({ tipoEmpresa }), USR, EMP)).toEqual({ tipo: 'TODO' });
  });

  it('vínculo vendedor: PROPIO con vendedorId y cobradorId null', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ vinculos: [vinculo()] }), USR, EMP);
    expect(r).toEqual({ tipo: 'PROPIO', vendedorId: 'vc-1', cobradorId: null, nombre: 'Ana Gómez', sinVinculo: false });
  });

  it('vínculo cobrador: PROPIO con cobradorId y vendedorId null', async () => {
    const r = await resolverAlcancePropio(
      crearPrisma({ vinculos: [vinculo({ tipo: 'cobrador', apellido: null })] }),
      USR,
      EMP,
    );
    expect(r).toEqual({ tipo: 'PROPIO', vendedorId: null, cobradorId: 'vc-1', nombre: 'Ana', sinVinculo: false });
  });

  it('vínculo ambos: los dos ids son el mismo vínculo', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ vinculos: [vinculo({ tipo: 'ambos' })] }), USR, EMP);
    expect(r).toEqual({ tipo: 'PROPIO', vendedorId: 'vc-1', cobradorId: 'vc-1', nombre: 'Ana Gómez', sinVinculo: false });
  });

  it('un vínculo vendedor y otro cobrador: cada id del suyo', async () => {
    const prisma = crearPrisma({
      vinculos: [vinculo({ id: 'vc-b', tipo: 'cobrador' }), vinculo({ id: 'vc-a', tipo: 'vendedor' })],
    });
    const r = await resolverAlcancePropio(prisma, USR, EMP);
    expect(r).toMatchObject({ tipo: 'PROPIO', vendedorId: 'vc-a', cobradorId: 'vc-b', sinVinculo: false });
  });

  it('vínculo inactivo: PROPIO sin vínculo (vacío)', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ vinculos: [vinculo({ active: false })] }), USR, EMP);
    expect(r).toEqual({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
  });

  it('vínculo de otra empresa: PROPIO sin vínculo (vacío)', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ vinculos: [vinculo({ empresa_id: OTRA })] }), USR, EMP);
    expect(r).toEqual({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
  });

  it('vínculo activo + REP_DSH_VER_TODO en un perfil de la misma empresa: TODO', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ vinculos: [vinculo()], asignaciones: [verTodo()] }), USR, EMP);
    expect(r).toEqual({ tipo: 'TODO' });
  });

  it('VER_TODO en un perfil de otra empresa: sigue PROPIO', async () => {
    const prisma = crearPrisma({ vinculos: [vinculo()], asignaciones: [verTodo({ perfil_empresa: OTRA })] });
    expect((await resolverAlcancePropio(prisma, USR, EMP)).tipo).toBe('PROPIO');
  });

  it('VER_TODO con la asignación o el privilegio inactivo: sigue PROPIO', async () => {
    const a = crearPrisma({ vinculos: [vinculo()], asignaciones: [verTodo({ pp_active: false })] });
    const b = crearPrisma({ vinculos: [vinculo()], asignaciones: [verTodo({ pr_active: false })] });
    expect((await resolverAlcancePropio(a, USR, EMP)).tipo).toBe('PROPIO');
    expect((await resolverAlcancePropio(b, USR, EMP)).tipo).toBe('PROPIO');
  });

  it('otro privilegio de Reportes no alcanza: sigue PROPIO', async () => {
    const prisma = crearPrisma({ vinculos: [vinculo()], asignaciones: [verTodo({ codigo: 'REP_DSH_DASHBOARD_VER' })] });
    expect((await resolverAlcancePropio(prisma, USR, EMP)).tipo).toBe('PROPIO');
  });

  it('superadmin con vínculo: TODO', async () => {
    const r = await resolverAlcancePropio(crearPrisma({ superadmin: true, vinculos: [vinculo()] }), USR, EMP);
    expect(r).toEqual({ tipo: 'TODO' });
  });

  it.each(['holding', 'reseller'])('empresa %s con vínculo: TODO', async (tipoEmpresa) => {
    const r = await resolverAlcancePropio(crearPrisma({ tipoEmpresa, vinculos: [vinculo()] }), USR, EMP);
    expect(r).toEqual({ tipo: 'TODO' });
  });
});
