import {
  ForbiddenException,
  NotFoundException,
} from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { SafeUser } from '../auth/types/auth.types.js';
import { CompaniesService } from '../companies/companies.service.js';
import { PrismaService } from '../prisma/prisma.service.js';
import { LeadsService } from './leads.service.js';
import type { LeadResponse } from './types/lead.types.js';

describe('LeadsService', () => {
  let service: LeadsService;
  let leadApi: {
    select: ReturnType<typeof vi.fn>;
    where: ReturnType<typeof vi.fn>;
    aggregate: ReturnType<typeof vi.fn>;
  };
  let companyApi: { select: ReturnType<typeof vi.fn> };
  let userApi: { select: ReturnType<typeof vi.fn> };
  let activityApi: { create: ReturnType<typeof vi.fn> };
  let companiesService: {
    resolveCompanyIdFromEmail: ReturnType<typeof vi.fn>;
  };

  const admin: SafeUser = {
    id: 'admin-1',
    firstName: 'Admin',
    lastName: 'User',
    email: 'admin@example.com',
    role: 'ADMIN',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  const sales: SafeUser = {
    id: 'sales-1',
    firstName: 'Sales',
    lastName: 'User',
    email: 'sales@example.com',
    role: 'SALES_USER',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  const otherSales: SafeUser = {
    ...sales,
    id: 'sales-2',
    firstName: 'Other',
    lastName: 'Rep',
    email: 'sales2@example.com',
  };

  const lead: LeadResponse = {
    id: 'lead-1',
    firstName: 'Jane',
    lastName: 'Doe',
    email: 'jane@example.com',
    phone: null,
    jobTitle: null,
    status: 'NEW',
    source: 'WEBSITE',
    notes: null,
    createdById: sales.id,
    assignedToId: sales.id,
    companyId: null,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

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

    leadApi = {
      select: vi.fn(),
      where: vi.fn(),
      aggregate: vi.fn(),
    };
    companyApi = { select: vi.fn() };
    userApi = { select: vi.fn() };
    activityApi = { create: vi.fn().mockResolvedValue({}) };
    companiesService = {
      resolveCompanyIdFromEmail: vi.fn().mockResolvedValue(null),
    };

    const prisma = {
      db: {
        orm: {
          public: {
            Lead: leadApi,
            Company: companyApi,
            User: userApi,
            Activity: activityApi,
          },
        },
      },
    };

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

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

  it('creates a lead with createdById and assignedToId from JWT user', async () => {
    const create = vi.fn().mockResolvedValue(lead);
    leadApi.select.mockReturnValue({ create });

    const result = await service.create(
      {
        firstName: ' Jane ',
        email: ' Jane@Example.com ',
        source: 'WEBSITE',
      },
      sales,
    );

    expect(create).toHaveBeenCalledWith(
      expect.objectContaining({
        firstName: 'Jane',
        email: 'jane@example.com',
        createdById: sales.id,
        assignedToId: sales.id,
        status: 'NEW',
      }),
    );
    expect(activityApi.create).toHaveBeenCalled();
    expect(result.createdById).toBe(sales.id);
    expect(result).not.toHaveProperty('passwordHash');
  });

  it('auto-resolves company from business email when companyId omitted', async () => {
    companiesService.resolveCompanyIdFromEmail.mockResolvedValue('company-42');
    const create = vi.fn().mockResolvedValue({
      ...lead,
      companyId: 'company-42',
      email: 'jane@acme.com',
    });
    leadApi.select.mockReturnValue({ create });

    await service.create(
      {
        firstName: 'Jane',
        email: 'jane@acme.com',
      },
      sales,
    );

    expect(companiesService.resolveCompanyIdFromEmail).toHaveBeenCalledWith(
      'jane@acme.com',
    );
    expect(create).toHaveBeenCalledWith(
      expect.objectContaining({
        companyId: 'company-42',
      }),
    );
  });

  it('does not override an explicitly supplied companyId', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue({ id: 'company-explicit' }),
      }),
    });
    const create = vi.fn().mockResolvedValue({
      ...lead,
      companyId: 'company-explicit',
    });
    leadApi.select.mockReturnValue({ create });

    await service.create(
      {
        firstName: 'Jane',
        email: 'jane@acme.com',
        companyId: 'company-explicit',
      },
      sales,
    );

    expect(companiesService.resolveCompanyIdFromEmail).not.toHaveBeenCalled();
    expect(create).toHaveBeenCalledWith(
      expect.objectContaining({
        companyId: 'company-explicit',
      }),
    );
  });

  it('rejects create with missing company', async () => {
    companyApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(null),
      }),
    });

    await expect(
      service.create(
        {
          firstName: 'Jane',
          companyId: '00000000-0000-0000-0000-000000000001',
        },
        sales,
      ),
    ).rejects.toBeInstanceOf(NotFoundException);
  });

  it('lists leads with pagination for admin', async () => {
    leadApi.aggregate.mockResolvedValue({ total: 1 });
    leadApi.select.mockReturnValue({
      orderBy: vi.fn().mockReturnValue({
        limit: vi.fn().mockReturnValue({
          offset: vi.fn().mockReturnValue({
            all: vi.fn().mockResolvedValue([lead]),
          }),
        }),
      }),
    });

    const result = await service.findAll(admin, { page: 1, limit: 20 });
    expect(result.meta.total).toBe(1);
    expect(result.data[0]?.id).toBe(lead.id);
  });

  it('returns assignee summary counts for admin', async () => {
    leadApi.select.mockReturnValue({
      all: vi.fn().mockResolvedValue([
        { assignedToId: sales.id },
        { assignedToId: sales.id },
        { assignedToId: otherSales.id },
      ]),
    });

    await expect(service.getAssigneeSummary(admin, {})).resolves.toEqual({
      total: 3,
      assignees: [
        { userId: sales.id, count: 2 },
        { userId: otherSales.id, count: 1 },
      ],
    });
  });

  it('forbids sales from requesting assignee summary', async () => {
    await expect(service.getAssigneeSummary(sales, {})).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('forbids sales from viewing another assignee lead', async () => {
    leadApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue({
          ...lead,
          assignedToId: otherSales.id,
        }),
      }),
    });

    await expect(service.findOne(lead.id, sales)).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('updates status and records activity', async () => {
    leadApi.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: lead.id,
            status: 'NEW',
            assignedToId: sales.id,
            createdById: sales.id,
          }),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          update: vi.fn().mockResolvedValue([{ ...lead, status: 'CONTACTED' }]),
        }),
      });

    const result = await service.updateStatus(
      lead.id,
      { status: 'CONTACTED' },
      sales,
    );

    expect(result.status).toBe('CONTACTED');
    expect(activityApi.create).toHaveBeenCalledWith(
      expect.objectContaining({
        title: 'Lead status changed',
        type: 'NOTE',
      }),
    );
  });

  it('allows admin to assign lead', async () => {
    leadApi.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: lead.id,
            status: 'NEW',
            assignedToId: sales.id,
            createdById: sales.id,
          }),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          update: vi
            .fn()
            .mockResolvedValue([{ ...lead, assignedToId: otherSales.id }]),
        }),
      });

    userApi.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: otherSales.id,
            firstName: otherSales.firstName,
            lastName: otherSales.lastName,
            email: otherSales.email,
            isActive: true,
          }),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            firstName: sales.firstName,
            lastName: sales.lastName,
            email: sales.email,
          }),
        }),
      });

    const result = await service.assign(
      lead.id,
      { assignedToId: otherSales.id },
      admin,
    );

    expect(result.assignedToId).toBe(otherSales.id);
    expect(activityApi.create).toHaveBeenCalledWith(
      expect.objectContaining({
        title: 'Lead reassigned',
        description: 'Lead reassigned from Sales User to Other Rep',
      }),
    );
  });

  it('forbids unrelated sales user from assigning', async () => {
    leadApi.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue({
          id: lead.id,
          status: 'NEW',
          assignedToId: sales.id,
          createdById: sales.id,
        }),
      }),
    });

    await expect(
      service.assign(lead.id, { assignedToId: otherSales.id }, otherSales),
    ).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('does not allow createdById to change through update', async () => {
    leadApi.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: lead.id,
            status: 'NEW',
            assignedToId: sales.id,
            createdById: sales.id,
          }),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          update: vi.fn().mockResolvedValue([
            { ...lead, firstName: 'Janet', createdById: sales.id },
          ]),
        }),
      });

    const result = await service.update(
      lead.id,
      { firstName: 'Janet' },
      sales,
    );

    expect(result.createdById).toBe(sales.id);
  });
});
