import { create } from "zustand";
import { Asset, SupportedAssets } from "@gardenfi/orderbook";
import { ErrorFormat, Errors } from "../constants/errors";
import { IOType } from "../constants/constants";

export type SwapErrors = {
  inputError?: ErrorFormat;
  outputError?: ErrorFormat;
  liquidityError?: ErrorFormat;
  insufficientBalanceError?: ErrorFormat;
};

type SwapState = {
  inputAsset?: Asset;
  outputAsset?: Asset;
  inputAmount: string;
  outputAmount: string;
  btcAddress: string;
  showBtcAddress: boolean;
  error: SwapErrors;
  loading: boolean;
  fetching: boolean;
  strategy: string;
  setStrategy: (strategy: string) => void;
  setAsset: (ioType: IOType, asset: Asset | undefined) => void;
  setAmount: (ioType: IOType, amount: string) => void;
  setBtcAddress: (btcAddress: string) => void;
  setShowBtcAddress: (showBtcAddress: boolean) => void;
  setLoading: (loading: boolean) => void;
  setFetching: (fetching: boolean) => void;
  swapAssets: () => void;
  setError: (error: SwapErrors) => void;
}

export const swapStore = create<SwapState>((set) => ({
  inputAsset: SupportedAssets.testnet.starknet_testnet_WBTC,
  inputAmount: "",
  outputAmount: "",
  btcAddress: "",
  showBtcAddress: false,
  strategy: "",
  error: {
    inputError: Errors.none,
    outputError: Errors.none,
    liquidityError: Errors.none,
    insufficientBalanceError: Errors.none,
  },
  loading: false,
  fetching: false,
  setAsset: (ioType, asset) => {
    set((state) => ({
      ...state,
      [ioType === IOType.input ? "inputAsset" : "outputAsset"]: asset,
    }));
  },
  setAmount: (ioType, amount) => {
    set((state) => ({
      ...state,
      [ioType === IOType.input ? "inputAmount" : "outputAmount"]: amount,
    }));
  },
  setBtcAddress: (btcAddress) => {
    set((state) => ({
      ...state,
      btcAddress,
    }));
  },
  swapAssets: () => {
    set((state) => {
      return {
        ...state,
        inputAsset: state.outputAsset,
        outputAsset: state.inputAsset,
        error: {
          ...state.error,
          inputError: Errors.none,
          outputError: Errors.none,
          liquidityError: Errors.none,
          insufficientBalanceError: Errors.none,
        },
      };
    });
  },
  setStrategy: (strategy) => {
    set({ strategy });
  },
  setError: (error) => {
    set((state) => ({ error: { ...state.error, ...error } }));
  },
  setLoading: (loading) => set({ loading }),
  setFetching: (fetching) => set({ fetching }),
  setShowBtcAddress: (showBtcAddress) => set({ showBtcAddress }),
}));


// interface SwapState {
//   swapParams: SwapParams & { showBtcAddress: boolean };
//   inputAmount: string;
//   btcAddress: string;
//   errorMessage: SwapErrors;
//   loading: boolean;
//   isBtcToWbtc: boolean;
//   setSwapParams: (params: Partial<SwapState["swapParams"]>) => void;
//   setInputAmount: (amount: string) => void;
//   setBtcAddress: (address: string) => void;
//   setErrorMessage: (message: string | null) => void;
//   setLoading: (loading: boolean) => void;
//   toggleSwapDirection: () => void;
// }

// export const swapStore = create<SwapState>((set) => ({
//   swapParams: {
//     fromAsset: SupportedAssets.testnet.ethereum_sepolia_WBTC,
//     toAsset: SupportedAssets.testnet.bitcoin_testnet_BTC,
//     sendAmount: "0",
//     receiveAmount: "0",
//     additionalData: { strategyId: "" },
//     showBtcAddress: false,
//   },
//   inputAmount: "",
//   btcAddress: "",
//   errorMessage: null,
//   loading: false,
//   isBtcToWbtc: false,
//   setSwapParams: (params) =>
//     set((state) => ({
//       swapParams: { ...state.swapParams, ...params },
//     })),
//   setInputAmount: (amount) => set({ inputAmount: amount }),
//   setBtcAddress: (address) => set({ btcAddress: address }),
//   setErrorMessage: (message) => set({ errorMessage: message }),
//   setLoading: (loading) => set({ loading }),
//   toggleSwapDirection: () =>
//     set((state) => {
//       const { fromAsset, toAsset } = state.swapParams;
//       const newFromAsset = toAsset;
//       const newToAsset = fromAsset;

//       return {
//         isBtcToWbtc: !state.isBtcToWbtc,
//         inputAmount: "",
//         btcAddress: "",
//         swapParams: {
//           fromAsset: newFromAsset,
//           toAsset: newToAsset,
//           sendAmount: "0",
//           receiveAmount: "0",
//           additionalData: { strategyId: "" },
//           showBtcAddress: false,
//         },
//       };
//     }),
// }));