import { BadRequestException, NotFoundException } from '@nestjs/common';
import { GUARDS_METADATA, METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';
import { RequestMethod } from '@nestjs/common';
import { AlgunPrivilegioGuard, REQUIRE_ALGUN_PRIVILEGIO_KEY } from 'src/auth/guards/algun-privilegio.guard';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { REQUIRE_MODULE_KEY } from 'src/auth/decorators/require-module.decorator';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { GastosController } from './gastos.controller';
import { GastosService } from './gastos.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));
const alcanceMock = alcanceSucursalUsuario as jest.Mock;

/**
 * El gasto de una requisición sale del alta normal de Gastos (plan de Requisiciones, Task 9): `requisicionOrigen`
 * da las líneas con su pendiente y `create` ejecuta la línea. Prisma falso en memoria, con `GastosService` real.
 */

const MONEDAS: Record<string, string> = { 'mon-pyg': 'PYG', 'mon-usd': 'USD' };
const SUC = 'suc-1';

const linea = (extra: Record<string, unknown> = {}) => ({
  id: 'det-1',
  estado: 'pendiente',
  producto_id: null,
  tipo_gasto_id: 'tg-1',
  centro_costo_id: null,
  descripcion: 'Combustible',
  cantidad_solicitada: '4.0000',
  cantidad_ejecutada: '0.0000',
  monto_ejecutado: '0.00',
  precio_unitario: '110000.0000',
  porcentaje_iva: '10.00',
  productos: null,
  tipo_gasto: { id: 'tg-1', descripcion: 'Combustible' },
  ...extra,
});

function armar(
  opts: {
    requisicion?: Record<string, unknown>;
    lineas?: Array<Record<string, unknown>>;
    config?: Record<string, unknown>;
  } = {},
) {
  const creados = { gastos: [] as any[], cxp: [] as any[], det: [] as any[] };
  const orden: string[] = [];
  const req: any = {
    id: 'req-1',
    empresa_id: 'emp',
    numero_requisicion: 'RQ-000001',
    origen_tipo: 'gasto',
    estado: 'aprobada',
    sucursal_id: SUC,
    activo: true,
    descripcion: 'Combustible de octubre',
    total_ejecutado: '0.00',
    ...opts.requisicion,
  };
  const det: any[] = (opts.lineas ?? [linea()]).map((l) => ({ requisicion_id: 'req-1', ...l }));
  const leer = () => ({ ...req, requisicion_det: det.map((d) => ({ ...d })) });
  let gastoGuardado: any = null;
  const config = {
    habilitar_requisicion_compra: true,
    generar_cxp_automatico: true,
    modo_flujo_compra: 'directo',
    incluir_contado_en_orden_pago: false,
    ...opts.config,
  };
  const traza = (nombre: string, valor: any) =>
    jest.fn().mockImplementation(async () => (orden.push(nombre), valor));
  const prisma: any = {
    config_compras: { findUnique: jest.fn().mockResolvedValue(config) },
    requisicion_cab: {
      // La lectura de requisicionOrigen filtra por sucursal en el where; la del alta y la ejecución no.
      findFirst: jest.fn().mockImplementation(async ({ where }) => {
        orden.push('leer-req');
        if (where.id !== req.id || where.empresa_id !== req.empresa_id) return null;
        if (where.origen_tipo && where.origen_tipo !== req.origen_tipo) return null;
        if (where.sucursal_id !== undefined && where.sucursal_id !== req.sucursal_id) return null;
        return leer();
      }),
      update: jest.fn().mockImplementation(async ({ data }) => Object.assign(req, data)),
    },
    requisicion_det: {
      update: jest.fn().mockImplementation(async ({ where, data }) => Object.assign(det.find((d) => d.id === where.id), data)),
    },
    requisicion_presupuesto: { findFirst: jest.fn().mockResolvedValue(null) },
    $executeRaw: jest.fn().mockImplementation(async (_s: TemplateStringsArray, ...v: unknown[]) => (orden.push(`lock ${v[0]}`), 1)),
    $queryRaw: traza('lock-fila', []),
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov-1', personas: { ruc: null, dv: null } }) },
    moneda: {
      findUnique: jest
        .fn()
        .mockImplementation(({ where }) => (MONEDAS[where.id] ? { id: where.id, codigo: MONEDAS[where.id] } : null)),
      findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ id: 'em-1' }) },
    tes_cuentas: { findFirst: jest.fn().mockImplementation(({ where }) => (String(where.id).startsWith('cta-') ? { id: where.id } : null)) },
    gasto_cab: {
      create: jest.fn().mockImplementation(({ data }) => {
        orden.push('escribir-gasto');
        creados.gastos.push(data);
        gastoGuardado = { id: 'g1', empresa_id: 'emp', anulado: false, activo: true, fecha_emision: data.fecha_emision, ...data };
        return { id: 'g1', ...data };
      }),
      findFirst: jest.fn().mockImplementation(async ({ where }) =>
        where?.id === 'g1'
          ? gastoGuardado
          : { numero_factura: null, fecha_emision: new Date('2026-10-05'), descripcion: null, proveedores: null },
      ),
      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
    },
    compra_cab: { findFirst: jest.fn().mockResolvedValue(null) },
    gasto_det: {
      createMany: jest.fn().mockImplementation(({ data }) => (creados.det.push(...data), {})),
      findMany: jest.fn().mockImplementation(async () => creados.det),
    },
    cuentas_pagar: {
      create: jest.fn().mockImplementation(({ data }) => (orden.push('escribir-cxp'), creados.cxp.push(data), {})),
      findMany: jest.fn().mockResolvedValue([]),
      updateMany: jest.fn().mockResolvedValue({}),
    },
    rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    nota_credito_compra_cab: { findFirst: jest.fn().mockResolvedValue(null) },
    orden_pago_proveedor_det: { findMany: jest.fn().mockResolvedValue([]) },
    pagos_proveedor: { count: jest.fn().mockResolvedValue(0) },
    cont_periodos: { findFirst: jest.fn().mockResolvedValue(null) },
    cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
    tes_movimientos: { findFirst: jest.fn().mockResolvedValue(null) },
    medio_pago: { findUnique: jest.fn().mockResolvedValue({ codigo: 1 }) },
    empresa_medio_pago: { findFirst: jest.fn().mockResolvedValue(null), findMany: jest.fn().mockResolvedValue([]) },
  };
  prisma.$transaction = (fn: any) => fn(prisma);

  const tesoreria = {
    integrarGasto: jest.fn().mockResolvedValue({ registrado: 'MOVIMIENTO' }),
    revertirGasto: jest.fn().mockResolvedValue(undefined),
    tieneMovimientoConciliado: jest.fn().mockResolvedValue(false),
    chequeNoRevertible: jest.fn().mockResolvedValue(null),
    resolverCuentaPago: jest
      .fn()
      .mockImplementation(async (_t: unknown, _e: string, o: { cuentaTesoreriaId?: string | null }) => ({
        cuenta: { id: o.cuentaTesoreriaId || 'cta-1', nombre: 'Caja', moneda: 'PYG' },
      })),
  };
  const contabilidad = {
    integrarGasto: jest.fn().mockResolvedValue({ estado: 'CONFIRMADO' }),
    revertirDocumento: jest.fn().mockResolvedValue(undefined),
    cuentaPasivoParaCongelar: jest.fn().mockResolvedValue('pasivo-1'),
  };
  const monedas = { getCotizacionVigente: jest.fn().mockResolvedValue({ tasa: 7300 }) };
  const service = new GastosService(prisma, contabilidad as any, tesoreria as any, {} as any, monedas as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'g1', tesoreria_estado: 'CONFIRMADO' } as any);
  return { service, prisma, creados, orden, det, req: () => req };
}

const item = (extra: Record<string, unknown> = {}) => ({
  requisicion_det_id: 'det-1',
  tipo_gasto_id: 'tg-1',
  descripcion: 'Combustible',
  cantidad: 1,
  precio_unitario: 110000,
  porcentaje_iva: 10,
  ...extra,
});
const dto = (cab: Record<string, unknown> = {}, items: any[] = [item()]) =>
  ({
    cabecera: {
      proveedor_id: 'prov-1',
      requisicion_id: 'req-1',
      forma_pago: 'CREDITO',
      fecha_emision: '2026-10-05',
      ...cab,
    },
    items,
  }) as any;
const cuerpo = (e: any) => e.getResponse();
const errorDe = async (p: Promise<unknown>): Promise<any> => {
  try {
    await p;
  } catch (e) {
    return e;
  }
  throw new Error('Se esperaba un error y no hubo');
};

beforeEach(() => alcanceMock.mockReset().mockResolvedValue(null));

describe('GastosService.requisicionOrigen', () => {
  it('de una aprobada de gasto devuelve las líneas con pendiente y precio', async () => {
    const { service } = armar({
      lineas: [
        linea({ cantidad_ejecutada: '1.5000' }),
        linea({ id: 'det-2', cantidad_solicitada: '2.0000', cantidad_ejecutada: '2.0000', descripcion: 'Lleno' }),
      ],
    });
    const r = await service.requisicionOrigen('emp', 'u1', 'req-1');
    expect(r).toEqual({
      id: 'req-1',
      numero_requisicion: 'RQ-000001',
      sucursal_id: SUC,
      descripcion: 'Combustible de octubre',
      moneda: { codigo: 'PYG' },
      // La línea ya ejecutada del todo no se ofrece.
      lineas: [
        {
          id: 'det-1',
          producto: null,
          tipo_gasto: { id: 'tg-1', descripcion: 'Combustible' },
          centro_costo_id: null,
          descripcion: 'Combustible',
          pendiente: '2.5000',
          precio_unitario: '110000.0000',
        },
      ],
    });
  });

  it.each([
    ['de compra', { origen_tipo: 'compra' }],
    ['en borrador', { estado: 'borrador' }],
    ['cancelada', { estado: 'cancelada' }],
  ])('de una %s → REQUISICION_NO_DISPONIBLE', async (_n, requisicion) => {
    const { service } = armar({ requisicion });
    const e = await errorDe(service.requisicionOrigen('emp', 'u1', 'req-1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_NO_DISPONIBLE', estado_actual: expect.any(String) });
  });

  it('de otra sucursal (fuera del alcance) → 404', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['otra'], puntosEstablecimiento: [], depositoIds: [] });
    const { service } = armar();
    await expect(service.requisicionOrigen('emp', 'u1', 'req-1')).rejects.toBeInstanceOf(NotFoundException);
    expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'u1', 'emp');
  });

  it('de otra empresa → 404', async () => {
    const { service } = armar();
    await expect(service.requisicionOrigen('otra', 'u1', 'req-1')).rejects.toBeInstanceOf(NotFoundException);
  });

  it('sin fila de config: es un GET, no la crea y se toma como bandera apagada (default false)', async () => {
    const { service, prisma } = armar();
    prisma.config_compras.findUnique.mockResolvedValue(null);
    prisma.config_compras.create = jest.fn();
    const e = await errorDe(service.requisicionOrigen('emp', 'u1', 'req-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });

  it('con la bandera de requisiciones apagada → REQUISICIONES_DESHABILITADAS', async () => {
    const { service } = armar({ config: { habilitar_requisicion_compra: false } });
    const e = await errorDe(service.requisicionOrigen('emp', 'u1', 'req-1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
  });
});

describe('GastosService.create con requisición', () => {
  it('con requisicion_det_id ejecuta la línea (crédito): cantidad, monto y estado', async () => {
    const { service, creados, det, req } = armar();
    await service.create(dto({}, [item({ cantidad: 1 })]), 'emp', 'u1');
    expect(creados.gastos[0]).toMatchObject({ requisicion_id: 'req-1', forma_pago: 'CREDITO', estado: 'registrado' });
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 1, monto_ejecutado: 110000, estado: 'ejecutada_parcial' });
    expect(req()).toMatchObject({ estado: 'ejecutada_parcial', total_ejecutado: 110000 });
    expect(creados.cxp).toHaveLength(1);
  });

  it('de contado con medio y cuenta: queda pagado y ejecuta la línea', async () => {
    const { service, creados, det } = armar();
    await service.create(
      dto({ forma_pago: 'CONTADO', medio_pago_id: 'mp-1', cuenta_tesoreria_id: 'cta-2' }, [item({ cantidad: 4 })]),
      'emp',
      'u1',
    );
    expect(creados.gastos[0]).toMatchObject({ estado: 'pagada', forma_pago: 'CONTADO', requisicion_id: 'req-1' });
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 4, monto_ejecutado: 440000, estado: 'ejecutada_total' });
  });

  it('con incluir_contado_en_orden_pago el contado queda pendiente, sin medio de pago, y ejecuta igual (matriz 6)', async () => {
    const { service, creados, det } = armar({ config: { incluir_contado_en_orden_pago: true } });
    await service.create(dto({ forma_pago: 'CONTADO' }, [item({ cantidad: 1 })]), 'emp', 'u1');
    expect(creados.gastos[0]).toMatchObject({ estado: 'registrado', requisicion_id: 'req-1' });
    expect(creados.cxp).toHaveLength(1);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 1, monto_ejecutado: 110000 });
  });

  it('un ítem sin requisicion_det_id → LINEA_DE_OTRA_REQUISICION con la línea, y no escribe nada', async () => {
    const { service, creados, det } = armar();
    const e = await errorDe(service.create(dto({}, [item({ requisicion_det_id: undefined })]), 'emp', 'u1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'LINEA_DE_OTRA_REQUISICION', campo: 'items', linea: 1 });
    expect(creados.gastos).toHaveLength(0);
    expect(det[0].cantidad_ejecutada).toBe('0.0000');
  });

  it('un ítem con la línea de otra requisición → LINEA_DE_OTRA_REQUISICION', async () => {
    const { service, creados } = armar();
    const e = await errorDe(
      service.create(dto({}, [item(), item({ requisicion_det_id: 'det-ajena' })]), 'emp', 'u1'),
    );
    expect(cuerpo(e)).toMatchObject({ codigo: 'LINEA_DE_OTRA_REQUISICION', campo: 'items', linea: 2 });
    expect(creados.gastos).toHaveLength(0);
  });

  it('el alta con requisición NO mira la bandera: con la bandera apagada sigue ejecutando (matriz 12)', async () => {
    const { service, creados, det } = armar({ config: { habilitar_requisicion_compra: false } });
    await service.create(dto({}, [item({ cantidad: 1 })]), 'emp', 'u1');
    expect(creados.gastos).toHaveLength(1);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 1, monto_ejecutado: 110000 });
  });

  it('gasto en USD ejecuta en guaraníes; anularlo devuelve lo pendiente', async () => {
    const { service, det, req } = armar();
    // 15 USD × 1 unidad a 7300 = 109.500 Gs.
    await service.create(
      dto({ moneda_id: 'mon-usd', cotizacion: 7300 }, [item({ cantidad: 1, precio_unitario: 15, porcentaje_iva: 0 })]),
      'emp',
      'u1',
    );
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 1, monto_ejecutado: 109500, estado: 'ejecutada_parcial' });
    expect(req().total_ejecutado).toBe(109500);

    await service.anular('g1', 'emp', 'u1', 'Cargado dos veces');
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 0, monto_ejecutado: 0, estado: 'pendiente' });
    expect(req()).toMatchObject({ estado: 'aprobada', total_ejecutado: 0 });
  });

  it('con requisicion_obligatoria y sin requisición → el error de hoy (matriz 7)', async () => {
    const { service, creados } = armar({ config: { modo_flujo_compra: 'requisicion_obligatoria' } });
    const sinReq = dto({ requisicion_id: undefined }, [item({ requisicion_det_id: undefined })]);
    await expect(service.create(sinReq, 'emp', 'u1')).rejects.toThrow(
      'La configuración exige requisición obligatoria. Debés informar cabecera.requisicion_id',
    );
    expect(creados.gastos).toHaveLength(0);
  });

  it('orden de locks: req: antes de escribir el gasto y la CxP', async () => {
    const { service, orden } = armar();
    await service.create(dto({}, [item({ cantidad: 1 })]), 'emp', 'u1');
    const iReq = orden.indexOf('lock req:req-1');
    expect(iReq).toBeGreaterThan(-1);
    expect(iReq).toBeLessThan(orden.indexOf('escribir-gasto'));
    expect(iReq).toBeLessThan(orden.indexOf('escribir-cxp'));
    // Y antes de la primera lectura de la requisición para validarla.
    expect(iReq).toBeLessThan(orden.indexOf('leer-req'));
  });
});

describe('GastosController requisiciones-origen', () => {
  const proto = GastosController.prototype as any;

  it('GET requisiciones-origen/:id va antes de :id, con AlgunPrivilegioGuard y VER o CREAR', () => {
    expect(Reflect.getMetadata(METHOD_METADATA, proto.requisicionOrigen)).toBe(RequestMethod.GET);
    expect(Reflect.getMetadata(PATH_METADATA, proto.requisicionOrigen)).toBe('requisiciones-origen/:id');
    const metodos = Object.getOwnPropertyNames(proto);
    expect(metodos.indexOf('requisicionOrigen')).toBeLessThan(metodos.indexOf('findOne'));
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.requisicionOrigen)).toBeUndefined();
    expect(Reflect.getMetadata(REQUIRE_ALGUN_PRIVILEGIO_KEY, proto.requisicionOrigen)).toEqual([
      'TES_GAS_GASTO_VER',
      'TES_GAS_GASTO_CREAR',
    ]);
    // El plan tiene que incluir COMPRAS (ModuleGuard) y el perfil, alguno de los privilegios de Gastos.
    expect(Reflect.getMetadata(GUARDS_METADATA, proto.requisicionOrigen)).toEqual([ModuleGuard, AlgunPrivilegioGuard]);
    expect(Reflect.getMetadata(REQUIRE_MODULE_KEY, proto.requisicionOrigen)).toBe('COMPRAS');
  });

  it('el handler le pasa empresa_id y user.id al servicio', async () => {
    const requisicionOrigen = jest.fn().mockResolvedValue({ id: 'req-1' });
    const controller = new GastosController({ requisicionOrigen } as any, {} as any);
    const r = await controller.requisicionOrigen('req-1', { id: 'u1', empresa_id: 'emp' } as any);
    expect(requisicionOrigen).toHaveBeenCalledWith('emp', 'u1', 'req-1');
    expect(r).toEqual({ id: 'req-1' });
  });
});
