import {
	getTransactions,
	type Transaction,
	type TransactionFilter,
	type TransactionsRecord,
} from "@olenbetong/appframe-updater";
import { useCallback, useEffect, useMemo, useState } from "react";

import type { Server } from "../lib/Server.js";

export type TransactionsEditorRefreshOptions = {
	preserveViewport?: boolean;
	anchorPrimKey?: string | null;
};

type UseTransactionsOptions = {
	server: Server;
	namespace: string | number;
	filter?: TransactionFilter;
};

export function useTransactions({ filter, server, namespace }: UseTransactionsOptions) {
	let [transactions, setTransactions] = useState<TransactionsRecord[]>([]);
	let [loading, setLoading] = useState(false);
	let [error, setError] = useState<Error | undefined>();

	let refresh = useCallback(
		async (_options: TransactionsEditorRefreshOptions = {}) => {
			setLoading(true);
			setError(undefined);
			try {
				let data = (await getTransactions(server.client, filter ?? "edit", namespace)) as TransactionsRecord[];
				setTransactions(data);
			} catch (caught) {
				setError(caught as Error);
			} finally {
				setLoading(false);
			}
		},
		[namespace, server, filter],
	);

	useEffect(() => {
		setError(undefined);
		refresh();
	}, [refresh]);

	let normalizedTransactions = useMemo<Transaction[]>(
		() =>
			transactions.map((transaction) => ({
				ID: transaction.ID,
				Namespace: transaction.Namespace,
				Name: transaction.Name,
				CreatedBy: transaction.CreatedBy ?? transaction.CreatedByName ?? transaction.LocalCreatedBy,
				Status: transaction.Status,
				LastError: transaction.LastError ?? undefined,
				PrimKey: transaction.PrimKey,
			})),
		[transactions],
	);

	let transactionMap = useMemo(
		() => new Map(transactions.map((transaction) => [transaction.PrimKey, transaction])),
		[transactions],
	);

	return {
		transactions,
		loading,
		error,
		refresh,
		normalizedTransactions,
		transactionMap,
	};
}