import {
    BalanceResponse,
    CombinedLedgerResponse,
    CombinedLedgerResponseTypeEnum,
    CreateCombinedLedgerRequest,
    CreateMainLedgerRequest,
    LedgerResponseTypeEnum,
    MainLedgerResponse,
    MainLedgerResponseTypeEnum,
    TransactionResponse,
    UpdateCombinedLedgerRequest,
    UpdateMainLedgerRequest
} from "@/generated/mammon";
import {defineStore} from "pinia";
import {computed, ref, triggerRef} from "vue";
import {ledgerApi, transactionApi} from "@/mammon";
import {useRouteParams} from "@vueuse/router";

export const LedgerTypes = LedgerResponseTypeEnum;

export type LedgerType = LedgerResponseTypeEnum;
export type MainLedger = MainLedgerResponse & {type: MainLedgerResponseTypeEnum}
export type CombinedLedger = CombinedLedgerResponse & {type: CombinedLedgerResponseTypeEnum}
export type Ledger = MainLedger | CombinedLedger;

export const systemLedgerRef = 'system';
export const systemLedger = {
    type: LedgerTypes.Main,
    ledgerId: "00000000-0000-0000-0000-000000000001",
    name: "Eve Economy",
    balance: 0,
    _system: true
} as MainLedger;

export const isMain = (ledger: Ledger): ledger is MainLedger => {
    return ledger.type === LedgerTypes.Main;
}
export const isCombined = (ledger: Ledger): ledger is CombinedLedger => {
    return ledger.type === LedgerTypes.Combined;
}

export const useLedgersStore = defineStore('ledgers', () => {
    const ledgers = ref<Ledger[]>([]);

    const addLedger = (ledger: Ledger) => {
        ledgers.value.push(ledger);
        triggerRef(ledgers);
        return ledger;
    };

    const replaceLedger = (ledger: Ledger) => {
        const index = ledgers.value.findIndex(l => l.ledgerId === ledger.ledgerId);

        if (index !== -1) {
            ledgers.value[index] = ledger;
        }
        triggerRef(ledgers);
        return ledger;
    };

    const findById = (ledgerId: string): Ledger | undefined => ledgers.value.find(l => l.ledgerId === ledgerId);
    const findAllById = (ledgerIds: string[]): Ledger[] => ledgerIds.map(findById).filter((x): x is Ledger => x !== undefined)

    const createMain = (ledger: CreateMainLedgerRequest) => ledgerApi.createMainLedger(ledger).then(response => addLedger(response.data as Ledger));
    const createCombined = (ledger: CreateCombinedLedgerRequest) => ledgerApi.createCombinedLedger(ledger).then(response => addLedger(response.data as Ledger));
    const updateMain = (ledgerId: string, ledger: UpdateMainLedgerRequest) => ledgerApi.updateMainLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
    const updateCombined = (ledgerId: string, ledger: UpdateCombinedLedgerRequest) => ledgerApi.updateCombinedLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));

    const refresh = () => ledgerApi.findAllLedgers().then(response => ledgers.value = response.data as Ledger[]);

    refresh();

    return {ledgers, findById, findAllById, createMain, createCombined, updateMain, updateCombined, refresh};
})

const getLedgerId = (ledger: Ledger | string): string => typeof ledger == 'string' ? ledger : ledger.ledgerId;

export const findAllTransactionInLeger = (ledger: Ledger | string): Promise<TransactionResponse[]> => transactionApi.finAllTransactionsInLedger(getLedgerId(ledger)).then(response => response.data)
export const getLedgerBalance = (ledger: Ledger | string): Promise<BalanceResponse> => ledgerApi.findBalanceByLedgerId(getLedgerId(ledger)).then(response => response.data)

export const useLedgerParam = () => {
    const {findById} = useLedgersStore();
    const ledgerId = useRouteParams<string, string>('ledgerId', '', { transform: v => typeof v === 'string' ? v : v[0]});
    const ledger = computed(() => findById(ledgerId.value))

    return {ledgerId, ledger};
}