import 'temporal-polyfill/full/global';
import { Injectable } from '@nestjs/common';
import type { SafeUser } from '../auth/types/auth.types.js';
import { LEAD_STATUSES } from '../leads/types/lead.types.js';
import { PrismaService } from '../prisma/prisma.service.js';
import type {
  DashboardActivityItem,
  DashboardLeadItem,
  DashboardResponse,
} from './types/dashboard.types.js';

const LEAD_DASH_SELECT = [
  'id',
  'firstName',
  'lastName',
  'email',
  'phone',
  'status',
  'companyId',
  'createdAt',
  'assignedToId',
] as const;

const ACTIVITY_DASH_SELECT = [
  'id',
  'type',
  'title',
  'leadId',
  'userId',
  'createdAt',
] as const;

const CONTACTS_MEANING =
  'Contacts counts leads that have an email and/or phone (contactable people). There is no separate Contact model.';

const RECENT_LIMIT = 5;
const CLOSED_STATUSES = new Set(['WON', 'LOST']);

@Injectable()
export class DashboardService {
  constructor(private readonly prisma: PrismaService) {}

  async getOverview(currentUser: SafeUser): Promise<DashboardResponse> {
    const leadQuery =
      currentUser.role === 'SALES_USER'
        ? this.prisma.db.orm.public.Lead.select(...LEAD_DASH_SELECT).where(
            (l) => l.assignedToId.eq(currentUser.id),
          )
        : this.prisma.db.orm.public.Lead.select(...LEAD_DASH_SELECT);

    const [leads, companiesAgg, activities] = await Promise.all([
      leadQuery.orderBy((l) => l.createdAt.desc()).all(),
      this.prisma.db.orm.public.Company.aggregate((agg) => ({
        total: agg.count(),
      })),
      this.prisma.db.orm.public.Activity.select(...ACTIVITY_DASH_SELECT)
        .orderBy((a) => a.createdAt.desc())
        .limit(200)
        .all(),
    ]);

    const visibleLeadIds = new Set(leads.map((lead) => lead.id));
    const leadNameById = new Map(
      leads.map((lead) => [lead.id, this.formatLeadName(lead)] as const),
    );

    const visibleActivities = activities.filter((activity) =>
      visibleLeadIds.has(activity.leadId),
    );

    const contacts = leads.filter(
      (lead) => Boolean(lead.email?.trim()) || Boolean(lead.phone?.trim()),
    ).length;

    const openLeads = leads.filter(
      (lead) => !CLOSED_STATUSES.has(lead.status),
    ).length;
    const wonLeads = leads.filter((lead) => lead.status === 'WON').length;

    const companiesForSales = new Set(
      leads.map((lead) => lead.companyId).filter(Boolean),
    ).size;
    const companies =
      currentUser.role === 'SALES_USER'
        ? companiesForSales
        : companiesAgg.total;

    const pipeline = LEAD_STATUSES.map((status) => ({
      status,
      count: leads.filter((lead) => lead.status === status).length,
    }));

    const recentActivities: DashboardActivityItem[] = visibleActivities
      .slice(0, RECENT_LIMIT)
      .map((activity) => ({
        id: activity.id,
        type: activity.type,
        title: activity.title,
        leadId: activity.leadId,
        leadName: leadNameById.get(activity.leadId) || 'Lead',
        createdAt: activity.createdAt,
      }));

    const recentLeads: DashboardLeadItem[] = leads
      .slice(0, RECENT_LIMIT)
      .map((lead) => ({
        id: lead.id,
        firstName: lead.firstName,
        lastName: lead.lastName,
        email: lead.email,
        status: lead.status,
        createdAt: lead.createdAt,
      }));

    return {
      summary: {
        leads: leads.length,
        openLeads,
        wonLeads,
        companies,
        contacts,
      },
      contactsMeaning: CONTACTS_MEANING,
      pipeline,
      recentActivities,
      recentLeads,
    };
  }

  private formatLeadName(lead: {
    firstName: string;
    lastName: string | null;
  }): string {
    return [lead.firstName, lead.lastName].filter(Boolean).join(' ');
  }
}
