import { Buffer } from 'buffer'
import { BN, Program, web3 } from '@project-serum/anchor'

export const Magic = 0xa1b2c3d4
export const Version1 = 1
export const Version = Version1
export const PriceStatus = ['Unknown', 'Trading', 'Halted', 'Auction']
export const CorpAction = ['NoCorpAct']
export const PriceType = ['Unknown', 'Price', 'TWAP', 'Volatility']

const empty32Buffer = Buffer.alloc(32)
const PKorNull = (data: Buffer) => (data.equals(empty32Buffer) ? null : new web3.PublicKey(data))

interface ICreatePriceFeed {
  oracleProgram: Program
  initPrice: number
  confidence?: BN
  expo?: number
}
export const createPriceFeed = async ({
  oracleProgram,
  initPrice,
  confidence,
  expo = -4,
}: ICreatePriceFeed) => {
  const conf = confidence || new BN((initPrice / 10) * 10 ** -expo)
  const collateralTokenFeed = new web3.Account()
  await oracleProgram.rpc.initialize(new BN(initPrice * 10 ** -expo), expo, conf, {
    accounts: { price: collateralTokenFeed.publicKey },
    signers: [collateralTokenFeed],
    instructions: [
      web3.SystemProgram.createAccount({
        fromPubkey: oracleProgram.provider.wallet.publicKey,
        newAccountPubkey: collateralTokenFeed.publicKey,
        space: 3312,
        lamports: await oracleProgram.provider.connection.getMinimumBalanceForRentExemption(3312),
        programId: oracleProgram.programId,
      }),
    ],
  })
  return collateralTokenFeed.publicKey
}
export const setFeedPrice = async (
  oracleProgram: Program,
  newPrice: number,
  priceFeed: web3.PublicKey
) => {
  const info = await oracleProgram.provider.connection.getAccountInfo(priceFeed)
  const data = parsePriceData(info.data)
  await oracleProgram.rpc.setPrice(new BN(newPrice * 10 ** -data.exponent), {
    accounts: { price: priceFeed },
  })
}
export const getFeedData = async (oracleProgram: Program, priceFeed: web3.PublicKey) => {
  const info = await oracleProgram.provider.connection.getAccountInfo(priceFeed)
  return parsePriceData(info.data)
}

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/errors.js#L758
const ERR_BUFFER_OUT_OF_BOUNDS = () => new Error('Attempt to access memory outside buffer bounds')

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/errors.js#L968
const ERR_INVALID_ARG_TYPE = (name: string, expected: string, actual: any) =>
  new Error(`The "${name}" argument must be of type ${expected}. Received ${actual}`)

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/errors.js#L1262
const ERR_OUT_OF_RANGE = (str: string, range: string, received: number) =>
  new Error(`The value of "${str} is out of range. It must be ${range}. Received ${received}`)

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/validators.js#L127-L130
function validateNumber(value: any, name: string) {
  if (typeof value !== 'number') throw ERR_INVALID_ARG_TYPE(name, 'number', value)
}

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/buffer.js#L68-L80
function boundsError(value: number, length: number) {
  if (Math.floor(value) !== value) {
    validateNumber(value, 'offset')
    throw ERR_OUT_OF_RANGE('offset', 'an integer', value)
  }

  if (length < 0) throw ERR_BUFFER_OUT_OF_BOUNDS()

  throw ERR_OUT_OF_RANGE('offset', `>= 0 and <= ${length}`, value)
}

export function readBigInt64LE(buffer: Buffer, offset = 0): bigint {
  validateNumber(offset, 'offset')
  const first = buffer[offset]
  const last = buffer[offset + 7]
  if (first === undefined || last === undefined) boundsError(offset, buffer.length - 8)
  const val =
    buffer[offset + 4] + buffer[offset + 5] * 2 ** 8 + buffer[offset + 6] * 2 ** 16 + (last << 24) // Overflow
  return (
    (BigInt(val) << BigInt(32)) +
    BigInt(
      first + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + buffer[++offset] * 2 ** 24
    )
  )
}

// https://github.com/nodejs/node/blob/v14.17.0/lib/internal/buffer.js#L89-L107
export function readBigUInt64LE(buffer: Buffer, offset = 0): bigint {
  validateNumber(offset, 'offset')
  const first = buffer[offset]
  const last = buffer[offset + 7]
  if (first === undefined || last === undefined) boundsError(offset, buffer.length - 8)

  const lo =
    first + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + buffer[++offset] * 2 ** 24

  const hi =
    buffer[++offset] + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + last * 2 ** 24

  return BigInt(lo) + (BigInt(hi) << BigInt(32)) // tslint:disable-line:no-bitwise
}

export const parsePriceData = (data: Buffer) => {
  // Pyth magic number.
  const magic = data.readUInt32LE(0)
  // Program version.
  const version = data.readUInt32LE(4)
  // Account type.
  const type = data.readUInt32LE(8)
  // Price account size.
  const size = data.readUInt32LE(12)
  // Price or calculation type.
  const priceType = data.readUInt32LE(16)
  // Price exponent.
  const exponent = data.readInt32LE(20)
  // Number of component prices.
  const numComponentPrices = data.readUInt32LE(24)
  // unused
  // const unused = accountInfo.data.readUInt32LE(28)
  // Currently accumulating price slot.
  const currentSlot = readBigUInt64LE(data, 32)
  // Valid on-chain slot of aggregate price.
  const validSlot = readBigUInt64LE(data, 40)
  // Time-weighted average price.
  const twapComponent = readBigInt64LE(data, 48)
  const twap = Number(twapComponent) * 10 ** exponent
  // Annualized price volatility.
  const avolComponent = readBigUInt64LE(data, 56)
  const avol = Number(avolComponent) * 10 ** exponent
  // Space for future derived values.
  const drv0Component = readBigInt64LE(data, 64)
  const drv0 = Number(drv0Component) * 10 ** exponent
  const drv1Component = readBigInt64LE(data, 72)
  const drv1 = Number(drv1Component) * 10 ** exponent
  const drv2Component = readBigInt64LE(data, 80)
  const drv2 = Number(drv2Component) * 10 ** exponent
  const drv3Component = readBigInt64LE(data, 88)
  const drv3 = Number(drv3Component) * 10 ** exponent
  const drv4Component = readBigInt64LE(data, 96)
  const drv4 = Number(drv4Component) * 10 ** exponent
  const drv5Component = readBigInt64LE(data, 104)
  const drv5 = Number(drv5Component) * 10 ** exponent
  // Product id / reference account.
  const productAccountKey = new web3.PublicKey(data.slice(112, 144))
  // Next price account in list.
  const nextPriceAccountKey = PKorNull(data.slice(144, 176))
  // Aggregate price updater.
  const aggregatePriceUpdaterAccountKey = new web3.PublicKey(data.slice(176, 208))
  const aggregatePriceInfo = parsePriceInfo(data.slice(208, 240), exponent)
  // Price components - up to 32.
  const priceComponents = []
  let offset = 240
  let shouldContinue = true
  while (offset < data.length && shouldContinue) {
    const publisher = PKorNull(data.slice(offset, offset + 32))
    offset += 32
    if (publisher) {
      const aggregate = parsePriceInfo(data.slice(offset, offset + 32), exponent)
      offset += 32
      const latest = parsePriceInfo(data.slice(offset, offset + 32), exponent)
      offset += 32
      priceComponents.push({ publisher, aggregate, latest })
    } else {
      shouldContinue = false
    }
  }
  return {
    magic,
    version,
    type,
    size,
    priceType,
    exponent,
    numComponentPrices,
    currentSlot,
    validSlot,
    twapComponent,
    twap,
    avolComponent,
    avol,
    drv0Component,
    drv0,
    drv1Component,
    drv1,
    drv2Component,
    drv2,
    drv3Component,
    drv3,
    drv4Component,
    drv4,
    drv5Component,
    drv5,
    productAccountKey,
    nextPriceAccountKey,
    aggregatePriceUpdaterAccountKey,
    ...aggregatePriceInfo,
    priceComponents,
  }
}

interface ProductAttributes {
  [index: string]: string
}

export const parseProductData = (data: Buffer) => {
  // Pyth magic number.
  const magic = data.readUInt32LE(0)
  // Program version.
  const version = data.readUInt32LE(4)
  // Account type.
  const type = data.readUInt32LE(8)
  // Price account size.
  const size = data.readUInt32LE(12)
  // First price account in list.
  const priceAccountBytes = data.slice(16, 48)
  const priceAccountKey = new web3.PublicKey(priceAccountBytes)
  const product: ProductAttributes = {}
  let idx = 48
  while (idx < data.length) {
    const keyLength = data[idx]
    idx++
    if (keyLength) {
      const key = data.slice(idx, idx + keyLength).toString()
      idx += keyLength
      const valueLength = data[idx]
      idx++
      const value = data.slice(idx, idx + valueLength).toString()
      idx += valueLength
      product[key] = value
    }
  }
  return { magic, version, type, size, priceAccountKey, product }
}

const parsePriceInfo = (data: Buffer, exponent: number) => {
  // Aggregate price.
  const priceComponent = data.readBigUInt64LE(0)
  const price = Number(priceComponent) * 10 ** exponent
  // Aggregate confidence.
  const confidenceComponent = data.readBigUInt64LE(8)
  const confidence = Number(confidenceComponent) * 10 ** exponent
  // Aggregate status.
  const status = data.readUInt32LE(16)
  // Aggregate corporate action.
  const corporateAction = data.readUInt32LE(20)
  // Aggregate publish slot.
  const publishSlot = data.readBigUInt64LE(24)
  return {
    priceComponent,
    price,
    confidenceComponent,
    confidence,
    status,
    corporateAction,
    publishSlot,
  }
}