import { ValidationPipe } from '@nestjs/common';
import { CreateTesCuentaDto, UpdateTesCuentaDto } from '../dto/tes-cuenta.dto';
import { TesCuentasService } from './tes-cuentas.service';
import { isContabilidadEnabledForEmpresa } from '../../common/utils/module-access.util';

jest.mock('../../common/utils/module-access.util', () => ({ isContabilidadEnabledForEmpresa: jest.fn() }));
const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;

const UUID_CONT = '11111111-1111-4111-8111-111111111111';
const UUID_BANCO = '22222222-2222-4222-8222-222222222222';

interface Opciones {
  monedas?: string[];
  movimientos?: number;
  cheques?: number;
  planes?: any[];
  bancos?: any[];
  cuenta?: any;
}

function armar(o: Opciones = {}) {
  const cuentaBase = {
    id: 'cta',
    empresa_id: 'emp',
    nombre: 'BCP',
    tipo: 'BANCO_CC',
    moneda: 'PYG',
    saldo_inicial: 0,
    saldo_actual: 0,
    cuenta_contable_id: null,
    activo: true,
    ...o.cuenta,
  };
  const monedas = o.monedas ?? ['PYG', 'USD'];
  // Cada condición del where cuenta: si la consulta deja de pedirla, el caso correspondiente falla.
  const planes = o.planes ?? [];
  const bancos = o.bancos ?? [];
  const prisma: any = {
    $transaction: jest.fn().mockImplementation((cb: any) => cb(prisma)),
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'cta' }]),
    empresa_monedas: {
      findFirst: jest
        .fn()
        .mockImplementation(({ where }) =>
          where.empresa_id === 'emp' && where.active === true && monedas.includes(where.moneda.codigo) ? { id: 'em' } : null,
        ),
    },
    cont_plan_cuentas: {
      findFirst: jest.fn().mockImplementation(({ where }) => {
        const deLaEmpresa = (c: any) => where.OR.some((x: any) => x.empresa_id === c.empresa_id);
        return (
          planes.find(
            (c) =>
              c.id === where.id &&
              deLaEmpresa(c) &&
              c.active === where.active &&
              c.acepta_movimientos === where.acepta_movimientos &&
              !(c.codigo as string).startsWith(where.NOT.codigo.startsWith),
          ) ?? null
        );
      }),
    },
    bancos: {
      findFirst: jest.fn().mockImplementation(({ where }) => {
        const deLaEmpresa = (b: any) => where.OR.some((x: any) => x.empresa_id === b.empresa_id);
        return bancos.find((b) => b.id === where.id && deLaEmpresa(b) && b.activo === where.activo) ?? null;
      }),
    },
    tes_movimientos: { count: jest.fn().mockResolvedValue(o.movimientos ?? 0) },
    tes_cheques: { count: jest.fn().mockResolvedValue(o.cheques ?? 0) },
    tes_cuentas: {
      create: jest.fn().mockImplementation(({ data }) => Promise.resolve({ id: 'nueva', ...data })),
      findFirst: jest.fn().mockResolvedValue(cuentaBase),
      update: jest.fn().mockImplementation(({ data }) => Promise.resolve({ ...cuentaBase, ...data })),
      findMany: jest.fn().mockResolvedValue([cuentaBase]),
    },
  };
  return { service: new TesCuentasService(prisma), prisma };
}

const dtoCrear = (extra: Partial<CreateTesCuentaDto> = {}): CreateTesCuentaDto => ({
  nombre: 'Itaú',
  tipo: 'BANCO_CC' as any,
  moneda: 'PYG',
  saldo_inicial: 100,
  ...extra,
});

beforeEach(() => {
  contabilidad.mockReset();
  contabilidad.mockResolvedValue(false);
});

describe('moneda (A10e)', () => {
  it('crear con EUR y la empresa con PYG y USD activas → MONEDA_NO_HABILITADA con campo moneda', async () => {
    const { service, prisma } = armar();
    await expect(service.create(dtoCrear({ moneda: 'EUR' }), 'emp')).rejects.toMatchObject({
      response: { codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda' },
    });
    expect(prisma.tes_cuentas.create).not.toHaveBeenCalled();
  });

  it('USD → crea con saldo_actual = saldo_inicial', async () => {
    const { service, prisma } = armar();
    await service.create(dtoCrear({ moneda: 'USD', saldo_inicial: 250 }), 'emp');
    const data = prisma.tes_cuentas.create.mock.calls[0][0].data;
    expect(data).toMatchObject({ moneda: 'USD', saldo_inicial: 250, saldo_actual: 250 });
    expect(prisma.empresa_monedas.findFirst.mock.calls[0][0].where).toMatchObject({ empresa_id: 'emp', active: true, moneda: { codigo: 'USD' } });
  });

  it('editar a una moneda no habilitada → MONEDA_NO_HABILITADA y no escribe', async () => {
    const { service, prisma } = armar();
    await expect(service.update('cta', { moneda: 'EUR' }, 'emp')).rejects.toMatchObject({ response: { codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda' } });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });
});

describe('moneda igual a la actual en update', () => {
  it('cuenta en USD que la empresa desactivó: renombrarla reenviando la moneda actual → 200', async () => {
    const { service, prisma } = armar({ monedas: ['PYG'], cuenta: { moneda: 'USD' }, movimientos: 2 });
    await service.update('cta', { nombre: 'Nuevo', moneda: 'USD' }, 'emp');
    expect(prisma.empresa_monedas.findFirst).not.toHaveBeenCalled();
    expect(prisma.tes_cuentas.update).toHaveBeenCalled();
  });

  it('en cambio, pasar a otra moneda que tampoco está activa sigue dando MONEDA_NO_HABILITADA', async () => {
    const { service, prisma } = armar({ monedas: ['PYG'], cuenta: { moneda: 'USD' } });
    await expect(service.update('cta', { moneda: 'EUR' }, 'emp')).rejects.toMatchObject({ response: { codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda' } });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });

  it('el mensaje de MONEDA_NO_HABILITADA no habla de «crear» (vale también al editar)', async () => {
    const { service } = armar();
    await expect(service.update('cta', { moneda: 'EUR' }, 'emp')).rejects.toMatchObject({
      response: { message: expect.not.stringMatching(/crear/i) },
    });
  });
});

describe('historial sin carrera (M4)', () => {
  it('bloquea la fila de la cuenta (FOR UPDATE) antes de contar movimientos y cheques', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { nombre: 'x' }, 'emp');
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
    expect(prisma.$queryRaw.mock.calls[0][0].join('?')).toMatch(/FOR UPDATE/i);
    expect(prisma.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(prisma.tes_movimientos.count.mock.invocationCallOrder[0]);
    expect(prisma.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(prisma.tes_cheques.count.mock.invocationCallOrder[0]);
  });
});

describe('cuenta con historial (A10b)', () => {
  it('PATCH moneda distinta con 1 movimiento → CUENTA_CON_MOVIMIENTOS y no escribe', async () => {
    const { service, prisma } = armar({ movimientos: 1 });
    await expect(service.update('cta', { moneda: 'USD' }, 'emp')).rejects.toMatchObject({
      response: { codigo: 'CUENTA_CON_MOVIMIENTOS', campo: 'moneda' },
    });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });

  it('con 0 movimientos y 1 cheque → igual', async () => {
    const { service, prisma } = armar({ movimientos: 0, cheques: 1 });
    await expect(service.update('cta', { moneda: 'USD' }, 'emp')).rejects.toMatchObject({ response: { codigo: 'CUENTA_CON_MOVIMIENTOS' } });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });

  it('con historial y la misma moneda → 200', async () => {
    const { service, prisma } = armar({ movimientos: 3, cheques: 2 });
    await service.update('cta', { moneda: 'PYG', nombre: 'BCP 2' }, 'emp');
    expect(prisma.tes_cuentas.update).toHaveBeenCalled();
    const data = prisma.tes_cuentas.update.mock.calls[0][0].data;
    expect(data.saldo_actual).toBeUndefined();
  });

  it('sin historial, saldo_inicial 500 → update con saldo_actual 500', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { saldo_inicial: 500 }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data).toMatchObject({ saldo_inicial: 500, saldo_actual: 500 });
  });

  it('con historial, saldo_inicial distinto → CUENTA_CON_MOVIMIENTOS (campo saldo_inicial)', async () => {
    const { service } = armar({ movimientos: 1 });
    await expect(service.update('cta', { saldo_inicial: 500 }, 'emp')).rejects.toMatchObject({ response: { campo: 'saldo_inicial' } });
  });
});

describe('cuenta contable (Contabilidad)', () => {
  const planEmpresa = { id: UUID_CONT, empresa_id: 'emp', codigo: '1.1.1.01', active: true, acepta_movimientos: true };

  it('sin CONTABILIDAD, crear sin cuenta_contable_id → crea', async () => {
    const { service, prisma } = armar();
    await service.create(dtoCrear(), 'emp');
    expect(prisma.tes_cuentas.create).toHaveBeenCalled();
    expect(prisma.cont_plan_cuentas.findFirst).not.toHaveBeenCalled();
  });

  it('sin CONTABILIDAD, con cuenta_contable_id → CONTABILIDAD_NO_CONTRATADA con campo cuenta_contable_id', async () => {
    const { service, prisma } = armar({ planes: [planEmpresa] });
    await expect(service.create(dtoCrear({ cuenta_contable_id: UUID_CONT }), 'emp')).rejects.toMatchObject({
      response: { codigo: 'CONTABILIDAD_NO_CONTRATADA', campo: 'cuenta_contable_id' },
    });
    expect(prisma.tes_cuentas.create).not.toHaveBeenCalled();
  });

  it('sin módulo, PATCH de nombre en una cuenta con cuenta_contable_id → 200 y el update no lleva cuenta_contable_id', async () => {
    const { service, prisma } = armar({ cuenta: { cuenta_contable_id: UUID_CONT } });
    await service.update('cta', { nombre: 'Nuevo' }, 'emp');
    const data = prisma.tes_cuentas.update.mock.calls[0][0].data;
    expect(data).toEqual({ nombre: 'Nuevo' });
    expect('cuenta_contable_id' in data).toBe(false);
  });

  it('sin módulo, borrar la cuenta contable (null) pasa', async () => {
    const { service, prisma } = armar({ cuenta: { cuenta_contable_id: UUID_CONT } });
    await service.update('cta', { cuenta_contable_id: null }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data).toEqual({ cuenta_contable_id: null });
  });

  describe('con CONTABILIDAD', () => {
    beforeEach(() => contabilidad.mockResolvedValue(true));
    const casosInvalidos: Array<[string, any]> = [
      ['de otra empresa', { ...planEmpresa, empresa_id: 'otra' }],
      ['inactiva', { ...planEmpresa, active: false }],
      ['con acepta_movimientos = false', { ...planEmpresa, acepta_movimientos: false }],
      ['con código OLD-…', { ...planEmpresa, codigo: 'OLD-1.1.1' }],
    ];
    it.each(casosInvalidos)('cuenta %s → CUENTA_CONTABLE_INVALIDA', async (_n, plan) => {
      const { service, prisma } = armar({ planes: [plan] });
      await expect(service.create(dtoCrear({ cuenta_contable_id: UUID_CONT }), 'emp')).rejects.toMatchObject({
        response: { codigo: 'CUENTA_CONTABLE_INVALIDA', campo: 'cuenta_contable_id' },
      });
      expect(prisma.tes_cuentas.create).not.toHaveBeenCalled();
    });

    it('cuenta del sistema (empresa_id null) activa y sin OLD- → guarda', async () => {
      const { service, prisma } = armar({ planes: [{ ...planEmpresa, empresa_id: null }] });
      await service.create(dtoCrear({ cuenta_contable_id: UUID_CONT }), 'emp');
      expect(prisma.tes_cuentas.create.mock.calls[0][0].data.cuenta_contable_id).toBe(UUID_CONT);
    });

    it('cuenta del plan de la empresa → guarda (y en update también)', async () => {
      const { service, prisma } = armar({ planes: [planEmpresa] });
      await service.update('cta', { cuenta_contable_id: UUID_CONT }, 'emp');
      expect(prisma.tes_cuentas.update.mock.calls[0][0].data.cuenta_contable_id).toBe(UUID_CONT);
    });

    it('cuenta_contable_id null → la borra', async () => {
      const { service, prisma } = armar({ cuenta: { cuenta_contable_id: UUID_CONT } });
      await service.update('cta', { cuenta_contable_id: null }, 'emp');
      expect(prisma.tes_cuentas.update.mock.calls[0][0].data.cuenta_contable_id).toBeNull();
      expect(prisma.cont_plan_cuentas.findFirst).not.toHaveBeenCalled();
    });
  });
});

describe('banco', () => {
  it.each([
    ['de otra empresa', { id: UUID_BANCO, empresa_id: 'otra', activo: true }],
    ['inactivo', { id: UUID_BANCO, empresa_id: null, activo: false }],
  ])('banco_id %s → BANCO_INVALIDO', async (_n, banco) => {
    const { service, prisma } = armar({ bancos: [banco] });
    await expect(service.create(dtoCrear({ banco_id: UUID_BANCO }), 'emp')).rejects.toMatchObject({ response: { codigo: 'BANCO_INVALIDO', campo: 'banco_id' } });
    expect(prisma.tes_cuentas.create).not.toHaveBeenCalled();
  });

  it('banco del sistema (empresa_id null) → guarda', async () => {
    const { service, prisma } = armar({ bancos: [{ id: UUID_BANCO, empresa_id: null, activo: true }] });
    await service.create(dtoCrear({ banco_id: UUID_BANCO }), 'emp');
    expect(prisma.tes_cuentas.create.mock.calls[0][0].data.banco_id).toBe(UUID_BANCO);
  });

  it('banco_id null en update lo borra sin consultar', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { banco_id: null }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.banco_id).toBeNull();
    expect(prisma.bancos.findFirst).not.toHaveBeenCalled();
  });
});

describe('campos borrables (RA§5.27)', () => {
  it('saldo_minimo_alerta 0 → guarda 0', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { saldo_minimo_alerta: 0 }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_minimo_alerta).toBe(0);
  });
  it('saldo_minimo_alerta null → guarda null', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { saldo_minimo_alerta: null }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_minimo_alerta).toBeNull();
  });
  it('numero_cuenta, cbu_iban y titular null se guardan null', async () => {
    const { service, prisma } = armar();
    await service.update('cta', { numero_cuenta: null, cbu_iban: null, titular: null }, 'emp');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data).toEqual({ numero_cuenta: null, cbu_iban: null, titular: null });
  });
});

describe('DTO (F11)', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const patch = (body: unknown) => pipe.transform(body, { type: 'body', metatype: UpdateTesCuentaDto });
  const alta = (body: unknown) => pipe.transform(body, { type: 'body', metatype: CreateTesCuentaDto });

  it.each(['nombre', 'tipo', 'moneda', 'saldo_inicial'])('PATCH { %s: null } → 400', async (campo) => {
    await expect(patch({ [campo]: null })).rejects.toMatchObject({ status: 400 });
  });
  it('PATCH { saldo_minimo_alerta: null } pasa', async () => {
    await expect(patch({ saldo_minimo_alerta: null })).resolves.toMatchObject({ saldo_minimo_alerta: null });
  });
  it.each(['banco_id', 'cuenta_contable_id', 'numero_cuenta', 'cbu_iban', 'titular'])('PATCH { %s: null } pasa', async (campo) => {
    await expect(patch({ [campo]: null })).resolves.toBeDefined();
  });
  it('moneda de 2 o 4 letras → 400 (Length 3,3)', async () => {
    await expect(alta({ nombre: 'x', tipo: 'BANCO_CC', moneda: 'PY', saldo_inicial: 0 })).rejects.toMatchObject({ status: 400 });
    await expect(patch({ moneda: 'PYGS' })).rejects.toMatchObject({ status: 400 });
  });
});

describe('lectura', () => {
  it('findOneConHistorial devuelve tiene_historial: true con movimientos', async () => {
    const { service } = armar({ movimientos: 2 });
    await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ id: 'cta', tiene_historial: true });
  });
  it('findOneConHistorial: true con solo cheques', async () => {
    const { service } = armar({ cheques: 1 });
    await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ tiene_historial: true });
  });
  it('findOneConHistorial: false sin ninguno', async () => {
    const { service } = armar();
    await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ tiene_historial: false });
  });
  describe('findOneConHistorial y la cuenta contable ya guardada (M6 de S1)', () => {
    const conPlan = (extra: { cuenta_contable_id?: string | null; plan?: any } = {}) => {
      const { service, prisma } = armar({ cuenta: { cuenta_contable_id: extra.cuenta_contable_id === undefined ? UUID_CONT : extra.cuenta_contable_id } });
      prisma.cont_plan_cuentas.findFirst = jest.fn().mockResolvedValue(extra.plan === undefined ? { codigo: '1.1.2.01', descripcion: 'Banco Itaú' } : extra.plan);
      return { service, prisma };
    };
    it('con CONTABILIDAD trae el código y la descripción de la cuenta guardada, de la empresa o del sistema', async () => {
      contabilidad.mockResolvedValue(true);
      const { service, prisma } = conPlan();
      await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ cuenta_contable: { codigo: '1.1.2.01', descripcion: 'Banco Itaú' } });
      expect(prisma.cont_plan_cuentas.findFirst).toHaveBeenCalledWith(
        expect.objectContaining({ where: { id: UUID_CONT, OR: [{ empresa_id: 'emp' }, { empresa_id: null }] }, select: { codigo: true, descripcion: true } }),
      );
    });
    it('sin CONTABILIDAD no lee el plan: cuenta_contable es null', async () => {
      contabilidad.mockResolvedValue(false);
      const { service, prisma } = conPlan();
      await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ cuenta_contable: null });
      expect(prisma.cont_plan_cuentas.findFirst).not.toHaveBeenCalled();
    });
    it('sin cuenta contable guardada, null y sin leer el plan', async () => {
      contabilidad.mockResolvedValue(true);
      const { service, prisma } = conPlan({ cuenta_contable_id: null });
      await expect(service.findOneConHistorial('cta', 'emp')).resolves.toMatchObject({ cuenta_contable: null });
      expect(prisma.cont_plan_cuentas.findFirst).not.toHaveBeenCalled();
    });
    it('findOne y findAll no la traen', async () => {
      contabilidad.mockResolvedValue(true);
      const { service } = conPlan();
      expect('cuenta_contable' in (await service.findOne('cta', 'emp'))).toBe(false);
    });
  });
  it('findOne no cuenta movimientos ni cheques', async () => {
    const { service, prisma } = armar();
    const cuenta = await service.findOne('cta', 'emp');
    expect(prisma.tes_movimientos.count).not.toHaveBeenCalled();
    expect(prisma.tes_cheques.count).not.toHaveBeenCalled();
    expect('tiene_historial' in cuenta).toBe(false);
  });
  it('toggleActivo no cuenta movimientos ni cheques', async () => {
    const { service, prisma } = armar();
    await service.toggleActivo('cta', 'emp');
    expect(prisma.tes_movimientos.count).not.toHaveBeenCalled();
    expect(prisma.tes_cheques.count).not.toHaveBeenCalled();
  });
  it('findAll no cambia de forma (sin tiene_historial)', async () => {
    const { service } = armar();
    const filas = await service.findAll('emp');
    expect(filas).toHaveLength(1);
    expect('tiene_historial' in filas[0]).toBe(false);
  });
});
