import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { SafeUser } from '../auth/types/auth.types.js';
import { PrismaService } from '../prisma/prisma.service.js';
import { DashboardService } from './dashboard.service.js';

describe('DashboardService', () => {
  let service: DashboardService;
  let leadSelect: ReturnType<typeof vi.fn>;
  let companyAggregate: ReturnType<typeof vi.fn>;
  let activitySelect: 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 leads = [
    {
      id: 'lead-1',
      firstName: 'Ada',
      lastName: 'Lovelace',
      email: 'ada@example.com',
      phone: null,
      status: 'NEW',
      companyId: 'co-1',
      createdAt: new Date('2026-03-01T00:00:00.000Z'),
      assignedToId: sales.id,
    },
    {
      id: 'lead-2',
      firstName: 'Grace',
      lastName: 'Hopper',
      email: null,
      phone: null,
      status: 'QUALIFIED',
      companyId: 'co-2',
      createdAt: new Date('2026-02-01T00:00:00.000Z'),
      assignedToId: 'other-sales',
    },
  ];

  const activities = [
    {
      id: 'act-1',
      type: 'NOTE',
      title: 'Kickoff note',
      leadId: 'lead-1',
      userId: sales.id,
      createdAt: new Date('2026-03-05T00:00:00.000Z'),
    },
    {
      id: 'act-2',
      type: 'CALL',
      title: 'Intro call',
      leadId: 'lead-1',
      userId: sales.id,
      createdAt: new Date('2026-03-04T00:00:00.000Z'),
    },
    {
      id: 'act-3',
      type: 'EMAIL',
      title: 'Proposal email',
      leadId: 'lead-2',
      userId: admin.id,
      createdAt: new Date('2026-03-03T00:00:00.000Z'),
    },
  ];

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

    leadSelect = vi.fn();
    companyAggregate = vi.fn().mockResolvedValue({ total: 4 });
    activitySelect = vi.fn().mockReturnValue({
      orderBy: vi.fn().mockReturnValue({
        limit: vi.fn().mockReturnValue({
          all: vi.fn().mockResolvedValue(activities),
        }),
      }),
    });

    const prisma = {
      db: {
        orm: {
          public: {
            Lead: { select: leadSelect },
            Company: { aggregate: companyAggregate },
            Activity: { select: activitySelect },
          },
        },
      },
    };

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

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

  function mockLeads(rows: typeof leads, withWhere = false) {
    const ordered = {
      orderBy: vi.fn().mockReturnValue({
        all: vi.fn().mockResolvedValue(rows),
      }),
    };
    if (withWhere) {
      leadSelect.mockReturnValue({
        where: vi.fn().mockReturnValue(ordered),
      });
    } else {
      leadSelect.mockReturnValue(ordered);
    }
  }

  it('returns admin overview with pipeline, contacts and recent items', async () => {
    mockLeads(leads, false);

    const result = await service.getOverview(admin);

    expect(result.summary).toEqual({
      leads: 2,
      openLeads: 2,
      wonLeads: 0,
      companies: 4,
      contacts: 1,
    });
    expect(result.tasks).toBeUndefined();
    expect(result.recentActivities).toHaveLength(3);
    expect(result.recentLeads).toHaveLength(2);
    expect(result.contactsMeaning).toContain('email and/or phone');
    expect(result.pipeline.find((item) => item.status === 'NEW')?.count).toBe(
      1,
    );
    expect(
      result.pipeline.find((item) => item.status === 'QUALIFIED')?.count,
    ).toBe(1);
    expect(result.recentLeads[0]?.id).toBe('lead-1');
    expect(result.recentActivities.some((item) => item.type === 'NOTE')).toBe(
      true,
    );
  });

  it('scopes leads and related activities to assigned leads for sales users', async () => {
    mockLeads([leads[0]!], true);

    const result = await service.getOverview(sales);

    expect(result.summary.leads).toBe(1);
    expect(result.summary.openLeads).toBe(1);
    expect(result.summary.wonLeads).toBe(0);
    expect(result.summary.companies).toBe(1);
    expect(result.summary.contacts).toBe(1);
    expect(result.recentLeads.every((lead) => lead.id === 'lead-1')).toBe(true);
    expect(
      result.recentActivities.every((activity) => activity.leadId === 'lead-1'),
    ).toBe(true);
  });
});
