import {Temporal} from "@js-temporal/polyfill";
import {writable, get} from "svelte/store";
import {get_time_entries, create_time_entry, delete_time_entry, update_time_entry} from "$shared/lib/api/time-entry";
import type {TimeEntryDto} from "$shared/lib/models/TimeEntryDto";
import type {IInternalFetchResponse} from "$shared/lib/models/IInternalFetchResponse";
import type {TimeEntryQuery} from "$shared/lib/models/TimeEntryQuery";

const entries = writable<Array<TimeEntryDto>>([]);

export function get_time_entry(id: string): TimeEntryDto {
    return get(entries).find(c => c.id === id);
}

export async function reload_entries(query: TimeEntryQuery): Promise<void> {
    const get_entries_response = await get_time_entries(query);
    if (!get_entries_response.ok) {
        clear_entries();
        return;
    }
    entries.set(get_default_sorted(get_entries_response.data?.results ?? []));
}

export function clear_entries() {
    entries.set([]);
}

function get_default_sorted(unsorted: Array<TimeEntryDto>): Array<TimeEntryDto> {
    if (unsorted.length < 1) return unsorted;
    const byStart = unsorted.sort((a, b) => {
        return Temporal.Instant.compare(Temporal.Instant.from(b.start), Temporal.Instant.from(a.start));
    });

    return byStart.sort((a, b) => {
        return Temporal.Instant.compare(Temporal.Instant.from(b.stop), Temporal.Instant.from(a.stop));
    });
}

export async function create_entry_async(request: TimeEntryDto): Promise<IInternalFetchResponse> {
    const create_entry_response = await create_time_entry(request);
    if (create_entry_response.ok) {
        const stored_entries = get(entries) ?? [];
        stored_entries.push(create_entry_response.data);
        entries.set(get_default_sorted(stored_entries));
    }
    return create_entry_response;
}

export async function edit_entry_async(request: TimeEntryDto): Promise<IInternalFetchResponse> {
    if (!request.id) return;
    const edit_entry_response = await update_time_entry(request);
    if (edit_entry_response.ok) {
        const stored_entries = get(entries) ?? [];
        const index = stored_entries.findIndex(c => c.id === request.id);
        if (index === -1) {
            stored_entries.push(edit_entry_response.data);
        } else {
            stored_entries[index] = edit_entry_response.data;
        }
        entries.set(get_default_sorted(stored_entries));
    }
    return edit_entry_response;
}

export async function delete_entry_async(entry_id: string): Promise<void> {
    if (!entry_id) throw new Error("No id was supplied when deleting query");
    const delete_entry_response = await delete_time_entry(entry_id);
    if (delete_entry_response.ok) {
        const stored_entries = get(entries) ?? [];
        entries.set(get_default_sorted(stored_entries.filter((e) => e.id !== entry_id) ?? []));
    }
}


export default entries;