import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { TimbradoEmpresaDto } from './dto/create-timbrado.dto';
import { EmpresasController } from './empresas.controller';
import { EmpresasService } from './empresas.service';

/**
 * C0 críticos › `GET /empresas/:id` y el correo de la empresa.
 * - Devolvían la contraseña SMTP en claro (`empresas_correo.password`) y el CSC del timbrado (código de seguridad de
 *   SIFEN): a cualquier usuario con sesión de la empresa, y a otras empresas vía el respaldo «tiene ADM_EMP_EMPRESA_VER»
 *   (que no miraba la red) o el `is_superadmin` del dueño de cualquier empresa. Ahora nunca salen: en su lugar
 *   `password_configurada` / `csc_configurado`, y guardar sin reenviarlos conserva los que había.
 * - Leer otra empresa: solo la plataforma, una asignación explícita o la red de la empresa del usuario.
 *
 * Red: holding (raíz) → kety (reseller) → nieta; holding → otra. ajena no cuelga de nadie.
 */
const empresas: Record<string, { parent_id: string | null; type: string }> = {
  holding: { parent_id: null, type: 'holding' },
  kety: { parent_id: 'holding', type: 'reseller' },
  nieta: { parent_id: 'kety', type: 'subsidiary' },
  otra: { parent_id: 'holding', type: 'subsidiary' },
  ajena: { parent_id: null, type: 'subsidiary' },
};
const usuarios: Record<string, { empresa_id: string; is_superadmin: boolean }> = {
  plataforma: { empresa_id: 'holding', is_superadmin: true },
  adminHolding: { empresa_id: 'holding', is_superadmin: false },
  duenoOtra: { empresa_id: 'otra', is_superadmin: true },
  adminOtra: { empresa_id: 'otra', is_superadmin: false },
  asignado: { empresa_id: 'otra', is_superadmin: false },
};

function crear(extra: Record<string, unknown> = {}) {
  const prisma: any = {
    usuario: {
      findUnique: jest.fn(async ({ where }: any) => {
        const u = usuarios[where.id];
        return u ? { ...u, empresa_rel: empresas[u.empresa_id], es_admin_plataforma: where.id === 'plataforma' } : null;
      }),
    },
    empresas: {
      findUnique: jest.fn(async ({ where }: any) => (empresas[where.id] ? { id: where.id, razon_social: where.id, usar_correo_propio: true, ...empresas[where.id] } : null)),
      findFirst: jest.fn().mockResolvedValue(null),
      update: jest.fn(async ({ where }: any) => ({ id: where.id, razon_social: where.id })),
    },
    usuario_empresas: {
      findFirst: jest.fn(async ({ where }: any) => (where.usuario_id === 'asignado' && where.empresa_id === 'ajena' ? { id: 'a1' } : null)),
    },
    // Si el código volviera a mirar el privilegio, que lo encuentre: el adminOtra lo tiene.
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue({ id: 'pp' }) },
    empresas_correo: { findFirst: jest.fn(), update: jest.fn(async ({ data }: any) => ({ id: 'c1', ...data })), create: jest.fn(async ({ data }: any) => ({ id: 'c1', ...data })) },
    empresas_timbrado: { findFirst: jest.fn(), update: jest.fn(), create: jest.fn() },
    actividades_economicas: { deleteMany: jest.fn(), createMany: jest.fn() },
    estado_empresa: { findFirst: jest.fn() },
    ...extra,
  };
  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 { service, prisma };
}
const user = (id: string, empresa_id = usuarios[id].empresa_id) => ({ id, username: id, empresa_id }) as any;

describe('GET /empresas/:id de otra empresa (requirePermisoLecturaOtraEmpresa)', () => {
  it.each([
    ['el dueño (is_superadmin) de una subsidiaria NO lee una empresa ajena', 'duenoOtra', 'ajena', false],
    ['el dueño de una subsidiaria NO lee a su hermana ni a la holding', 'duenoOtra', 'kety', false],
    ['un Administrador con ADM_EMP_EMPRESA_VER NO lee fuera de su red', 'adminOtra', 'ajena', false],
    ['la plataforma lee cualquiera', 'plataforma', 'ajena', true],
    ['la holding lee su red, nietas incluidas', 'adminHolding', 'nieta', true],
    ['con asignación explícita (usuario_empresas) se lee', 'asignado', 'ajena', true],
  ] as const)('%s', async (_n, quien, destino, pasa) => {
    const r = crear().service.requirePermisoLecturaOtraEmpresa(user(quien), destino);
    if (pasa) await expect(r).resolves.toBeUndefined();
    else await expect(r).rejects.toBeInstanceOf(ForbiddenException);
  });
});

describe('las respuestas de empresa nunca llevan secretos', () => {
  it('findOne: sin contraseña SMTP ni CSC, con «configurado: sí/no»', async () => {
    const { service, prisma } = crear();
    prisma.empresas.findUnique = jest.fn().mockResolvedValue({
      id: 'otra',
      razon_social: 'Otra',
      empresas_correo: [{ id: 'c1', host: 'smtp.x', username: 'u', password: 'SECRETO-SMTP', email: 'a@x.com' }],
      empresas_timbrado: [
        { id: 't1', num_timbrado: '12345678', id_csc: '001', csc: 'SECRETO-CSC', ambiente: 'prod' },
        { id: 't2', num_timbrado: '87654321', id_csc: null, csc: null, ambiente: 'hml' },
      ],
      certificados: [],
      suscripciones: [],
    });
    const r: any = await service.findOne('otra');
    expect(JSON.stringify(r)).not.toContain('SECRETO');
    expect(r.empresas_correo[0]).not.toHaveProperty('password');
    expect(r.empresas_correo[0]).toMatchObject({ host: 'smtp.x', password_configurada: true });
    expect(r.empresas_timbrado[0]).not.toHaveProperty('csc');
    expect(r.empresas_timbrado[0]).toMatchObject({ id_csc: '001', csc_configurado: true });
    expect(r.empresas_timbrado[1]).toMatchObject({ csc_configurado: false });
  });

  it('GET :id/correo: sin la contraseña del correo propio', async () => {
    const { service, prisma } = crear();
    prisma.empresas_correo.findFirst = jest.fn(async ({ where }: any) =>
      where.system === true ? { id: 's', email: 'sys@x.com', password: 'SECRETO-SYS' } : { id: 'c1', host: 'smtp.x', password: 'SECRETO-SMTP' },
    );
    const r: any = await service.getEmpresaCorreo('otra');
    expect(JSON.stringify(r)).not.toContain('SECRETO');
    expect(r.correo_propio).toMatchObject({ host: 'smtp.x', password_configurada: true });
  });

  it('PUT :id/correo sin contraseña conserva la guardada y no la devuelve', async () => {
    const { service, prisma } = crear();
    prisma.empresas_correo.findFirst = jest.fn().mockResolvedValue({ id: 'c1', password: 'SECRETO-SMTP' });
    // Prisma devuelve la fila entera, con la contraseña que quedó guardada.
    prisma.empresas_correo.update = jest.fn(async ({ data }: any) => ({ id: 'c1', password: 'SECRETO-SMTP', ...data }));
    const r: any = await service.upsertEmpresaCorreo('otra', { usar_correo_propio: true, host: 'h', username: 'u', password: '', email: 'a@x.com' });
    expect(prisma.empresas_correo.update.mock.calls[0][0].data).not.toHaveProperty('password');
    expect(JSON.stringify(r)).not.toContain('SECRETO');
    expect(r.correo).toMatchObject({ password_configurada: true });
  });

  it('PUT :id/correo con contraseña nueva la graba; sin ninguna guardada la exige', async () => {
    const { service, prisma } = crear();
    prisma.empresas_correo.findFirst = jest.fn().mockResolvedValue({ id: 'c1', password: 'vieja' });
    await service.upsertEmpresaCorreo('otra', { usar_correo_propio: true, host: 'h', username: 'u', password: 'nueva', email: 'a@x.com' });
    expect(prisma.empresas_correo.update.mock.calls[0][0].data.password).toBe('nueva');

    const otro = crear();
    otro.prisma.empresas_correo.findFirst = jest.fn().mockResolvedValue(null);
    await expect(
      otro.service.upsertEmpresaCorreo('otra', { usar_correo_propio: true, host: 'h', username: 'u', email: 'a@x.com' }),
    ).rejects.toBeInstanceOf(BadRequestException);
  });
});

describe('timbrado: guardar sin reenviar el CSC conserva el guardado', () => {
  const timbrado = { num_timbrado: '12345678', fecha_inicio: '2026-01-01', id_csc: '001', ambiente: 'prod' };

  it('el DTO acepta el timbrado sin CSC', async () => {
    const errores = await validate(plainToInstance(TimbradoEmpresaDto, timbrado));
    expect(errores).toHaveLength(0);
  });

  it('con timbrado existente: no toca el CSC', async () => {
    const { service, prisma } = crear();
    jest.spyOn(service, 'findOne').mockResolvedValue({ razon_social: 'Otra', ruc: '1' } as any);
    prisma.empresas_timbrado.findFirst = jest.fn().mockResolvedValue({ id: 't1', csc: 'SECRETO-CSC' });
    await service.update('otra', { timbrado: { ...timbrado, csc: '' } } as any, 'u');
    expect(prisma.empresas_timbrado.update.mock.calls[0][0].data).not.toHaveProperty('csc');
  });

  it('timbrado nuevo sin CSC: se rechaza', async () => {
    const { service, prisma } = crear();
    jest.spyOn(service, 'findOne').mockResolvedValue({ razon_social: 'Otra', ruc: '1' } as any);
    prisma.empresas_timbrado.findFirst = jest.fn().mockResolvedValue(null);
    const err = await service.update('otra', { timbrado } as any, 'u').catch((e) => e);
    // Llega como 400 con su mensaje, no envuelto en un error genérico (500).
    expect(err).toBeInstanceOf(BadRequestException);
    expect(err.message).toBe('El CSC (código de seguridad) es obligatorio para un timbrado nuevo');
    expect(prisma.empresas_timbrado.create).not.toHaveBeenCalled();
  });
});

describe('PUT /empresas/:id: el 400 del CSC llega tal cual', () => {
  it('el controlador no reenvuelve la HttpException del servicio', async () => {
    const rechazo = new BadRequestException('El CSC (código de seguridad) es obligatorio para un timbrado nuevo');
    const service: any = {
      exigirAlcance: jest.fn(),
      exigirCambioDeJerarquia: jest.fn(),
      exigirCambioDeIdentidadFiscal: jest.fn(),
      update: jest.fn().mockRejectedValue(rechazo),
    };
    const controller = new EmpresasController(service);
    await expect(controller.update('otra', {} as any, { id: 'u' } as any)).rejects.toBe(rechazo);
  });
});
