import { Injectable } from "@nestjs/common";
import { PrismaService } from "src/prisma/prisma.service";
import { computeHours, computePeriod, listPayYear, payYearOfDate, toStringFromDate } from "src/common/utils/date-utils";
import { EmployeePeriodOverviewDto, PayPeriodDto, PayPeriodOverviewDto } from "../dtos/overview-pay-period.dto";
import { Result } from "src/common/errors/result-error.factory";
import { mapPayPeriodToDto } from "src/time-and-attendance/pay-period/pay-periods.mapper";

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

    async getOverview(pay_period_no: number): Promise<Result<PayPeriodOverviewDto, string>> {
        const period = await this.prisma.payPeriods.findFirst({
            where: { pay_period_no },
            orderBy: { pay_year: "desc" },
        });
        if (!period) return { success: false, error: `PAY_PERIOD_NOT_FOUND` };

        const overview = await this.buildOverview({
            period_start: period.period_start,
            period_end: period.period_end,
            payday: period.payday,
            period_no: period.pay_period_no,
            pay_year: period.pay_year,
            label: period.label,
        });
        if (!overview.success) return { success: false, error: 'INVALID_PAY_PERIOD' }

        return { success: true, data: overview.data }
    }

    async getOverviewByYearPeriod(pay_year: number, period_no: number): Promise<Result<PayPeriodOverviewDto, string>> {
        const period = computePeriod(pay_year, period_no);
        const overview = await this.buildOverview({
            period_start: period.period_start,
            period_end: period.period_end,
            period_no: period.period_no,
            pay_year: period.pay_year,
            payday: period.payday,
            label: period.label,
        });
        if (!overview.success) return { success: false, error: 'INVALID_PAY_PERIOD' }
        return { success: true, data: overview.data }
    }

    //find crew member associated with supervisor
    private async resolveCrew(supervisor_id: number, include_subtree: boolean):
        Promise<Result<Array<{ id: number; first_name: string; last_name: string; email: string }>, string>> {
        const result: Array<{ id: number; first_name: string; last_name: string; email: string; }> = [];

        let frontier = await this.prisma.employees.findMany({
            where: { supervisor_id: supervisor_id },
            select: { id: true, user: { select: { first_name: true, last_name: true, email: true } } },
        });
        result.push(...frontier.map(emp => ({
            id: emp.id, first_name: emp.user.first_name, last_name: emp.user.last_name, email: emp.user.email
        })));

        if (!include_subtree) return { success: true, data: result };

        while (frontier.length) {
            const parent_ids = frontier.map(emp => emp.id);
            const next = await this.prisma.employees.findMany({
                where: { supervisor_id: { in: parent_ids } },
                select: { id: true, user: { select: { first_name: true, last_name: true, email: true } } },
            });
            if (next.length === 0) break;
            result.push(...next.map(emp => ({
                id: emp.id, first_name: emp.user.first_name, last_name: emp.user.last_name, email: emp.user.email
            })));
            frontier = next;
        }
        return { success: true, data: result };
    }

    //fetchs crew emails
    async resolveCrewEmails(supervisor_id: number, include_subtree: boolean): Promise<Result<Set<string>, string>> {
        const crew = await this.resolveCrew(supervisor_id, include_subtree);
        if (!crew.success) return { success: false, error: crew.error }
        return { success: true, data: new Set(crew.data.map(crew_member => crew_member.email).filter(Boolean)) }
    }

    async getCrewOverview(pay_year: number, period_no: number, email: string, include_subtree: boolean):
        Promise<Result<PayPeriodOverviewDto, string>> {
        // 1) Search for the period
        const period = await this.prisma.payPeriods.findFirst({ where: { pay_year, pay_period_no: period_no } });
        if (!period) return { success: false, error: 'PAY_PERIOD_NOT_FOUND' }

        // 2) fetch supervisor
        const supervisor = await this.prisma.employees.findFirst({
            where: { user: { email: email } },
            select: {
                id: true,
                is_supervisor: true,
            },
        });

        if (!supervisor) return { success: false, error: 'EMPLOYEE_NOT_FOUND' }
        if (!supervisor.is_supervisor) return { success: false, error: 'INVALID_EMPLOYEE' }

        // 3)fetchs crew members
        const crew = await this.resolveCrew(supervisor.id, include_subtree); // [{ id, first_name, last_name }]
        if (!crew.success) return { success: false, error: crew.error }
        const crew_ids = crew.data.map(c => c.id);
        // seed names map for employee without data
        const seed_names = new Map<number, { name: string; email: string }>(
            crew.data.map(crew => [
                crew.id,
                {
                    name: `${crew.first_name} ${crew.last_name}`.trim(),
                    email: crew.email
                }
            ]
            )
        );
        const overview = await this.buildOverview({
            period_no: period.pay_period_no,
            period_start: period.period_start,
            period_end: period.period_end,
            payday: period.payday,
            pay_year: period.pay_year,
            label: period.label,
        }, { filtered_employee_ids: crew_ids, seed_names })
        if (!overview.success) return { success: false, error: 'INVALID_PAY_PERIOD' }

        // 4) overview build
        return { success: true, data: overview.data }
    }



    private async buildOverview(
        period: {
            period_start: string | Date; period_end: string | Date; payday: string | Date;
            period_no: number; pay_year: number; label: string;
        },
        options?: { filtered_employee_ids?: number[]; seed_names?: Map<number, { name: string, email: string }> }
    ): Promise<Result<PayPeriodOverviewDto, string>> {
        const toDateString = (d: Date) => d.toISOString().slice(0, 10);
        const toMoney = (v: any) => (typeof v === "object" && "toNumber" in v ? v.toNumber() : (v as number));

        const start = period.period_start instanceof Date
            ? period.period_start
            : new Date(`${period.period_start}T00:00:00.000Z`);

        const end = period.period_end instanceof Date
            ? period.period_end
            : new Date(`${period.period_end}T00:00:00.000Z`);

        const payd = period.payday instanceof Date
            ? period.payday
            : new Date(`${period.payday}T00:00:00.000Z`);

        //restrictEmployeeIds = filter for shifts and expenses by employees
        const where_employee = options?.filtered_employee_ids?.length ?
            {
                date: { gte: start, lte: end },
                timesheet: { employee_id: { in: options.filtered_employee_ids } },
            }
            :
            { date: { gte: start, lte: end } };

        // SHIFTS (filtered by crew)
        const shifts = await this.prisma.shifts.findMany({
            where: where_employee,
            select: {
                start_time: true,
                end_time: true,
                is_remote: true,
                timesheet: {
                    select: {
                        id: true,
                        is_approved: true,
                        employee: {
                            select: {
                                id: true,
                                user: {
                                    select: {
                                        first_name: true,
                                        last_name: true,
                                        email: true,
                                    }
                                },
                            }
                        },
                    },
                },
                bank_code: { select: { categorie: true, type: true } },
            },
        });

        // EXPENSES (filtered by crew)
        const expenses = await this.prisma.expenses.findMany({
            where: where_employee,
            select: {
                amount: true,
                timesheet: {
                    select: {
                        id: true,
                        is_approved: true,
                        employee: {
                            select: {
                                id: true,
                                user: {
                                    select: {
                                        first_name: true,
                                        last_name: true,
                                        email: true,
                                    }
                                },
                            }
                        },
                    }
                },
                bank_code: { select: { categorie: true, modifier: true, type: true } },
            },
        });
        const timesheet_id = shifts[0].timesheet.id ? expenses[0].timesheet.id : null;
        if (timesheet_id === null) return { success: false, error: 'INVALID_TIMESHEET' };

        const by_employee = new Map<number, EmployeePeriodOverviewDto>();

        const timesheet = await this.prisma.timesheets.findFirst({
            where: { id: timesheet_id },
            select: {
                is_approved: true,
                id: true,
            },
        });
        if (!timesheet) return { success: false, error: 'INVALID_TIMESHEET' };

        // seed for employee without data
        if (options?.seed_names) {
            for (const [id, { name, email }] of options.seed_names.entries()) {
                by_employee.set(id, {
                    email,
                    employee_name: name,
                    is_active: true,
                    regular_hours: 0,
                    other_hours: {
                        evening_hours: 0,
                        emergency_hours: 0,
                        overtime_hours: 0,
                        sick_hours: 0,
                        holiday_hours: 0,
                        vacation_hours: 0,
                    },
                    total_hours: 0,
                    expenses: 0,
                    mileage: 0,
                    is_approved: false,
                });
            }
        } else {
            const all_employees = await this.prisma.employees.findMany({
                include: {
                    user: {
                        select: {
                            first_name: true,
                            last_name: true,
                            email: true
                        },
                    },
                },
            });

            for (const employee of all_employees) {
                let is_active = true;

                if (employee.last_work_day !== null) {
                    is_active = this.checkForInactiveDate(employee.last_work_day)
                }

                by_employee.set(employee.id, {
                    email: employee.user.email,
                    employee_name: employee.user.first_name + ' ' + employee.user.last_name,
                    is_active: is_active,
                    regular_hours: 0,
                    other_hours: {
                        evening_hours: 0,
                        emergency_hours: 0,
                        overtime_hours: 0,
                        sick_hours: 0,
                        holiday_hours: 0,
                        vacation_hours: 0,
                    },
                    total_hours: 0,
                    expenses: 0,
                    mileage: 0,
                    is_approved: timesheet.is_approved,
                });
            }
        }

        const ensure = (id: number, name: string, email: string) => {
            if (!by_employee.has(id)) {
                by_employee.set(id, {
                    email,
                    employee_name: name,
                    is_active: true,
                    regular_hours: 0,
                    other_hours: {
                        evening_hours: 0,
                        emergency_hours: 0,
                        overtime_hours: 0,
                        sick_hours: 0,
                        holiday_hours: 0,
                        vacation_hours: 0,
                    },
                    total_hours: 0,
                    expenses: 0,
                    mileage: 0,
                    is_approved: timesheet.is_approved,
                });
            }
            return by_employee.get(id)!;
        };

        for (const shift of shifts) {
            const employee = shift.timesheet.employee;
            const name = `${employee.user.first_name} ${employee.user.last_name}`.trim();
            const record = ensure(employee.id, name, employee.user.email);

            const hours = computeHours(shift.start_time, shift.end_time);
            const type = (shift.bank_code?.type ?? '').toUpperCase();
            switch (type) {
                case "EVENING": record.other_hours.evening_hours += hours;
                    record.total_hours += hours;
                    break;
                case "EMERGENCY": record.other_hours.emergency_hours += hours;
                    record.total_hours += hours;
                    break;
                case "OVERTIME": record.other_hours.overtime_hours += hours;
                    record.total_hours += hours;
                    break;
                case "SICK": record.other_hours.sick_hours += hours;
                    record.total_hours += hours;
                    break;
                case "HOLIDAY": record.other_hours.holiday_hours += hours;
                    record.total_hours += hours;
                    break;
                case "VACATION": record.other_hours.vacation_hours += hours;
                    record.total_hours += hours;
                    break;
                case "REGULAR": record.regular_hours = record.regular_hours += hours;
                    record.total_hours += hours;
                    break;
            }

            record.is_approved = record.is_approved && shift.timesheet.is_approved;
        }

        for (const expense of expenses) {
            const exp = expense.timesheet.employee;
            const name = `${exp.user.first_name} ${exp.user.last_name}`.trim();
            const record = ensure(exp.id, name, exp.user.email);

            const amount = toMoney(expense.amount);
            record.expenses = Number((record.expenses += amount).toFixed(2));

            const type = (expense.bank_code?.type || "").toUpperCase();
            const rate = expense.bank_code?.modifier ?? 0;
            if (type === "MILEAGE" && rate > 0) {
                record.mileage = Number((record.mileage += Math.round((amount / rate) * 100) / 100).toFixed(2));
            }
            record.is_approved = record.is_approved && expense.timesheet.is_approved;
        }

        const employees_overview = Array.from(by_employee.values()).sort((a, b) =>
            a.employee_name.localeCompare(b.employee_name, "fr", { sensitivity: "base" }),
        );

        return {
            success: true,
            data: {
                pay_period_no: period.period_no,
                pay_year: period.pay_year,
                payday: toDateString(payd),
                period_start: toDateString(start),
                period_end: toDateString(end),
                label: period.label,
                employees_overview,
            }
        };
    }

    async getSupervisor(email: string) {
        return this.prisma.employees.findFirst({
            where: { user: { email } },
            select: { id: true, is_supervisor: true },
        });
    }

    async findAll(): Promise<Result<PayPeriodDto[], string>> {
        const currentPayYear = payYearOfDate(new Date());
        return {
            success: true,
            data: listPayYear(currentPayYear).map(period => ({
                pay_period_no: period.period_no,
                pay_year: period.pay_year,
                payday: period.payday,
                period_start: period.period_start,
                period_end: period.period_end,
                label: period.label,
            }))
        };
    }

    async findOne(period_no: number): Promise<Result<PayPeriodDto, string>> {
        const row = await this.prisma.payPeriods.findFirst({
            where: { pay_period_no: period_no },
            orderBy: { pay_year: "desc" },
        });
        if (!row) return { success: false, error: `PAY_PERIOD_NOT_FOUND` }
        return { success: true, data: mapPayPeriodToDto(row) };
    }

    async findCurrent(date?: string): Promise<Result<PayPeriodDto, string>> {
        const iso_day = date ?? new Date().toISOString().slice(0, 10);
        const pay_period = await this.findByDate(iso_day);
        if (!pay_period.success) return { success: false, error: 'INVALID_PAY_PERIOD' }
        return { success: true, data: pay_period.data }
    }

    async findOneByYearPeriod(pay_year: number, period_no: number): Promise<Result<PayPeriodDto, string>> {
        const row = await this.prisma.payPeriods.findFirst({
            where: { pay_year, pay_period_no: period_no },
        });
        if (row) return { success: true, data: mapPayPeriodToDto(row) };

        // fallback for outside of view periods
        const period = computePeriod(pay_year, period_no);
        return {
            success: true,
            data: {
                pay_period_no: period.period_no,
                pay_year: period.pay_year,
                period_start: period.period_start,
                payday: period.payday,
                period_end: period.period_end,
                label: period.label
            }
        }
    }

    //function to cherry pick a Date to find a period
    async findByDate(date: string): Promise<Result<PayPeriodDto, string>> {
        const dt = new Date(date);
        const row = await this.prisma.payPeriods.findFirst({
            where: { period_start: { lte: dt }, period_end: { gte: dt } },
        });
        if (row) return { success: true, data: mapPayPeriodToDto(row) };

        //fallback for outwside view periods
        const pay_year = payYearOfDate(date);
        const periods = listPayYear(pay_year);
        const hit = periods.find(period => date >= period.period_start && date <= period.period_end);
        if (!hit) return { success: false, error: `PAY_PERIOD_NOT_FOUND` }

        return {
            success: true,
            data: {
                pay_period_no: hit.period_no,
                pay_year: hit.pay_year,
                period_start: hit.period_start,
                period_end: hit.period_end,
                payday: hit.payday,
                label: hit.label
            }
        }
    }

    async getPeriodWindow(pay_year: number, period_no: number) {
        return this.prisma.payPeriods.findFirst({
            where: { pay_year, pay_period_no: period_no },
            select: { period_start: true, period_end: true },
        });
    }

    private checkForInactiveDate = (last_work_day: Date) => {
        const limit = new Date(last_work_day);
        limit.setDate(limit.getDate() + 14);
        if (limit >= new Date()) {
            return true;
        }
        return false;
    }
}