import { BalanceMap, newCategoryBalanceMapFromDto } from "../types/balanceMap";
import { BudgetMap, newBudgetMapFromDto } from "../types/budgetMap";
import { BudgetUpdate, newBudgetUpdateFromDto } from "../types/budgetUpdate";
import { Category, newCategoryFromDto } from "../types/category";

const backendUrl = "http://localhost:8000";

function makeGetter<T>(params: FetcherMakerParams<T>): Getter<T> {
  const parser =
    "parser" in params
      ? params.parser
      : (dto: unknown[]) => <T>dto.map(params.elementParser);

  return async function () {
    const response = await fetch(`${backendUrl}${params.path}`);
    const dto = await response.json();

    try {
      return parser(dto);
    } catch (err) {
      console.error(`Error parsing DTO. ${err?.toString() ?? ""}`);
      return null;
    }
  };
}

export const getAllBudgetUpdates: Getter<BudgetUpdate[]> = makeGetter<
  BudgetUpdate[]
>({
  path: "/budget-update",
  elementParser: newBudgetUpdateFromDto,
});

export const getAllCategories: Getter<Category[]> = async () => {
  const balances = await getAllCategoryBalances();
  const budgets = await getAllCurrentCategoryBudgets();
  return makeGetter<Category[]>({
    path: "/category",
    elementParser: newCategoryFromDto(balances, budgets),
  })();
};

export const getAllCategoryBalances: Getter<BalanceMap<Category>> = makeGetter<
  BalanceMap<Category>
>({
  path: "/balance/category",
  parser: newCategoryBalanceMapFromDto,
});

export const getAllCurrentCategoryBudgets: Getter<BudgetMap<Category>> =
  makeGetter<BudgetMap<Category>>({
    path: "/budget/category?current",
    parser: newBudgetMapFromDto,
  });

type FetcherMakerParams<T> = {
  path: string;
} & AnyParser<T>;

type Parser<T> = { parser: (dto: unknown) => T | null };
type ElementParser<T> = { elementParser: (dto: unknown) => T | null };
type AnyParser<T> = T extends any[]
  ? Parser<T> | ElementParser<T[number]>
  : Parser<T>;

type Getter<T> = () => Promise<T | null>;