import { ConflictException, HttpException, NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { ListaPreciosController } from './lista-precios.controller';
import { ListaPreciosService } from './lista-precios.service';

/**
 * Gestión de listas: empresa del token en todo (H9), errores reales en vez de un
 * 500 genérico (L4), borrador al crear (L5), desactivar con conteo de clientes
 * (L6), duplicar con código libre, tope y asignaciones (H13).
 */
describe('ListaPreciosService · gestión de listas', () => {
  const crear = (prisma: any) => {
    const service = Object.create(ListaPreciosService.prototype) as ListaPreciosService;
    (service as any).prisma = prisma;
    (service as any).auditService = { log: jest.fn() };
    (service as any).cache = { set: jest.fn().mockResolvedValue(undefined) };
    (service as any).logger = { log: jest.fn(), error: jest.fn() };
    return service;
  };

  it('rechaza operar sobre una lista de otra empresa', async () => {
    const prisma: any = {
      lista_precios: { findFirst: jest.fn().mockResolvedValue(null), update: jest.fn() },
    };
    const service = crear(prisma);
    await expect(service.cambiarEstadoLista('l1', false, 'u1', 'empresa-ajena')).rejects.toBeInstanceOf(NotFoundException);
    expect(prisma.lista_precios.findFirst).toHaveBeenCalledWith({ where: { id: 'l1', empresa_id: 'empresa-ajena' } });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('crear como borrador deja la lista inactiva', async () => {
    const prisma: any = {
      lista_precios: {
        findFirst: jest.fn().mockResolvedValue(null),
        create: jest.fn().mockImplementation(({ data }) => ({ id: 'n1', ...data })),
      },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { codigo: 'PYG' } }) },
    };
    const lista = await crear(prisma).crearListaPrecios({ codigo: 'MAY', nombre: 'Mayorista', activa: false } as any, 'e1', 'u1');
    expect(lista.activa).toBe(false);
  });

  it('crear con un código repetido es 409 con el código en el mensaje', async () => {
    const prisma: any = {
      lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'x', codigo: 'MAY', nombre: 'Mayorista' }), create: jest.fn() },
    };
    await expect(crear(prisma).crearListaPrecios({ codigo: 'MAY', nombre: 'Otra' } as any, 'e1')).rejects.toThrow(
      /Ya existe una lista con el código MAY/,
    );
    expect(prisma.lista_precios.create).not.toHaveBeenCalled();
  });

  it('desactivar cuenta los clientes que la tienen (ficha + asignaciones, sin repetir)', async () => {
    const prisma: any = {
      lista_precios: {
        findFirst: jest.fn().mockResolvedValue({ id: 'l1' }),
        update: jest.fn().mockResolvedValue({ id: 'l1', nombre: 'Mayorista', activa: false }),
      },
      clientes: { findMany: jest.fn().mockResolvedValue([{ id: 'c1' }, { id: 'c2' }]) },
      lista_precios_asignaciones: { findMany: jest.fn().mockResolvedValue([{ entidad_id: 'c2' }, { entidad_id: 'c3' }]) },
    };
    const r = await crear(prisma).cambiarEstadoLista('l1', false, 'u1', 'e1');
    expect(r.clientesAsignados).toBe(3);
  });

  it('sugiere un código de copia libre', async () => {
    const prisma: any = {
      lista_precios: { findMany: jest.fn().mockResolvedValue([{ codigo: 'MAY_COPIA' }, { codigo: 'MAY_COPIA2' }]) },
    };
    await expect(crear(prisma).sugerirCodigoCopia('e1', 'may')).resolves.toBe('MAY_COPIA3');
  });

  it('duplicar copia el tope manual y, si se pide, las asignaciones', async () => {
    const origen = {
      id: 'l1',
      empresa_id: 'e1',
      nombre: 'Mayorista',
      lista_precios_productos: [{ producto_id: 'p1', precio_base: 100, descuento_maximo_pct: 7 }],
      lista_precios_asignaciones: [{ tipo_entidad: 'cliente', entidad_id: 'c1' }],
    };
    const tx: any = {
      lista_precios: { create: jest.fn().mockResolvedValue({ id: 'l2', empresa_id: 'e1', nombre: 'Copia', codigo: 'MAY2' }) },
      lista_precios_productos: { createMany: jest.fn() },
      lista_precios_asignaciones: { createMany: jest.fn() },
    };
    const prisma: any = {
      lista_precios: {
        findFirst: jest.fn().mockResolvedValueOnce({ id: 'l1' }).mockResolvedValueOnce(null),
        findUnique: jest.fn().mockResolvedValue(origen),
      },
      $transaction: (fn: any) => fn(tx),
    };
    await crear(prisma).duplicarListaPrecios('l1', { codigo: 'MAY2', nombre: 'Copia', copiarAsignaciones: true }, 'u1', 'e1');
    expect(tx.lista_precios_productos.createMany.mock.calls[0][0].data[0].descuento_maximo_pct).toBe(7);
    expect(tx.lista_precios_asignaciones.createMany).toHaveBeenCalled();
  });

  it('la copia de un borrador sale como borrador (E2E 2026-10-25)', async () => {
    const tx: any = {
      lista_precios: { create: jest.fn().mockResolvedValue({ id: 'l2', empresa_id: 'e1', nombre: 'Copia', codigo: 'B2' }) },
      lista_precios_productos: { createMany: jest.fn() },
      lista_precios_asignaciones: { createMany: jest.fn() },
    };
    const prisma: any = {
      lista_precios: {
        findFirst: jest.fn().mockResolvedValueOnce({ id: 'l1' }).mockResolvedValueOnce(null),
        findUnique: jest.fn().mockResolvedValue({
          id: 'l1',
          empresa_id: 'e1',
          activa: false,
          lista_precios_productos: [],
          lista_precios_asignaciones: [],
        }),
      },
      $transaction: (fn: any) => fn(tx),
    };
    await crear(prisma).duplicarListaPrecios('l1', { codigo: 'B2', nombre: 'Copia' }, 'u1', 'e1');
    expect(tx.lista_precios.create.mock.calls[0][0].data.activa).toBe(false);
  });

  it('el código se compara sin distinguir mayúsculas', async () => {
    const prisma: any = {
      lista_precios: {
        findFirst: jest
          .fn()
          .mockResolvedValueOnce({ id: 'l1' })
          .mockResolvedValueOnce({ id: 'otra', codigo: 'MAY', nombre: 'Vieja' }),
        findUnique: jest.fn().mockResolvedValue({ id: 'l1', lista_precios_productos: [], lista_precios_asignaciones: [] }),
      },
    };
    await expect(crear(prisma).duplicarListaPrecios('l1', { codigo: 'may', nombre: 'Copia' }, 'u1', 'e1')).rejects.toThrow(
      /código MAY/,
    );
    expect(prisma.lista_precios.findFirst.mock.calls[1][0].where.codigo).toEqual({ equals: 'may', mode: 'insensitive' });
  });

  it('duplicar con un código ya usado es 409', async () => {
    const prisma: any = {
      lista_precios: {
        findFirst: jest
          .fn()
          .mockResolvedValueOnce({ id: 'l1' })
          .mockResolvedValueOnce({ id: 'otra', codigo: 'MAY_COPY', nombre: 'Vieja' }),
        findUnique: jest.fn().mockResolvedValue({ id: 'l1', lista_precios_productos: [], lista_precios_asignaciones: [] }),
      },
    };
    await expect(
      crear(prisma).duplicarListaPrecios('l1', { codigo: 'MAY_COPY', nombre: 'Copia' }, 'u1', 'e1'),
    ).rejects.toBeInstanceOf(ConflictException);
  });

  it('editar la lista acepta quitar la fecha de fin (null) e ignora campos ajenos', async () => {
    const prisma: any = {
      lista_precios: {
        findFirst: jest.fn().mockResolvedValue({ id: 'l1' }),
        update: jest.fn().mockResolvedValue({ id: 'l1', nombre: 'X' }),
      },
    };
    await crear(prisma).actualizarListaPrecios('l1', { fechaFin: null, empresa_id: 'otra', recargoPorcentaje: 5 }, 'u1', 'e1');
    const data = prisma.lista_precios.update.mock.calls[0][0].data;
    expect(data.fecha_fin).toBeNull();
    expect(data.recargo_porcentaje).toBe(5);
    expect(data.empresa_id).toBeUndefined();
  });

  it('el listado filtra por nombre o código', async () => {
    const prisma: any = { lista_precios: { count: jest.fn().mockResolvedValue(0), findMany: jest.fn().mockResolvedValue([]) } };
    await crear(prisma).obtenerListasEmpresa('e1', { nombre: 'mayo' });
    expect(prisma.lista_precios.findMany.mock.calls[0][0].where.OR).toEqual([
      { nombre: { contains: 'mayo', mode: 'insensitive' } },
      { codigo: { contains: 'mayo', mode: 'insensitive' } },
    ]);
  });

  it('una asignación por canal se rechaza (Canal se quitó)', async () => {
    const prisma: any = { lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'l1' }) } };
    await expect(crear(prisma).asignarListaPrecios('l1', [{ tipoEntidad: 'canal', canalVenta: 'web' }], 'e1')).rejects.toThrow(
      /cliente o a una zona/,
    );
  });
});

describe('ListaPreciosController · errores', () => {
  const ctrl = (service: any) => {
    const c = Object.create(ListaPreciosController.prototype) as ListaPreciosController;
    (c as any).listaPreciosService = service;
    (c as any).logger = { error: jest.fn() };
    return c;
  };
  const user: any = { id: 'u1', empresa_id: 'e1' };

  it('un 409 del servicio llega como 409, no como 500', async () => {
    const c = ctrl({ crearListaPrecios: jest.fn().mockRejectedValue(new ConflictException('Ya existe una lista con el código X')) });
    await expect(c.crearListaPrecios({} as any, user)).rejects.toBeInstanceOf(ConflictException);
  });

  it('un código único violado por carrera (P2002) es 409', async () => {
    const err = new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' });
    const c = ctrl({ crearListaPrecios: jest.fn().mockRejectedValue(err) });
    await expect(c.crearListaPrecios({} as any, user)).rejects.toMatchObject({ status: 409 });
  });

  it('DELETE desactiva de verdad y dice cuántos clientes la tienen', async () => {
    const cambiarEstadoLista = jest.fn().mockResolvedValue({ id: 'l1', activa: false, clientesAsignados: 4 });
    const r = await ctrl({ cambiarEstadoLista }).desactivarListaPrecios('l1', user);
    expect(cambiarEstadoLista).toHaveBeenCalledWith('l1', false, 'u1', 'e1');
    expect(r?.message).toMatch(/4 clientes la tienen asignada/);
  });

  it('el listado usa la empresa del token aunque la URL traiga otra', async () => {
    const obtenerListasEmpresa = jest.fn().mockResolvedValue({ data: [] });
    await ctrl({ obtenerListasEmpresa }).obtenerListasEmpresa(user);
    expect(obtenerListasEmpresa.mock.calls[0][0]).toBe('e1');
  });

  it('lo inesperado es 500 con mensaje accionable', async () => {
    const c = ctrl({ obtenerProductosLista: jest.fn().mockRejectedValue(new Error('boom')) });
    await expect(c.obtenerProductosLista('l1', user)).rejects.toBeInstanceOf(HttpException);
  });
});
