import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard.js';
import { RolesGuard } from '../auth/guards/roles.guard.js';
import type { SafeUser } from '../auth/types/auth.types.js';
import { LeadsController } from './leads.controller.js';
import { LeadsService } from './leads.service.js';
import type { LeadResponse } from './types/lead.types.js';

describe('LeadsController', () => {
  let controller: LeadsController;
  let leadsService: {
    create: ReturnType<typeof vi.fn>;
    findAll: ReturnType<typeof vi.fn>;
    getAssigneeSummary: ReturnType<typeof vi.fn>;
    findOne: ReturnType<typeof vi.fn>;
    update: ReturnType<typeof vi.fn>;
    updateStatus: ReturnType<typeof vi.fn>;
    assign: ReturnType<typeof vi.fn>;
  };

  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 lead: LeadResponse = {
    id: 'lead-1',
    firstName: 'Jane',
    lastName: 'Doe',
    email: 'jane@example.com',
    phone: null,
    jobTitle: null,
    status: 'NEW',
    source: 'OTHER',
    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 () => {
    leadsService = {
      create: vi.fn().mockResolvedValue(lead),
      findAll: vi.fn().mockResolvedValue({
        data: [lead],
        meta: { total: 1, page: 1, limit: 20, totalPages: 1 },
      }),
      getAssigneeSummary: vi.fn().mockResolvedValue({
        total: 1,
        assignees: [{ userId: sales.id, count: 1 }],
      }),
      findOne: vi.fn().mockResolvedValue(lead),
      update: vi.fn().mockResolvedValue(lead),
      updateStatus: vi.fn().mockResolvedValue({ ...lead, status: 'CONTACTED' }),
      assign: vi.fn().mockResolvedValue(lead),
    };

    const module: TestingModule = await Test.createTestingModule({
      controllers: [LeadsController],
      providers: [{ provide: LeadsService, useValue: leadsService }],
    })
      .overrideGuard(JwtAuthGuard)
      .useValue({ canActivate: () => true })
      .overrideGuard(RolesGuard)
      .useValue({ canActivate: () => true })
      .compile();

    controller = module.get(LeadsController);
  });

  it('creates a lead', async () => {
    const dto = { firstName: 'Jane' };
    await expect(controller.create(dto, sales)).resolves.toEqual(lead);
    expect(leadsService.create).toHaveBeenCalledWith(dto, sales);
  });

  it('lists leads', async () => {
    const query = { page: 1, limit: 20 };
    await expect(controller.findAll(query, sales)).resolves.toMatchObject({
      data: [lead],
    });
  });

  it('returns assignee summary for admin', async () => {
    const admin = { ...sales, id: 'admin-1', role: 'ADMIN' as const };
    await expect(
      controller.assigneeSummary({ status: 'NEW' }, admin),
    ).resolves.toEqual({
      total: 1,
      assignees: [{ userId: sales.id, count: 1 }],
    });
    expect(leadsService.getAssigneeSummary).toHaveBeenCalledWith(
      admin,
      { status: 'NEW' },
    );
  });

  it('gets a lead', async () => {
    await expect(controller.findOne('lead-1', sales)).resolves.toEqual(lead);
  });

  it('updates a lead', async () => {
    await expect(
      controller.update('lead-1', { firstName: 'Janet' }, sales),
    ).resolves.toEqual(lead);
  });

  it('updates lead status', async () => {
    await expect(
      controller.updateStatus('lead-1', { status: 'CONTACTED' }, sales),
    ).resolves.toMatchObject({ status: 'CONTACTED' });
  });

  it('assigns a lead', async () => {
    await expect(
      controller.assign('lead-1', { assignedToId: sales.id }, sales),
    ).resolves.toEqual(lead);
  });
});
