import type {
    EntryPoint,
    EntryPointVersion,
    GetEntryPointVersion
} from "permissionless/types"
import type { Address, Hex } from "viem"

export type PartialPick<T, K extends keyof T> = Partial<Pick<T, K>>

export type NonEmptyArray<T> = [T, ...T[]]

export type CAB_VERSION = "0.0.1" | "0.0.2" | "0.2.1"

export type AllTokens = "ETH" | "MATIC" | "USDC" | "6TEST" | "USDT"

export type CABToken = {
    chainId: number
    address: Address
}

export type CABVault = {
    chainId: number
    vaultAddress: Address
    tokenAddress: Address
}

export type SponsorTokenInfo = {
    amount: bigint
    address: Address
}

export type SwapTokenInfo = {
    router: Address
    tokenIn: Address
    tokenOut: Address
    amountIn: bigint
    amountOut: bigint
    approveAndSwapCalls: Call[]
}

export type RepayToken = {
    address: Address
    chainId: number
}
export type RepayTokenName = string

export type RepayTokens = RepayToken[] | RepayTokenName[]

export type RepayTokenInfo = {
    vault: Address
    amount: bigint
    chainId: number
}

export type Call = {
    to: Address
    data: Hex
    value: bigint
}

export type UserOperationWithBigIntAsHex<
    entryPointVersion extends EntryPointVersion
> = entryPointVersion extends "v0.6"
    ? {
          sender: Address
          nonce: Hex
          initCode: Hex
          callData: Hex
          callGasLimit: Hex
          verificationGasLimit: Hex
          preVerificationGas: Hex
          maxFeePerGas: Hex
          maxPriorityFeePerGas: Hex
          paymasterAndData: Hex
          signature: Hex
          factory?: never
          factoryData?: never
          paymaster?: never
          paymasterVerificationGasLimit?: never
          paymasterPostOpGasLimit?: never
          paymasterData?: never
      }
    : {
          sender: Address
          nonce: Hex
          factory: Address
          factoryData: Hex
          callData: Hex
          callGasLimit: Hex
          verificationGasLimit: Hex
          preVerificationGas: Hex
          maxFeePerGas: Hex
          maxPriorityFeePerGas: Hex
          paymaster: Address
          paymasterVerificationGasLimit: Hex
          paymasterPostOpGasLimit: Hex
          paymasterData: Hex
          signature: Hex
          initCode?: never
          paymasterAndData?: never
      }

export type GetRpcCabPaymasterAllTokensParameters =
    | []
    | [chainId: number | null]

export type GetRpcCabPaymasterAllTokensReturnType = {
    tokens: CABToken[]
}

export type GetRpcCabPaymasterAllVaultsParameters =
    | []
    | [chainId: number | null]
    | [chainId: number | null, token: Address | null]

export type GetRpcCabPaymasterAllVaultsReturnType = {
    vaults: CABVault[]
}

export type GetRpcCabPaymasterBalanceParameters = [
    address: Address,
    token?: AllTokens | AllTokens[] | null,
    repayTokens?: RepayToken[] | null
]

export type GetRpcCabPaymasterBalanceReturnType = Hex

export type GetRpcCabPaymasterSponsorTokensParameters<
    TEntryPoint extends EntryPoint
> = [
    userOperation: UserOperationWithBigIntAsHex<
        GetEntryPointVersion<TEntryPoint>
    >,
    entryPoint: TEntryPoint,
    sponsorChainId: number,
    paymaster: Address
]

export type GetRpcCabPaymasterSponsorTokensReturnType = {
    paymaster: Address
    sponsorTokensInfo: SponsorTokenInfo[]
    swapTokensInfo: SwapTokenInfo[]
    repayTokensInfo: RepayTokenInfo[]
}

export type GetRpcCabPaymasterStubDataParameters<
    TEntryPoint extends EntryPoint
> = [
    userOperation: UserOperationWithBigIntAsHex<
        GetEntryPointVersion<TEntryPoint>
    >,
    entryPoint: TEntryPoint,
    sponsorChainId: number,
    repayTokens: RepayTokens,
    paymaster: Address
]

export type GetRpcCabPaymasterStubDataReturnType<
    TEntryPoint extends EntryPoint
> = GetEntryPointVersion<TEntryPoint> extends "v0.6"
    ? {
          paymasterAndData: Hex
          repayTokensInfo: RepayTokenInfo[]
          preVerificationGas?: Hex
          verificationGasLimit?: Hex
          callGasLimit?: Hex
      }
    : {
          paymaster: Hex
          paymasterData: Hex
          repayTokensInfo: RepayTokenInfo[]
          preVerificationGas?: Hex
          verificationGasLimit?: Hex
          callGasLimit?: Hex
          paymasterVerificationGasLimit?: Hex
          paymasterPostOpGasLimit?: Hex
      }
export type GetRpcCabPaymasterDataParameters<TEntryPoint extends EntryPoint> = [
    userOperation: UserOperationWithBigIntAsHex<
        GetEntryPointVersion<TEntryPoint>
    >,
    entryPoint: TEntryPoint,
    sponsorChainId: number,
    depreciatedRepayTokens: unknown,
    paymaster: Address
]

export type GetRpcCabPaymasterDataReturnType<TEntryPoint extends EntryPoint> =
    GetEntryPointVersion<TEntryPoint> extends "v0.6"
        ? {
              paymasterAndData: Hex
          }
        : {
              paymaster: Hex
              paymasterData: Hex
          }

export type CabPaymasterRpcScheme<TEntryPoint extends EntryPoint> = [
    {
        Method: "pm_getCabAllTokens"
        Parameters: GetRpcCabPaymasterAllTokensParameters
        ReturnType: GetRpcCabPaymasterAllTokensReturnType
    },
    {
        Method: "pm_getCabAllVaults"
        Parameters: GetRpcCabPaymasterAllVaultsParameters
        ReturnType: GetRpcCabPaymasterAllVaultsReturnType
    },
    {
        Method: "pm_getCabBalance"
        Parameters: GetRpcCabPaymasterBalanceParameters
        ReturnType: GetRpcCabPaymasterBalanceReturnType
    },
    {
        Method: "pm_getCabPaymasterSponsorTokens"
        Parameters: GetRpcCabPaymasterSponsorTokensParameters<TEntryPoint>
        ReturnType: GetRpcCabPaymasterSponsorTokensReturnType
    },
    {
        Method: "pm_getCabPaymasterStubData"
        Parameters: GetRpcCabPaymasterStubDataParameters<TEntryPoint>
        ReturnType: GetRpcCabPaymasterStubDataReturnType<TEntryPoint>
    },
    {
        Method: "pm_getCabPaymasterData"
        Parameters: GetRpcCabPaymasterDataParameters<TEntryPoint>
        ReturnType: GetRpcCabPaymasterDataReturnType<TEntryPoint>
    }
]

export type StateOverrides = {
    [x: string]: {
        balance?: bigint | undefined
        nonce?: bigint | number | undefined
        code?: Hex | undefined
        state?: {
            [x: Hex]: Hex
        }
        stateDiff?: {
            [x: Hex]: Hex
        }
    }
}