import { SortType } from "@/enums";
import type { RawTask, Task, TaskCreateData } from "@/types";
import { nextCronReset } from "@/lib/recurrence";

const TEMPORARY_ID = "tmp";

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 newTemporaryTask(data: TaskCreateData): Task {
    return {
        id: TEMPORARY_ID,
        name: data.name,
        reset_cron: data.reset_cron,
        created_at: new Date(),
        updated_at: new Date(),
        check_date: null,
        previous_check_date: null,
    };
}

export function isTemporary(task: Task): boolean {
    return task.id === TEMPORARY_ID;
}

export function taskNextReset(task: Task): Date | null {
    return nextCronReset(
        task.check_date ?? new Date(),
        task.reset_cron,
        task.id,
    );
}

export function taskFutureReset(task: Task): Date | null {
    return nextCronReset(
        taskNextReset(task) ?? new Date(),
        task.reset_cron,
        task.id,
    );
}

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

export function fallbackDate(task: Task): Date {
    return new Date(
        (task.check_date ?? task.created_at).getFullYear() + 100,
        (task.check_date ?? task.created_at).getMonth(),
        (task.check_date ?? task.created_at).getDate(),
        0,
        0,
        0,
        0,
    );
}

export function taskSortFunction(
    sortType: SortType,
    reverse: boolean,
): (a: Task, b: Task) => number {
    switch (sortType) {
        case SortType.CREATED_AT:
            return (a: Task, b: Task) =>
                (reverse ? -1 : 1) *
                (a.created_at.getTime() - b.created_at.getTime());
        case SortType.UPDATED_AT:
            return (a: Task, b: Task) =>
                (reverse ? -1 : 1) *
                (a.updated_at.getTime() - b.updated_at.getTime());
        case SortType.CHECK_DATE:
            return (a: Task, b: Task) =>
                (reverse ? -1 : 1) *
                ((a.check_date ?? fallbackDate(a)).getTime() -
                    (b.check_date ?? fallbackDate(b)).getTime());
        case SortType.RESET_DATE:
            return (a: Task, b: Task) =>
                (reverse ? -1 : 1) *
                ((taskNextReset(a) ?? fallbackDate(a)).getTime() -
                    (taskNextReset(b) ?? fallbackDate(b)).getTime());
        case SortType.NAME:
            return (a: Task, b: Task) =>
                (reverse ? -1 : 1) * a.name.localeCompare(b.name);
    }
}