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 HeaderFields {
  sender: types.ForeignAddrFields
  id: BN
  inputTokens: Array<types.XTokenLocatorFields>
  outputTokens: Array<types.XTokenLocatorFields>
  operation: types.RaydiumOpCodeKind
  recipient: PublicKey | null
}

export interface HeaderJSON {
  sender: types.ForeignAddrJSON
  id: string
  inputTokens: Array<types.XTokenLocatorJSON>
  outputTokens: Array<types.XTokenLocatorJSON>
  operation: types.RaydiumOpCodeJSON
  recipient: string | null
}

export class Header {
  readonly sender: types.ForeignAddr
  readonly id: BN
  readonly inputTokens: Array<types.XTokenLocator>
  readonly outputTokens: Array<types.XTokenLocator>
  readonly operation: types.RaydiumOpCodeKind
  readonly recipient: PublicKey | null

  constructor(fields: HeaderFields) {
    this.sender = new types.ForeignAddr({ ...fields.sender })
    this.id = fields.id
    this.inputTokens = fields.inputTokens.map(
      (item) => new types.XTokenLocator({ ...item })
    )
    this.outputTokens = fields.outputTokens.map(
      (item) => new types.XTokenLocator({ ...item })
    )
    this.operation = fields.operation
    this.recipient = fields.recipient
  }

  static layout(property?: string) {
    return borsh.struct(
      [
        types.ForeignAddr.layout("sender"),
        borsh.u64("id"),
        borsh.vec(types.XTokenLocator.layout(), "inputTokens"),
        borsh.vec(types.XTokenLocator.layout(), "outputTokens"),
        types.RaydiumOpCode.layout("operation"),
        borsh.option(borsh.publicKey(), "recipient"),
      ],
      property
    )
  }

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  static fromDecoded(obj: any) {
    return new Header({
      sender: types.ForeignAddr.fromDecoded(obj.sender),
      id: obj.id,
      inputTokens: obj.inputTokens.map((item) =>
        types.XTokenLocator.fromDecoded(item)
      ),
      outputTokens: obj.outputTokens.map((item) =>
        types.XTokenLocator.fromDecoded(item)
      ),
      operation: types.RaydiumOpCode.fromDecoded(obj.operation),
      recipient: obj.recipient,
    })
  }

  static toEncodable(fields: HeaderFields) {
    return {
      sender: types.ForeignAddr.toEncodable(fields.sender),
      id: fields.id,
      inputTokens: fields.inputTokens.map((item) =>
        types.XTokenLocator.toEncodable(item)
      ),
      outputTokens: fields.outputTokens.map((item) =>
        types.XTokenLocator.toEncodable(item)
      ),
      operation: fields.operation.toEncodable(),
      recipient: fields.recipient,
    }
  }

  toJSON(): HeaderJSON {
    return {
      sender: this.sender.toJSON(),
      id: this.id.toString(),
      inputTokens: this.inputTokens.map((item) => item.toJSON()),
      outputTokens: this.outputTokens.map((item) => item.toJSON()),
      operation: this.operation.toJSON(),
      recipient: (this.recipient && this.recipient.toString()) || null,
    }
  }

  static fromJSON(obj: HeaderJSON): Header {
    return new Header({
      sender: types.ForeignAddr.fromJSON(obj.sender),
      id: new BN(obj.id),
      inputTokens: obj.inputTokens.map((item) =>
        types.XTokenLocator.fromJSON(item)
      ),
      outputTokens: obj.outputTokens.map((item) =>
        types.XTokenLocator.fromJSON(item)
      ),
      operation: types.RaydiumOpCode.fromJSON(obj.operation),
      recipient: (obj.recipient && new PublicKey(obj.recipient)) || null,
    })
  }

  toEncodable() {
    return Header.toEncodable(this)
  }
}