import { SortType } from "@/enums";
import type { RawTask, Task } from "@/types";
import { CronExpressionParser } from "cron-parser";

export function parseTask(task: RawTask): Task {
    return {
        id: task.id,
        name: task.name,
        reset_cron: task.reset_cron,
        created_at: new Date(task.created_at),
        updated_at: new Date(task.updated_at),
        check_date: task.check_date ? new Date(task.check_date) : null,
        previous_check_date: task.previous_check_date
            ? new Date(task.previous_check_date)
            : null,
    };
}

export function taskNextReset(task: Task): Date | null {
    if (task.check_date === null || task.reset_cron === null) {
        return null;
    }
    try {
        const interval = CronExpressionParser.parse(task.reset_cron, {
            currentDate: task.check_date,
        });
        return interval.next().toDate();
    } catch {
        return null;
    }
}

export function taskCompleted(task: Task): boolean {
    const nextReset = taskNextReset(task);
    if (nextReset === null) {
        return task.check_date !== null;
    }
    return nextReset.getTime() > new Date().getTime();
}

export function sortTasks(
    tasks: Task[],
    sortType: SortType,
    reverse: boolean,
): Task[] {
    switch (sortType) {
        case SortType.CREATED_AT:
            return tasks
                .slice()
                .sort(
                    (a: Task, b: Task) =>
                        (reverse ? -1 : 1) *
                        (a.created_at.getTime() - b.created_at.getTime()),
                );
        case SortType.UPDATED_AT:
            return tasks
                .slice()
                .sort(
                    (a: Task, b: Task) =>
                        (reverse ? -1 : 1) *
                        (a.updated_at.getTime() - b.updated_at.getTime()),
                );
        case SortType.CHECK_DATE:
            return tasks
                .slice()
                .sort(
                    (a: Task, b: Task) =>
                        (reverse ? -1 : 1) *
                        ((a.check_date ?? a.created_at).getTime() -
                            (b.check_date ?? b.created_at).getTime()),
                );
        case SortType.RESET_DATE:
            return tasks
                .slice()
                .sort(
                    (a: Task, b: Task) =>
                        (reverse ? -1 : 1) *
                            (taskNextReset(a) ?? a.created_at).getTime() -
                        (taskNextReset(b) ?? b.created_at).getTime(),
                );
        case SortType.NAME:
            return tasks
                .slice()
                .sort(
                    (a: Task, b: Task) =>
                        (reverse ? -1 : 1) * a.name.localeCompare(b.name),
                );
        default:
            return tasks.slice();
    }
}