import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
import * as borsh from "@project-serum/borsh"

export interface InitializeJSON {
  kind: "Initialize"
}

export class Initialize {
  readonly discriminator = 0
  readonly kind = "Initialize"

  toJSON(): InitializeJSON {
    return {
      kind: "Initialize",
    }
  }

  toEncodable() {
    return {
      Initialize: {},
    }
  }
}

export interface AttestTokenJSON {
  kind: "AttestToken"
}

export class AttestToken {
  readonly discriminator = 1
  readonly kind = "AttestToken"

  toJSON(): AttestTokenJSON {
    return {
      kind: "AttestToken",
    }
  }

  toEncodable() {
    return {
      AttestToken: {},
    }
  }
}

export interface CompleteNativeJSON {
  kind: "CompleteNative"
}

export class CompleteNative {
  readonly discriminator = 2
  readonly kind = "CompleteNative"

  toJSON(): CompleteNativeJSON {
    return {
      kind: "CompleteNative",
    }
  }

  toEncodable() {
    return {
      CompleteNative: {},
    }
  }
}

export interface CompleteWrappedJSON {
  kind: "CompleteWrapped"
}

export class CompleteWrapped {
  readonly discriminator = 3
  readonly kind = "CompleteWrapped"

  toJSON(): CompleteWrappedJSON {
    return {
      kind: "CompleteWrapped",
    }
  }

  toEncodable() {
    return {
      CompleteWrapped: {},
    }
  }
}

export interface TransferWrappedJSON {
  kind: "TransferWrapped"
}

export class TransferWrapped {
  readonly discriminator = 4
  readonly kind = "TransferWrapped"

  toJSON(): TransferWrappedJSON {
    return {
      kind: "TransferWrapped",
    }
  }

  toEncodable() {
    return {
      TransferWrapped: {},
    }
  }
}

export interface TransferNativeJSON {
  kind: "TransferNative"
}

export class TransferNative {
  readonly discriminator = 5
  readonly kind = "TransferNative"

  toJSON(): TransferNativeJSON {
    return {
      kind: "TransferNative",
    }
  }

  toEncodable() {
    return {
      TransferNative: {},
    }
  }
}

export interface RegisterChainJSON {
  kind: "RegisterChain"
}

export class RegisterChain {
  readonly discriminator = 6
  readonly kind = "RegisterChain"

  toJSON(): RegisterChainJSON {
    return {
      kind: "RegisterChain",
    }
  }

  toEncodable() {
    return {
      RegisterChain: {},
    }
  }
}

export interface CreateWrappedJSON {
  kind: "CreateWrapped"
}

export class CreateWrapped {
  readonly discriminator = 7
  readonly kind = "CreateWrapped"

  toJSON(): CreateWrappedJSON {
    return {
      kind: "CreateWrapped",
    }
  }

  toEncodable() {
    return {
      CreateWrapped: {},
    }
  }
}

export interface UpgradeContractJSON {
  kind: "UpgradeContract"
}

export class UpgradeContract {
  readonly discriminator = 8
  readonly kind = "UpgradeContract"

  toJSON(): UpgradeContractJSON {
    return {
      kind: "UpgradeContract",
    }
  }

  toEncodable() {
    return {
      UpgradeContract: {},
    }
  }
}

export interface CompleteNativeWithPayloadJSON {
  kind: "CompleteNativeWithPayload"
}

export class CompleteNativeWithPayload {
  readonly discriminator = 9
  readonly kind = "CompleteNativeWithPayload"

  toJSON(): CompleteNativeWithPayloadJSON {
    return {
      kind: "CompleteNativeWithPayload",
    }
  }

  toEncodable() {
    return {
      CompleteNativeWithPayload: {},
    }
  }
}

export interface CompleteWrappedWithPayloadJSON {
  kind: "CompleteWrappedWithPayload"
}

export class CompleteWrappedWithPayload {
  readonly discriminator = 10
  readonly kind = "CompleteWrappedWithPayload"

  toJSON(): CompleteWrappedWithPayloadJSON {
    return {
      kind: "CompleteWrappedWithPayload",
    }
  }

  toEncodable() {
    return {
      CompleteWrappedWithPayload: {},
    }
  }
}

export interface TransferWrappedWithPayloadJSON {
  kind: "TransferWrappedWithPayload"
}

export class TransferWrappedWithPayload {
  readonly discriminator = 11
  readonly kind = "TransferWrappedWithPayload"

  toJSON(): TransferWrappedWithPayloadJSON {
    return {
      kind: "TransferWrappedWithPayload",
    }
  }

  toEncodable() {
    return {
      TransferWrappedWithPayload: {},
    }
  }
}

export interface TransferNativeWithPayloadJSON {
  kind: "TransferNativeWithPayload"
}

export class TransferNativeWithPayload {
  readonly discriminator = 12
  readonly kind = "TransferNativeWithPayload"

  toJSON(): TransferNativeWithPayloadJSON {
    return {
      kind: "TransferNativeWithPayload",
    }
  }

  toEncodable() {
    return {
      TransferNativeWithPayload: {},
    }
  }
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function fromDecoded(obj: any): types.TokenBridgeOperationsKind {
  if (typeof obj !== "object") {
    throw new Error("Invalid enum object")
  }

  if ("Initialize" in obj) {
    return new Initialize()
  }
  if ("AttestToken" in obj) {
    return new AttestToken()
  }
  if ("CompleteNative" in obj) {
    return new CompleteNative()
  }
  if ("CompleteWrapped" in obj) {
    return new CompleteWrapped()
  }
  if ("TransferWrapped" in obj) {
    return new TransferWrapped()
  }
  if ("TransferNative" in obj) {
    return new TransferNative()
  }
  if ("RegisterChain" in obj) {
    return new RegisterChain()
  }
  if ("CreateWrapped" in obj) {
    return new CreateWrapped()
  }
  if ("UpgradeContract" in obj) {
    return new UpgradeContract()
  }
  if ("CompleteNativeWithPayload" in obj) {
    return new CompleteNativeWithPayload()
  }
  if ("CompleteWrappedWithPayload" in obj) {
    return new CompleteWrappedWithPayload()
  }
  if ("TransferWrappedWithPayload" in obj) {
    return new TransferWrappedWithPayload()
  }
  if ("TransferNativeWithPayload" in obj) {
    return new TransferNativeWithPayload()
  }

  throw new Error("Invalid enum object")
}

export function fromJSON(
  obj: types.TokenBridgeOperationsJSON
): types.TokenBridgeOperationsKind {
  switch (obj.kind) {
    case "Initialize": {
      return new Initialize()
    }
    case "AttestToken": {
      return new AttestToken()
    }
    case "CompleteNative": {
      return new CompleteNative()
    }
    case "CompleteWrapped": {
      return new CompleteWrapped()
    }
    case "TransferWrapped": {
      return new TransferWrapped()
    }
    case "TransferNative": {
      return new TransferNative()
    }
    case "RegisterChain": {
      return new RegisterChain()
    }
    case "CreateWrapped": {
      return new CreateWrapped()
    }
    case "UpgradeContract": {
      return new UpgradeContract()
    }
    case "CompleteNativeWithPayload": {
      return new CompleteNativeWithPayload()
    }
    case "CompleteWrappedWithPayload": {
      return new CompleteWrappedWithPayload()
    }
    case "TransferWrappedWithPayload": {
      return new TransferWrappedWithPayload()
    }
    case "TransferNativeWithPayload": {
      return new TransferNativeWithPayload()
    }
  }
}

export function layout(property?: string) {
  const ret = borsh.rustEnum([
    borsh.struct([], "Initialize"),
    borsh.struct([], "AttestToken"),
    borsh.struct([], "CompleteNative"),
    borsh.struct([], "CompleteWrapped"),
    borsh.struct([], "TransferWrapped"),
    borsh.struct([], "TransferNative"),
    borsh.struct([], "RegisterChain"),
    borsh.struct([], "CreateWrapped"),
    borsh.struct([], "UpgradeContract"),
    borsh.struct([], "CompleteNativeWithPayload"),
    borsh.struct([], "CompleteWrappedWithPayload"),
    borsh.struct([], "TransferWrappedWithPayload"),
    borsh.struct([], "TransferNativeWithPayload"),
  ])
  if (property !== undefined) {
    return ret.replicate(property)
  }
  return ret
}