import { ContractPromise } from '@polkadot/api-contract';
import { ContractOptions } from '@polkadot/api-contract/types';
import { useMemo, useState } from 'react';
import { DecodedContractTxResult } from '../../types/contracts.js';
import { SignerOptions } from '../../types/mod.js';
import { call } from '../../utils/mod.js';
import { useAbiMessage } from './useAbiMessage.js';
import { useExtension } from '../useExtension.js';

export type DryRunResult<T> = DecodedContractTxResult<T>;

export type Send<T> = (
  args?: unknown[],
  o?: ContractOptions,
  signerOptions?: SignerOptions,
) => Promise<DryRunResult<T> | undefined>;

interface DryRun<T> {
  send: Send<T>;
  isSubmitting: boolean;
  result?: DryRunResult<T>;
  resolved: Boolean;
  resetState: () => void;
}

export function useDryRun<T>(
  contract: ContractPromise | undefined,
  message: string,
): DryRun<T> {
  const { account, extension } = useExtension();
  const [result, setResult] = useState<DecodedContractTxResult<T>>();
  const [isSubmitting, setIsSubmitting] = useState(false);
  const abiMessage = useAbiMessage(contract, message);

  const send: Send<T> = useMemo(
    () => async (params, options) => {
      const tx = contract?.tx?.[message];
      if (!account || !contract || !extension || !abiMessage || !tx) return;

      setIsSubmitting(true);

      try {
        const resp = await call<T>(
          contract,
          abiMessage,
          account.address,
          params,
          options,
        );

        if (!resp || !resp.ok) return;

        const { gasConsumed, gasRequired, storageDeposit } = resp.value.raw;

        const requiresNoArguments = tx.meta.args.length === 0;
        const { partialFee } = await (requiresNoArguments
          ? tx(options || {})
          : tx(options || {}, params))
          .paymentInfo(account.address);

        const r = {
          ...resp,
          value: {
            ...resp.value,
            gasRequired,
            gasConsumed,
            storageDeposit,
            partialFee,
          },
        };

        setIsSubmitting(false);
        setResult(r);

        return r;
      } catch (e: unknown) {
        console.error(e);
        setIsSubmitting(false);
        return;
      }
    },
    [account, extension, contract, abiMessage],
  );

  return {
    send,
    isSubmitting,
    result,
    resolved: Boolean(result && !isSubmitting),
    resetState: () => {
      setIsSubmitting(false);
      setResult(undefined);
    },
  };
}