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 SuccessJSON {
  kind: "Success"
}

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

  toJSON(): SuccessJSON {
    return {
      kind: "Success",
    }
  }

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

export interface AbortedJSON {
  kind: "Aborted"
}

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

  toJSON(): AbortedJSON {
    return {
      kind: "Aborted",
    }
  }

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

export interface TargetProgramErroredJSON {
  kind: "TargetProgramErrored"
}

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

  toJSON(): TargetProgramErroredJSON {
    return {
      kind: "TargetProgramErrored",
    }
  }

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

export interface InconsistentPayloadsJSON {
  kind: "InconsistentPayloads"
}

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

  toJSON(): InconsistentPayloadsJSON {
    return {
      kind: "InconsistentPayloads",
    }
  }

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

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

  if ("Success" in obj) {
    return new Success()
  }
  if ("Aborted" in obj) {
    return new Aborted()
  }
  if ("TargetProgramErrored" in obj) {
    return new TargetProgramErrored()
  }
  if ("InconsistentPayloads" in obj) {
    return new InconsistentPayloads()
  }

  throw new Error("Invalid enum object")
}

export function fromJSON(obj: types.StatusJSON): types.StatusKind {
  switch (obj.kind) {
    case "Success": {
      return new Success()
    }
    case "Aborted": {
      return new Aborted()
    }
    case "TargetProgramErrored": {
      return new TargetProgramErrored()
    }
    case "InconsistentPayloads": {
      return new InconsistentPayloads()
    }
  }
}

export function layout(property?: string) {
  const ret = borsh.rustEnum([
    borsh.struct([], "Success"),
    borsh.struct([], "Aborted"),
    borsh.struct([], "TargetProgramErrored"),
    borsh.struct([], "InconsistentPayloads"),
  ])
  if (property !== undefined) {
    return ret.replicate(property)
  }
  return ret
}