/*
 This file is part of GNU Taler
 (C) 2022 Taler Systems S.A.

 GNU Taler is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software
 Foundation; either version 3, or (at your option) any later version.

 GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with
 GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */


import { FeeDescription, OperationMap } from "@gnu-taler/taler-util";
import { createDenominationPairTimeline } from "@gnu-taler/taler-wallet-core";
import { useState } from "preact/hooks";
import { useAsyncAsHook } from "../../hooks/useAsyncAsHook.js";
import * as wxApi from "../../wxApi.js";
import { Props, State } from "./index.js";

export function useComponentState(
  { onCancel, onSelection, currency }: Props,
  api: typeof wxApi,
): State {
  const initialValue = 0
  const [value, setValue] = useState(String(initialValue));

  const hook = useAsyncAsHook(async () => {
    const { exchanges } = await api.listExchanges()

    const selectedIdx = parseInt(value, 10)
    const selectedExchange = exchanges.length == 0 ? undefined : exchanges[selectedIdx]
    const selected = !selectedExchange ? undefined : await api.getExchangeDetailedInfo(selectedExchange.exchangeBaseUrl)

    const initialExchange = selectedIdx === initialValue ? undefined : exchanges[initialValue]
    const original = !initialExchange ? undefined : await api.getExchangeDetailedInfo(initialExchange.exchangeBaseUrl)
    return { exchanges, selected, original }
  });

  if (!hook) {
    return {
      status: "loading",
      error: undefined,
    }
  }
  if (hook.hasError) {
    return {
      status: "loading-uri",
      error: hook,
    };
  }

  const { exchanges, selected, original } = hook.response;

  if (!selected) {
    //!selected <=> exchanges.length === 0
    return {
      status: "no-exchanges",
      error: undefined
    }
  }

  const exchangeMap = exchanges.reduce((prev, cur, idx) => ({ ...prev, [cur.exchangeBaseUrl]: String(idx) }), {} as Record<string, string>)

  if (!original) {
    // !original <=> selected == original
    return {
      status: "ready",
      exchanges: {
        list: exchangeMap,
        value: value,
        onChange: async (v) => {
          setValue(v)
        }
      },
      error: undefined,
      onClose: {
        onClick: onCancel
      },
      selected,
      timeline: selected.feesDescription
    }
  }

  const pairTimeline: OperationMap<FeeDescription[]> = {
    deposit: createDenominationPairTimeline(selected.feesDescription.deposit, original.feesDescription.deposit),
    refresh: createDenominationPairTimeline(selected.feesDescription.refresh, original.feesDescription.refresh),
    refund: createDenominationPairTimeline(selected.feesDescription.refund, original.feesDescription.refund),
    withdraw: createDenominationPairTimeline(selected.feesDescription.withdraw, original.feesDescription.withdraw),
  }

  return {
    status: "comparing",
    exchanges: {
      list: exchangeMap,
      value: value,
      onChange: async (v) => {
        setValue(v)
      }
    },
    error: undefined,
    onReset: {
      onClick: async () => {
        setValue(String(initialValue))
      }
    },
    onSelect: {
      onClick: async () => {
        onSelection(selected.exchangeBaseUrl)
      }
    },
    selected,
    pairTimeline,
  }

}