import { address, Address } from "@solana/kit" // 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 "@coral-xyz/borsh"
import { borshAddress } from "../utils"

export interface OpenPositionOrIncreaseLiquidityJSON {
  kind: "OpenPositionOrIncreaseLiquidity"
}

export class OpenPositionOrIncreaseLiquidity {
  static readonly discriminator = 0
  static readonly kind = "OpenPositionOrIncreaseLiquidity"
  readonly discriminator = 0
  readonly kind = "OpenPositionOrIncreaseLiquidity"

  toJSON(): OpenPositionOrIncreaseLiquidityJSON {
    return {
      kind: "OpenPositionOrIncreaseLiquidity",
    }
  }

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

export interface DecreaseLiquidityJSON {
  kind: "DecreaseLiquidity"
}

export class DecreaseLiquidity {
  static readonly discriminator = 1
  static readonly kind = "DecreaseLiquidity"
  readonly discriminator = 1
  readonly kind = "DecreaseLiquidity"

  toJSON(): DecreaseLiquidityJSON {
    return {
      kind: "DecreaseLiquidity",
    }
  }

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

export interface CollectFeeJSON {
  kind: "CollectFee"
}

export class CollectFee {
  static readonly discriminator = 2
  static readonly kind = "CollectFee"
  readonly discriminator = 2
  readonly kind = "CollectFee"

  toJSON(): CollectFeeJSON {
    return {
      kind: "CollectFee",
    }
  }

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

export interface CollectRewardJSON {
  kind: "CollectReward"
}

export class CollectReward {
  static readonly discriminator = 3
  static readonly kind = "CollectReward"
  readonly discriminator = 3
  readonly kind = "CollectReward"

  toJSON(): CollectRewardJSON {
    return {
      kind: "CollectReward",
    }
  }

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

export interface SwapJSON {
  kind: "Swap"
}

export class Swap {
  static readonly discriminator = 4
  static readonly kind = "Swap"
  readonly discriminator = 4
  readonly kind = "Swap"

  toJSON(): SwapJSON {
    return {
      kind: "Swap",
    }
  }

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

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

  if ("OpenPositionOrIncreaseLiquidity" in obj) {
    return new OpenPositionOrIncreaseLiquidity()
  }
  if ("DecreaseLiquidity" in obj) {
    return new DecreaseLiquidity()
  }
  if ("CollectFee" in obj) {
    return new CollectFee()
  }
  if ("CollectReward" in obj) {
    return new CollectReward()
  }
  if ("Swap" in obj) {
    return new Swap()
  }

  throw new Error("Invalid enum object")
}

export function fromJSON(
  obj: types.PoolStatusBitIndexJSON
): types.PoolStatusBitIndexKind {
  switch (obj.kind) {
    case "OpenPositionOrIncreaseLiquidity": {
      return new OpenPositionOrIncreaseLiquidity()
    }
    case "DecreaseLiquidity": {
      return new DecreaseLiquidity()
    }
    case "CollectFee": {
      return new CollectFee()
    }
    case "CollectReward": {
      return new CollectReward()
    }
    case "Swap": {
      return new Swap()
    }
  }
}

export function layout(property?: string) {
  const ret = borsh.rustEnum([
    borsh.struct([], "OpenPositionOrIncreaseLiquidity"),
    borsh.struct([], "DecreaseLiquidity"),
    borsh.struct([], "CollectFee"),
    borsh.struct([], "CollectReward"),
    borsh.struct([], "Swap"),
  ])
  if (property !== undefined) {
    return ret.replicate(property)
  }
  return ret
}