import { fromHex, type Chain, type Client, type Transport } from "viem";
import type {
  GetEntryPointFromAccount,
  SmartContractAccount,
} from "../../account/smartContractAccount";
import { isBaseSmartAccountClient } from "../../client/isSmartAccountClient.js";
import { AccountNotFoundError } from "../../errors/account.js";
import { IncompatibleClientError } from "../../errors/client.js";
import { TransactionMissingToParamError } from "../../errors/transaction.js";
import type { UserOperationOverrides } from "../../types";
import { bigIntMax } from "../../utils/index.js";
import { buildUserOperation } from "./buildUserOperation.js";
import type {
  BuildTransactionParameters,
  BuildUserOperationFromTransactionsResult,
  UserOperationContext,
} from "./types";
import { clientHeaderTrack } from "../../index.js";

/**
 * Performs `buildUserOperationFromTx` in batch and builds into a single,
 * yet to be signed `UserOperation` (UO) struct. The output user operation struct
 * will be filled with all gas fields (and paymaster data if a paymaster is used)
 * based on the transactions data (`to`, `data`, `value`, `maxFeePerGas`,
 * `maxPriorityFeePerGas`) computed using the configured ClientMiddlewares on the SmartAccountClient.
 *
 * @example
 * ```ts
 * import type { RpcTransactionRequest } from "viem";
 * import { smartAccountClient } from "./smartAccountClient";
 *
 * const requests: RpcTransactionRequest[] = [
 *   {
 *     from, // ignored
 *     to,
 *     data: encodeFunctionData({
 *       abi: ContractABI.abi,
 *       functionName: "func",
 *       args: [arg1, arg2, ...],
 *     }),
 *   },
 *   {
 *     from, // ignored
 *     to,
 *     data: encodeFunctionData({
 *       abi: ContractABI.abi,
 *       functionName: "func",
 *       args: [arg1, arg2, ...],
 *     }),
 *   },
 * ];
 * const uoStruct = await smartAccountClient.buildUserOperationFromTxs({
 *   requests,
 * });
 *
 * // signUserOperation signs the above unsigned user operation struct built
 * // using the account connected to the smart account client
 * const request = await smartAccountClient.signUserOperation({ uoStruct });
 *
 * // You can use the BundlerAction `sendRawUserOperation` (packages/core/src/actions/bundler/sendRawUserOperation.ts)
 * // to send the signed user operation request to the bundler, requesting the bundler to send the signed uo to the
 * // EntryPoint contract pointed at by the entryPoint address parameter
 * const entryPointAddress = client.account.getEntryPoint().address;
 * const uoHash = await smartAccountClient.sendRawUserOperation({
 *   request,
 *   entryPoint: entryPointAddress,
 * });
 * ```
 *
 * @param {Client<TTransport, TChain, TAccount>} client_ the smart account client to use to make RPC calls
 * @param {BuildTransactionParameters} args  an object containing the requests to build as well as, the account if not hoisted, the context, the overrides, and optionally a flag to enable signing of the UO via the underlying middleware
 * @returns {Promise<BuildUserOperationFromTransactionsResult<TEntryPointVersion>>} a Promise containing the built user operation
 */
export async function buildUserOperationFromTxs<
  TTransport extends Transport = Transport,
  TChain extends Chain | undefined = Chain | undefined,
  TAccount extends SmartContractAccount | undefined =
    | SmartContractAccount
    | undefined,
  TEntryPointVersion extends
    GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>,
  TContext extends UserOperationContext | undefined =
    | UserOperationContext
    | undefined,
>(
  client_: Client<TTransport, TChain, TAccount>,
  args: BuildTransactionParameters<TAccount, TContext, TEntryPointVersion>,
): Promise<BuildUserOperationFromTransactionsResult<TEntryPointVersion>> {
  const client = clientHeaderTrack(client_, "buildUserOperationFromTxs");
  const { account = client.account, requests, overrides, context } = args;
  if (!account) {
    throw new AccountNotFoundError();
  }

  if (!isBaseSmartAccountClient(client)) {
    throw new IncompatibleClientError(
      "BaseSmartAccountClient",
      "buildUserOperationFromTxs",
      client,
    );
  }

  const batch = requests.map((request) => {
    if (!request.to) {
      throw new TransactionMissingToParamError();
    }

    return {
      target: request.to,
      data: request.data ?? "0x",
      value: request.value ? fromHex(request.value, "bigint") : 0n,
    };
  });

  const mfpgOverridesInTx = () =>
    requests
      .filter((x) => x.maxFeePerGas != null)
      .map((x) => fromHex(x.maxFeePerGas!, "bigint"));
  const maxFeePerGas =
    overrides?.maxFeePerGas != null
      ? overrides?.maxFeePerGas
      : mfpgOverridesInTx().length > 0
        ? bigIntMax(...mfpgOverridesInTx())
        : undefined;

  const mpfpgOverridesInTx = () =>
    requests
      .filter((x) => x.maxPriorityFeePerGas != null)
      .map((x) => fromHex(x.maxPriorityFeePerGas!, "bigint"));
  const maxPriorityFeePerGas =
    overrides?.maxPriorityFeePerGas != null
      ? overrides?.maxPriorityFeePerGas
      : mpfpgOverridesInTx().length > 0
        ? bigIntMax(...mpfpgOverridesInTx())
        : undefined;

  const _overrides = {
    maxFeePerGas,
    maxPriorityFeePerGas,
  } as UserOperationOverrides<TEntryPointVersion>;

  const uoStruct = await buildUserOperation(client, {
    uo: batch,
    account,
    context,
    overrides: _overrides,
  });

  return {
    uoStruct,
    // TODO: in v4 major version update, remove these as below parameters are not needed
    batch,
    overrides: _overrides,
  };
}