import { ExecutionContext, ForbiddenException, RequestMethod } from '@nestjs/common';
import { GUARDS_METADATA, METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { REQUIRE_MODULE_KEY } from 'src/auth/decorators/require-module.decorator';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { PermissionGuard } from 'src/auth/guards/permission.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { DELIM_CSV } from 'src/common/marangatu/registro-comprobantes.util';
import { ComprasController } from './compras.controller';
import { ComprasService } from './compras.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  exigirAccesoElevado: jest.fn().mockResolvedValue(undefined),
}));

/**
 * El archivo para Marangatu tiene que traer lo mismo que el Libro IVA en pantalla
 * (Latincomp, oct-2026: el archivo no coincidía con la pantalla).
 */
describe('ComprasService - Libro IVA compras para Marangatu', () => {
  const persona = { razon_social: 'PROVEEDOR SA', ruc: '80000001', dv: '7', nro_documento: null };
  const gasto = (over: Record<string, unknown>) => ({
    id: 'g1',
    fecha_emision: new Date('2026-09-10T00:00:00Z'),
    timbrado: '12345678',
    establecimiento: '001',
    punto_expedicion: '001',
    numero_factura: '0000001',
    total_gravado_10: 110000,
    total_gravado_5: 0,
    total_exento: 0,
    forma_pago: 'CONTADO',
    deducible: true,
    proveedores: { personas: persona },
    moneda: { codigo: 'PYG' },
    ...over,
  });

  const crear = (gastos: any[], empresa: Record<string, unknown> = {}, despachos: any[] = []) => {
    const prisma: any = {
      empresas: {
        findUnique: jest
          .fn()
          .mockResolvedValue({ ruc: '80099999', imputa_iva: true, imputa_ire: false, imputa_irp_rsp: false, ...empresa }),
      },
      compra_cab: { findMany: jest.fn().mockResolvedValue([]) },
      gasto_cab: { findMany: jest.fn().mockResolvedValue(gastos) },
      nota_credito_compra_cab: { findMany: jest.fn().mockResolvedValue([]) },
      imp_despachos: { findMany: jest.fn().mockResolvedValue(despachos) },
      // El Libro IVA en pantalla resuelve la moneda como el Tablero (base PYG).
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'mon-pyg' }) },
      moneda: { findUnique: jest.fn().mockResolvedValue({ id: 'mon-pyg', codigo: 'PYG' }) },
    };
    return { service: new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any), prisma };
  };

  const columnas = (linea: string) => linea.split(DELIM_CSV);

  it('deja afuera la factura del exterior y los comprobantes en cero, como la pantalla', async () => {
    const { service, prisma } = crear([]);
    await service.getLibroIvaComprasMarangatu('emp-1', 9, 2026, undefined, 'C0001', 'preimpresos', 'u1');
    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where).toMatchObject({ anulado: false, total: { gt: 0 }, embarque_id: null, es_preimpreso: true });
  });

  it('un gasto no deducible no imputa IVA si la empresa imputa IRE', async () => {
    const { service } = crear([gasto({ id: 'g1', deducible: true }), gasto({ id: 'g2', numero_factura: '0000002', deducible: false })], {
      imputa_ire: true,
    });
    const r = await service.getLibroIvaComprasMarangatu('emp-1', 9, 2026, undefined, 'C0001', 'preimpresos', 'u1');
    const [deducible, noDeducible] = r.csv.split('\r\n').map(columnas);
    // Columnas 15-18: imputa IVA, IRE, IRP-RSP, no imputa.
    expect(deducible.slice(14, 18)).toEqual(['S', 'S', 'N', 'N']);
    expect(noDeducible.slice(14, 18)).toEqual(['N', 'S', 'N', 'N']);
  });

  it('nunca deja una fila sin imputación: si la empresa sólo imputa IVA, el no deducible sigue en IVA', async () => {
    const { service } = crear([gasto({ id: 'g2', deducible: false })]);
    const r = await service.getLibroIvaComprasMarangatu('emp-1', 9, 2026, undefined, 'C0001', 'preimpresos', 'u1');
    expect(columnas(r.csv).slice(14, 18)).toEqual(['S', 'N', 'N', 'N']);
  });

  const filas = async (gastos: any[], empresa: Record<string, unknown> = {}, despachos: any[] = []) => {
    const { service } = crear(gastos, empresa, despachos);
    const r = await service.getLibroIvaComprasMarangatu('emp-1', 9, 2026, undefined, 'C0001', 'preimpresos', 'u1');
    return { r, filas: r.csv ? r.csv.split('\r\n').map(columnas) : [] };
  };

  it('autofactura (101): sólo el total, sin condición', async () => {
    const { filas: [f] } = await filas([gasto({ tipo_comprobante: 'AUTOFACTURA' })]);
    expect(f[4]).toBe('101');
    expect(f.slice(8, 13)).toEqual(['0', '0', '0', '110000', '']);
  });

  it('despacho cargado como gasto (107): timbrado 0 y sin número', async () => {
    const { filas: [f] } = await filas([gasto({ tipo_comprobante: 'DESPACHO_IMPORTACION', timbrado: null, numero_factura: null })]);
    expect(f[4]).toBe('107');
    expect(f.slice(6, 8)).toEqual(['0', '']);
  });

  it('despachos del módulo Importaciones (107): base derivada del IVA importación', async () => {
    const { r, filas: [f] } = await filas([], {}, [
      { fecha_despacho: new Date('2026-09-15T00:00:00Z'), iva_importacion_gs: 1000, despachante: { personas: persona } },
    ]);
    expect(r.despachos).toBe(1);
    expect(f[0]).toBe('2');
    expect(f[4]).toBe('107');
    expect(f.slice(8, 12)).toEqual(['11000', '0', '0', '11000']);
  });

  it('despachos con IVA al 5 %: la base se separa por tasa en el archivo (F11)', async () => {
    const { filas: [f] } = await filas([], {}, [
      { fecha_despacho: new Date('2026-09-15T00:00:00Z'), iva_importacion_gs: 1000, iva_importacion_5_gs: 300, despachante: { personas: persona } },
    ]);
    // 700 de IVA al 10 % → 7700 con IVA; 300 al 5 % → 6300 con IVA.
    expect(f.slice(8, 12)).toEqual(['7700', '6300', '0', '14000']);
  });

  it('despachos con IVA al 5 % suman gravada_5 en el Libro IVA (detalle, resumen y crédito fiscal)', async () => {
    const { service } = crear([], {}, [
      {
        fecha_despacho: new Date('2026-09-15T00:00:00Z'), numero_despacho: '26-1-IM', iva_importacion_gs: 1000, iva_importacion_5_gs: 300,
        despachante: { personas: persona }, embarque: { numero: 'IMP-1', proveedores: null },
      },
    ]);
    const r: any = await service.getLibroIvaCompras('emp-1', 9, 2026, undefined, 'preimpresos', 'u1');
    const fila = r.detalle.find((d: any) => d.tipo === 'DESPACHO_IMPORTACION');
    expect(fila).toMatchObject({ gravada_10: 7000, iva_10: 700, gravada_5: 6000, iva_5: 300, total: 14000 });
    expect(r.resumen.despachos_importacion).toMatchObject({ gravada_10: 7000, iva_10: 700, gravada_5: 6000, iva_5: 300, total: 14000 });
    expect(r.resumen.credito_fiscal).toMatchObject({ iva_10: 700, iva_5: 300, total: 1000 });
  });

  it('comprobante del exterior (202): registro de egresos con identificación tributaria y sin IVA', async () => {
    const exterior = gasto({
      tipo_comprobante: 'COMPROBANTE_EXTERIOR',
      timbrado: null,
      establecimiento: null,
      punto_expedicion: null,
      numero_factura: 'INV-9',
      total: 500000,
      proveedores: { personas: { razon_social: 'ACME INC', ruc: null, nro_documento: 'US-123' } },
    });
    const { r, filas: [f] } = await filas([exterior], { imputa_ire: true });
    expect(r.egresos).toBe(1);
    expect(f).toEqual(['4', '202', '10/09/2026', 'INV-9', '17', 'US-123', 'ACME INC', '500000', 'N', 'S', 'N', 'N', '', '', '', '', '', '']);
  });

  it('un egreso que sin IVA no imputa a nada no sale (la SET lo rechazaría)', async () => {
    const { r, filas: f } = await filas([gasto({ tipo_comprobante: 'COMPROBANTE_EXTERIOR' })]);
    expect(f).toHaveLength(0);
    expect(r.egresos_sin_obligacion).toBe(1);
  });

  it('extracto de tarjeta (207): cuenta y entidad, puede imputar IVA', async () => {
    const { filas: [f] } = await filas([
      gasto({ tipo_comprobante: 'EXTRACTO_TARJETA', numero_factura: null, extracto_cuenta: '4111', extracto_entidad: 'BANCO X' }),
    ]);
    expect(f[1]).toBe('207');
    expect(f.slice(3, 6)).toEqual(['', '', '']);
    expect(f.slice(8, 14)).toEqual(['S', 'N', 'N', 'N', '4111', 'BANCO X']);
  });

  it('lo elegido en el comprobante manda sobre la empresa', async () => {
    const { filas: [f] } = await filas([gasto({ imputa_iva: false, imputa_ire: true })], { imputa_ire: true });
    expect(f.slice(14, 18)).toEqual(['N', 'S', 'N', 'N']);
  });

  it('un gasto en dólares sale en guaraníes con su cotización', async () => {
    const { filas: [f] } = await filas([
      gasto({ moneda: { codigo: 'USD' }, cotizacion: 7000, total_gravado_10: 110, total: 110 }),
    ]);
    expect(f[8]).toBe('770000');
    expect(f[13]).toBe('S');
  });
});

/**
 * Reportes A-T4: el archivo de compras pedía el permiso de exportar pero no el módulo COMPRAS ni el submódulo de facturas
 * de compra que pide el libro en pantalla: una empresa sin Compras contratado podía bajarlo.
 */
describe('GET compras/libro-iva-compras/marangatu: guardas', () => {
  const metodo = (ComprasController.prototype as any).getLibroIvaComprasMarangatu;

  it('es la ruta del archivo de Marangatu', () => {
    expect(Reflect.getMetadata(PATH_METADATA, metodo)).toBe('libro-iva-compras/marangatu');
    expect(Reflect.getMetadata(METHOD_METADATA, metodo)).toBe(RequestMethod.GET);
  });

  it('pide módulo COMPRAS, submódulo COMP_FACTURAS y el permiso de exportar a Marangatu', () => {
    expect(Reflect.getMetadata(REQUIRE_MODULE_KEY, metodo)).toBe('COMPRAS');
    expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, metodo)).toBe('COMP_FACTURAS');
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, metodo)).toEqual({ modulo: 'FISCAL', privilegio: 'FIS_MAR_MARANGATU_EXPORTAR' });
  });

  it('corre los guards que miran esa metadata', () => {
    const guards = Reflect.getMetadata(GUARDS_METADATA, metodo) ?? [];
    expect(guards[0]).toBe(AuthGuard('jwt'));
    expect(guards).toEqual(expect.arrayContaining([ModuleGuard, SubmoduloGuard, PermissionGuard]));
  });

  it('ejecución: empresa sin COMPRAS en la suscripción → 403', async () => {
    const prisma: any = {
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false, username: 'u' }) },
      empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'empresa' }) },
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(null) },
    };
    const contexto = {
      getHandler: () => metodo,
      getClass: () => ComprasController,
      switchToHttp: () => ({ getRequest: () => ({ user: { id: 'u1', empresa_id: 'e1' }, method: 'GET', url: '/x' }) }),
    } as unknown as ExecutionContext;
    await expect(new ModuleGuard(new Reflector(), prisma).canActivate(contexto)).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.suscripcion_modulos.findFirst.mock.calls[0][0].where.modulos).toMatchObject({ codigo: 'COMPRAS' });
  });
});
