import { useCallback, useEffect, useState } from "react";
import type { Schedule, ScheduleEndCondition, ScheduleFrequency } from "@/lib/shared/types";
import { schedulesCreate, schedulesDelete, schedulesList, schedulesUpdate } from "@/lib/client/schedules";
import type { ApiResult } from "@/lib/client/fetch-json";

type ScheduleInput = {
    entryType: "SPENDING" | "INCOME";
    amountDollars: number;
    necessity: "NECESSARY" | "BOTH" | "UNNECESSARY";
    purchaseType: string;
    notes?: string;
    tags?: string[];
    startsOn: string;
    frequency: ScheduleFrequency;
    intervalCount?: number;
    endCondition?: ScheduleEndCondition;
    endCount?: number | null;
    endDate?: string | null;
};

function isError<T>(result: ApiResult<T>): result is { error: { code: string; message: string } } {
    return "error" in result;
}

function compareSchedulesAsc(a: Schedule, b: Schedule) {
    if (a.nextRunOn === b.nextRunOn) return Number(a.id) - Number(b.id);
    return a.nextRunOn > b.nextRunOn ? 1 : -1;
}

function upsertScheduleSorted(schedules: Schedule[], next: Schedule) {
    const without = schedules.filter(item => Number(item.id) !== Number(next.id));
    const merged = [next, ...without];
    merged.sort(compareSchedulesAsc);
    return merged;
}

export default function useSchedules(activeGroupId?: number | null) {
    const [schedules, setSchedules] = useState<Schedule[]>([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState("");

    const load = useCallback(async () => {
        if (!activeGroupId) {
            setError("");
            setSchedules([]);
            setLoading(false);
            return;
        }
        setLoading(true);
        setError("");
        const result = await schedulesList();
        if (isError(result)) {
            setError(result.error.message || "");
            setSchedules([]);
        } else {
            const next = [...(result.data.schedules || [])];
            next.sort(compareSchedulesAsc);
            setSchedules(next);
        }
        setLoading(false);
    }, [activeGroupId]);

    const createSchedule = useCallback(async (input: ScheduleInput & { createEntryNow?: boolean }): Promise<Schedule | null> => {
        setError("");
        const result = await schedulesCreate(input);
        if (isError(result)) {
            setError(result.error.message || "");
            return null;
        }
        const created = result.data.schedule;
        setSchedules(prev => upsertScheduleSorted(prev, created));
        return created;
    }, []);

    const updateSchedule = useCallback(async (input: ScheduleInput & { id: number; nextRunOn?: string; isActive?: boolean }): Promise<Schedule | null> => {
        setError("");
        const result = await schedulesUpdate(input);
        if (isError(result)) {
            setError(result.error.message || "");
            return null;
        }
        const updated = result.data.schedule;
        setSchedules(prev => upsertScheduleSorted(prev, updated));
        return updated;
    }, []);

    const deleteSchedule = useCallback(async (id: number | string): Promise<Schedule | null> => {
        setError("");
        const numericId = Number(id);
        if (!Number.isFinite(numericId) || numericId <= 0) return null;
        let removed: Schedule | null = null;
        const result = await schedulesDelete({ id });
        if (isError(result)) {
            setError(result.error.message || "");
            return null;
        }
        setSchedules(prev => {
            const index = prev.findIndex(item => Number(item.id) === numericId);
            if (index < 0) return prev;
            removed = prev[index];
            return [...prev.slice(0, index), ...prev.slice(index + 1)];
        });
        return removed;
    }, []);

    useEffect(() => {
        load();
    }, [load]);

    return {
        schedules,
        loading,
        error,
        createSchedule,
        updateSchedule,
        deleteSchedule,
        reload: load
    };
}