import {
  encodeFunctionData,
  type Account,
  type Hash,
  type SendTransactionParameters,
  type Transport,
} from 'viem'
import { sendTransaction } from 'viem/actions'
import type { ChainWithPns, ClientWithAccount } from '../../contracts/consts.js'
import { plsRegistrarControllerRegisterSnippet } from '../../contracts/plsRegistrarController.js'
import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
import { UnsupportedNameTypeError } from '../../errors/general.js'
import type {
  Prettify,
  SimpleTransactionRequest,
  WriteTransactionParameters,
} from '../../types.js'
import { getNameType } from '../../utils/getNameType.js'
import {
  makeRegistrationTuple,
  type RegistrationParameters,
} from '../../utils/registerHelpers.js'
import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'

export type RegisterNameDataParameters = RegistrationParameters & {
  /** Value of registration */
  value: bigint
}

export type RegisterNameDataReturnType = SimpleTransactionRequest & {
  value: bigint
}

export type RegisterNameParameters<
  TChain extends ChainWithPns,
  TAccount extends Account | undefined,
  TChainOverride extends ChainWithPns | undefined,
> = Prettify<
  RegisterNameDataParameters &
    WriteTransactionParameters<TChain, TAccount, TChainOverride>
>

export type RegisterNameReturnType = Hash

export const makeFunctionData = <
  TChain extends ChainWithPns,
  TAccount extends Account | undefined,
>(
  wallet: ClientWithAccount<Transport, TChain, TAccount>,
  { value, ...args }: RegisterNameDataParameters,
): RegisterNameDataReturnType => {
  const nameType = getNameType(args.name)
  if (nameType !== 'pls-2ld')
    throw new UnsupportedNameTypeError({
      nameType,
      supportedNameTypes: ['pls-2ld'],
      details: 'Only 2ld-pls name registration is supported',
    })

  const labels = args.name.split('.')
  wrappedLabelLengthCheck(labels[0])

  const tuple = makeRegistrationTuple(args)

  return {
    to: getChainContractAddress({
      client: wallet,
      contract: 'pnsPlsRegistrarController',
    }),
    data: encodeFunctionData({
      abi: plsRegistrarControllerRegisterSnippet,
      functionName: 'register',
      args: [{
        name: tuple[0],
        owner: tuple[1],
        duration: tuple[2],
        secret: tuple[3],
        resolver: tuple[4],
        data: tuple[5],
        reverseRecord: tuple[6],
        ownerControlledFuses: tuple[7],
        referrer: tuple[8]
      }],
    }),
    value,
  }
}

/**
 * Registers a name on PNS
 * @param wallet - {@link ClientWithAccount}
 * @param parameters - {@link RegisterNameParameters}
 * @returns Transaction hash. {@link RegisterNameReturnType}
 *
 * @example
 * import { createPublicClient, createWalletClient, http, custom } from 'viem'
 * import { mainnet } from 'viem/chains'
 * import { addPnsContracts } from '@pnsdomains/pnsjs'
 * import { getPrice } from '@pnsdomains/pnsjs/public'
 * import { randomSecret } from '@pnsdomains/pnsjs/utils'
 * import { commitName, registerName } from '@pnsdomains/pnsjs/wallet'
 *
 * const mainnetWithPns = addPnsContracts(mainnet)
 * const client = createPublicClient({
 *   chain: mainnetWithPns,
 *   transport: http(),
 * })
 * const wallet = createWalletClient({
 *   chain: mainnetWithPns,
 *   transport: custom(window.ethereum),
 * })
 * const secret = randomSecret()
 * const params = {
 *   name: 'example.pls',
 *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
 *   duration: 31536000, // 1 year
 *   secret,
 * }
 *
 * const commitmentHash = await commitName(wallet, params)
 * await client.waitForTransactionReceipt({ hash: commitmentHash }) // wait for commitment to finalise
 * await new Promise((resolve) => setTimeout(resolve, 60 * 1_000)) // wait for commitment to be valid
 *
 * const { base, premium } = await getPrice(client, { nameOrNames: params.name, duration: params.duration })
 * const value = (base + premium) * 110n / 100n // add 10% to the price for buffer
 * const hash = await registerName(wallet, { ...params, value })
 * // 0x...
 */
async function registerName<
  TChain extends ChainWithPns,
  TAccount extends Account | undefined,
  TChainOverride extends ChainWithPns | undefined = ChainWithPns,
>(
  wallet: ClientWithAccount<Transport, TChain, TAccount>,
  {
    name,
    owner,
    duration,
    secret,
    resolverAddress,
    records,
    reverseRecord,
    fuses,
    referrer,
    value,
    ...txArgs
  }: RegisterNameParameters<TChain, TAccount, TChainOverride>,
): Promise<RegisterNameReturnType> {
  const data = makeFunctionData(wallet, {
    name,
    owner,
    duration,
    secret,
    resolverAddress,
    records,
    reverseRecord,
    fuses,
    referrer,
    value,
  })
  const writeArgs = {
    ...data,
    ...txArgs,
  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
  return sendTransaction(wallet, writeArgs)
}

registerName.makeFunctionData = makeFunctionData

export default registerName