import {
  BadRequestException,
  ConflictException,
  NotFoundException,
} from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { PrismaService } from '../prisma/prisma.service.js';
import { CompaniesService } from './companies.service.js';
import type { CompanyResponse } from './types/company.types.js';

describe('CompaniesService', () => {
  let service: CompaniesService;
  let companyApi: {
    select: ReturnType<typeof vi.fn>;
    where: ReturnType<typeof vi.fn>;
    aggregate: ReturnType<typeof vi.fn>;
  };
  let leadApi: {
    where: ReturnType<typeof vi.fn>;
  };

  const company: CompanyResponse = {
    id: 'company-1',
    name: 'Acme Corp',
    domain: 'acme.example',
    website: 'https://acme.example',
    industry: 'Software',
    phone: '555-0100',
    email: 'hello@acme.example',
    address: '1 Main St',
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  beforeEach(async () => {
    vi.clearAllMocks();

    companyApi = {
      select: vi.fn(),
      where: vi.fn(),
      aggregate: vi.fn(),
    };
    leadApi = {
      where: vi.fn(),
    };

    const prisma = {
      db: {
        orm: {
          public: {
            Company: companyApi,
            Lead: leadApi,
          },
        },
      },
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        CompaniesService,
        { provide: PrismaService, useValue: prisma },
      ],
    }).compile();

    service = module.get(CompaniesService);
  });

  it('rejects blank company names', async () => {
    await expect(
      service.create({
        name: '   ',
      }),
    ).rejects.toBeInstanceOf(BadRequestException);
  });

  it('creates a company', async () => {
    const create = vi.fn().mockResolvedValue(company);
    companyApi.select.mockReturnValue({ create });

    const result = await service.create({
      name: ' Acme Corp ',
      website: ' https://acme.example ',
      industry: 'Software',
      phone: '555-0100',
      email: ' Hello@Acme.Example ',
      address: '1 Main St',
    });

    expect(create).toHaveBeenCalledWith({
      name: 'Acme Corp',
      domain: null,
      website: 'https://acme.example',
      industry: 'Software',
      phone: '555-0100',
      email: 'hello@acme.example',
      address: '1 Main St',
    });
    expect(result).toEqual(company);
  });

  it('finds or creates a company by domain and handles races', async () => {
    const create = vi.fn().mockRejectedValue({ code: '23505' });
    const first = vi
      .fn()
      .mockResolvedValueOnce(null)
      .mockResolvedValueOnce(company);

    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({ first }),
      create,
    });

    const result = await service.findOrCreateByDomain('Acme.COM.');
    expect(result).toEqual(company);
    expect(create).toHaveBeenCalledWith(
      expect.objectContaining({
        name: 'Acme',
        domain: 'acme.com',
        website: 'https://acme.com',
      }),
    );
  });

  it('resolves company id from business email domains only', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(company),
      }),
    });

    await expect(
      service.resolveCompanyIdFromEmail('ada@gmail.com'),
    ).resolves.toBeNull();
    await expect(
      service.resolveCompanyIdFromEmail('ops@acme.example'),
    ).resolves.toBe('company-1');
  });

  it('lists companies with pagination', async () => {
    companyApi.aggregate.mockResolvedValue({ total: 25 });
    companyApi.select.mockReturnValue({
      orderBy: vi.fn().mockReturnValue({
        limit: vi.fn().mockReturnValue({
          offset: vi.fn().mockReturnValue({
            all: vi.fn().mockResolvedValue([company]),
          }),
        }),
      }),
    });

    const result = await service.findAll({ page: 2, limit: 10 });

    expect(result).toEqual({
      data: [company],
      meta: { total: 25, page: 2, limit: 10, totalPages: 3 },
    });
  });

  it('searches companies', async () => {
    const aggregate = vi.fn().mockResolvedValue({ total: 1 });
    companyApi.where.mockReturnValue({ aggregate });
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        orderBy: vi.fn().mockReturnValue({
          limit: vi.fn().mockReturnValue({
            offset: vi.fn().mockReturnValue({
              all: vi.fn().mockResolvedValue([company]),
            }),
          }),
        }),
      }),
    });

    const result = await service.findAll({
      search: 'Acme',
      page: 1,
      limit: 10,
    });

    expect(companyApi.where).toHaveBeenCalled();
    expect(result.data).toEqual([company]);
    expect(result.meta.totalPages).toBe(1);
  });

  it('gets a company by id', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(company),
      }),
    });

    await expect(service.findOne('company-1')).resolves.toEqual(company);
  });

  it('throws not found for missing company', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(null),
      }),
    });

    await expect(service.findOne('missing')).rejects.toBeInstanceOf(
      NotFoundException,
    );
  });

  it('updates a company', async () => {
    const update = vi.fn().mockResolvedValue([
      { ...company, name: 'Acme Updated' },
    ]);

    companyApi.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({ id: company.id }),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({ update }),
      });

    const result = await service.update(company.id, {
      name: ' Acme Updated ',
    });

    expect(update).toHaveBeenCalledWith({ name: 'Acme Updated' });
    expect(result.name).toBe('Acme Updated');
  });

  it('deletes a company without leads', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue({ id: company.id }),
      }),
    });
    leadApi.where.mockReturnValue({
      aggregate: vi.fn().mockResolvedValue({ total: 0 }),
    });
    const deleteFn = vi.fn().mockResolvedValue(undefined);
    companyApi.where.mockReturnValue({ delete: deleteFn });

    await service.remove(company.id);
    expect(deleteFn).toHaveBeenCalled();
  });

  it('rejects delete when company has leads', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue({ id: company.id }),
      }),
    });
    leadApi.where.mockReturnValue({
      aggregate: vi.fn().mockResolvedValue({ total: 2 }),
    });

    await expect(service.remove(company.id)).rejects.toBeInstanceOf(
      ConflictException,
    );
  });
});
