import { defineStore } from "pinia"
import { POST } from "../api";
import { useAccountStore } from "./budget-account";

interface State {
    Transactions: Map<string, Transaction>
    Reconciling: boolean
}

export interface Transaction {
    ID: string
    Date: Date
    TransferAccount: string
    CategoryGroup: string
    Category: string
    CategoryID: string | undefined
    Memo: string
    Status: string
    GroupID: string
    Payee: string
    PayeeID: string | undefined
    Amount: number
    Reconciled: boolean
}

export const useTransactionsStore = defineStore("budget/transactions", {
    state: (): State => ({
        Transactions: new Map<string, Transaction>(),
        Reconciling: false,
    }),
    getters: {
        ReconcilingBalance(state): number {
            const accountsStore = useAccountStore()
            let reconciledBalance = accountsStore.CurrentAccount!.ReconciledBalance;
            for (const transaction of this.TransactionsList) {
                if (transaction.Reconciled)
                    reconciledBalance += transaction.Amount;
            }
            return reconciledBalance;
        },
        TransactionsList(state): Transaction[] {
                const accountsStore = useAccountStore()
            return accountsStore.CurrentAccount!.Transactions.map(x => {
                return this.Transactions.get(x)!
            });
        },
    },
    actions: {
        AddTransactions(transactions: Array<Transaction>) {
            const transactionIds = [] as Array<string>;
            this.$patch(() => {
                for (const transaction of transactions) {
                    transaction.Date = new Date(transaction.Date);
                    this.Transactions.set(transaction.ID, transaction);
                    transactionIds.push(transaction.ID);
                }
            });
            return transactionIds;
        },
        SetReconciledForAllTransactions(value: boolean) {
            for (const transaction of this.TransactionsList) {
                if (transaction.Status == "Reconciled")
                    continue;

                transaction.Reconciled = value;
            }
        },
        async SubmitReconcilation(reconciliationTransactionAmount: number) {
                const accountsStore = useAccountStore()
            const account = accountsStore.CurrentAccount!;
            const reconciledTransactions = this.TransactionsList.filter(x => x.Reconciled);
            for (const transaction of reconciledTransactions) {
                account.ReconciledBalance += transaction.Amount;
                transaction.Status = "Reconciled";
                transaction.Reconciled = false;
            }
            const result = await POST("/account/" + accountsStore.CurrentAccountID + "/reconcile", JSON.stringify({
                transactionIDs: reconciledTransactions.map(x => x.ID),
                reconciliationTransactionAmount: reconciliationTransactionAmount.toString(),
            }));
            const response = await result.json();
            const recTrans = response.ReconciliationTransaction;
            if (recTrans) {
                this.AddTransactions([recTrans]);
                account.Transactions.unshift(recTrans.ID);
            }
        },
        logout() {
            this.$reset()
        },
        async saveTransaction(payload: string) {
                const accountsStore = useAccountStore()
            const result = await POST("/transaction/new", payload);
            const response = await result.json() as Transaction;
            this.AddTransactions([response]);
            accountsStore.CurrentAccount?.Transactions.unshift(response.ID);
        },
        async editTransaction(transactionid: string, payload: string) {
            const result = await POST("/transaction/" + transactionid, payload);
            const response = await result.json() as Transaction;
            this.AddTransactions([response]);
        }
    }

})