import { ForbiddenException } from '@nestjs/common';
import { EmpresasController } from './empresas.controller';
import { EmpresasService } from './empresas.service';

/**
 * Carril B › T1. La identidad fiscal de la empresa (RUC, DV, tipo de contribuyente y la facturación electrónica
 * `sifen_activo`) la cambiaba cualquiera con ADM_EMP_EMPRESA_EDITAR desde Datos de la empresa. Ahora solo el dueño de esa
 * empresa (`is_superadmin` con esa empresa como principal), una empresa superior (Empresas asociadas) o la plataforma.
 * Reenviar el mismo valor no es cambio (el formulario manda todo).
 *
 * Red: holding (raíz) → latin; ajena no cuelga de nadie.
 */
const MENSAJE = 'Solo el dueño de la empresa puede cambiar el RUC, el DV, el tipo de contribuyente o la facturación electrónica.';

const empresas: Record<string, any> = {
  holding: { id: 'holding', parent_id: null, type: 'holding', ruc: '80100753', dv: '1', sifen_activo: true, tipo_contribuyente: 'tc-2', tipo_contribuyente_empresas: { codigo: 2 } },
  latin: { id: 'latin', parent_id: 'holding', type: 'subsidiary', ruc: '80000001', dv: '5', sifen_activo: true, tipo_contribuyente: 'tc-2', tipo_contribuyente_empresas: { codigo: 2 } },
  ajena: { id: 'ajena', parent_id: null, type: 'subsidiary', ruc: '80000002', dv: '3', sifen_activo: false, tipo_contribuyente: 'tc-1', tipo_contribuyente_empresas: { codigo: 1 } },
};
const usuarios: Record<string, { empresa_id: string; is_superadmin: boolean; es_admin_plataforma?: boolean }> = {
  plataforma: { empresa_id: 'holding', is_superadmin: true, es_admin_plataforma: true },
  adminHolding: { empresa_id: 'holding', is_superadmin: false },
  duenoLatin: { empresa_id: 'latin', is_superadmin: true },
  adminLatin: { empresa_id: 'latin', is_superadmin: false },
  duenoAjena: { empresa_id: 'ajena', is_superadmin: true },
};

function crear() {
  const prisma: any = {
    usuario: {
      findUnique: jest.fn(async ({ where }: any) => {
        const u = usuarios[where.id];
        return u ? { es_admin_plataforma: false, ...u, empresa_rel: empresas[u.empresa_id] } : null;
      }),
    },
    empresas: {
      findUnique: jest.fn(async ({ where }: any) => (empresas[where.id] ? { razon_social: where.id, ...empresas[where.id] } : null)),
      findFirst: jest.fn().mockResolvedValue(null),
      update: jest.fn(async ({ where, data }: any) => ({ id: where.id, ...data })),
    },
    tipo_contribuyente: { findFirst: jest.fn(async ({ where }: any) => ({ id: `tc-${where.codigo}`, codigo: where.codigo })) },
    usuario_empresas: { findFirst: jest.fn().mockResolvedValue(null) },
    empresas_timbrado: { findFirst: jest.fn(), update: jest.fn(), create: jest.fn() },
    actividades_economicas: { deleteMany: jest.fn(), createMany: jest.fn() },
    estado_empresa: { findFirst: jest.fn() },
  };
  const audit = { log: jest.fn() };
  const queues = { enqueueMiddlewareEmpresa: jest.fn() };
  const service = new EmpresasService(prisma, {} as any, {} as any, {} as any, queues as any, {} as any, {} as any, audit as any);
  return { controller: new EmpresasController(service), service, prisma };
}
const user = (id: string) => ({ id, username: id, empresa_id: usuarios[id].empresa_id }) as any;

async function put(quien: string, id: string, dto: Record<string, unknown>) {
  const ctx = crear();
  const r = ctx.controller.update(id, dto as any, user(quien));
  return { ...ctx, r };
}

describe('PUT /empresas/:id: identidad fiscal', () => {
  it.each([
    ['ruc', { ruc: '80000099' }],
    ['dv', { dv: '9' }],
    ['tipo_contribuyente', { tipo_contribuyente: 1 }],
    ['sifen_activo', { sifen_activo: false }],
  ])('un Administrador que no es el dueño cambia %s → 403 sin grabar', async (_n, dto) => {
    const { r, prisma } = await put('adminLatin', 'latin', { razon_social: 'Latin SA', ...dto });
    await expect(r).rejects.toBeInstanceOf(ForbiddenException);
    await expect(r).rejects.toThrow(MENSAJE);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it('el mismo Administrador cambia la razón social reenviando los mismos valores fiscales → 200', async () => {
    const { r, prisma } = await put('adminLatin', 'latin', { razon_social: 'Latin SA', ruc: '80000001', dv: '5', tipo_contribuyente: 2, sifen_activo: true });
    await expect(r).resolves.toMatchObject({ success: true });
    expect(prisma.empresas.update).toHaveBeenCalled();
  });

  it('el dueño cambia el RUC y la facturación electrónica → 200', async () => {
    const { r, prisma } = await put('duenoLatin', 'latin', { ruc: '80000099', dv: '7', sifen_activo: false, tipo_contribuyente: 1 });
    await expect(r).resolves.toMatchObject({ success: true });
    expect(prisma.empresas.update.mock.calls[0][0].data).toMatchObject({ ruc: '80000099', dv: '7', sifen_activo: false, tipo_contribuyente: 'tc-1' });
  });

  it('una empresa superior (Empresas asociadas) → 200, aunque no sea su dueño', async () => {
    const { r } = await put('adminHolding', 'latin', { ruc: '80000099' });
    await expect(r).resolves.toMatchObject({ success: true });
  });

  it('la plataforma → 200', async () => {
    const { r } = await put('plataforma', 'ajena', { ruc: '80000099', sifen_activo: true });
    await expect(r).resolves.toMatchObject({ success: true });
  });

  it('el dueño de otra empresa → 403 (lo corta el alcance) sin grabar', async () => {
    const { r, prisma } = await put('duenoAjena', 'latin', { ruc: '80000099' });
    await expect(r).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it('el dueño de una empresa no es dueño de otra que tenga activa: en la superior no cambia el RUC', async () => {
    const ctx = crear();
    // duenoLatin trabajando con la holding activa (asignado), sin ser su dueño ni su superior.
    ctx.prisma.usuario_empresas.findFirst = jest.fn().mockResolvedValue({ id: 'a1' });
    const r = ctx.controller.update('holding', { ruc: '80100799' } as any, { id: 'duenoLatin', username: 'x', empresa_id: 'holding' } as any);
    await expect(r).rejects.toThrow(MENSAJE);
    expect(ctx.prisma.empresas.update).not.toHaveBeenCalled();
  });
});

describe('findOne: lo más nuevo primero', () => {
  it('pide timbrados y certificados ordenados por created_at desc', async () => {
    const { service, prisma } = crear();
    const viejo = { id: 't-viejo', num_timbrado: '1', csc: null, created_at: new Date('2025-01-01') };
    const nuevo = { id: 't-nuevo', num_timbrado: '2', csc: null, created_at: new Date('2026-01-01') };
    prisma.empresas.findUnique = jest.fn(async ({ select }: any) => {
      const ordenar = (lista: any[], rel: any) =>
        rel?.orderBy?.created_at === 'desc' ? [...lista].sort((a, b) => b.created_at - a.created_at) : lista;
      return {
        id: 'latin',
        created_at: new Date(),
        updated_at: new Date(),
        empresas_timbrado: ordenar([viejo, nuevo], select.empresas_timbrado),
        certificados: ordenar([{ id: 'c-viejo', created_at: new Date('2025-01-01') }, { id: 'c-nuevo', created_at: new Date('2026-01-01') }], select.certificados),
        empresas_correo: [],
        suscripciones: [],
      };
    });
    const r: any = await service.findOne('latin');
    expect(r.empresas_timbrado.map((t: any) => t.id)).toEqual(['t-nuevo', 't-viejo']);
    expect(r.certificados.map((c: any) => c.id)).toEqual(['c-nuevo', 'c-viejo']);
  });
});
