import { Address, BigDecimal, ethereum } from '@graphprotocol/graph-ts'
import {
  Pool,
  PoolShares,
  PoolSnapshot,
  PoolTransaction
} from '../../@types/schema'
import { BPool } from '../../@types/templates/BPool/BPool'
import { DAY, decimal, PoolTransactionType } from './constants'
import { gweiToEth, weiToDecimal } from './generic'

export function getPoolSharesId(
  poolAddress: string,
  userAddress: string
): string {
  return `${poolAddress}-${userAddress}`
}

export function getPoolTransaction(
  event: ethereum.Event,
  userAddress: string,
  type: PoolTransactionType
): PoolTransaction {
  let poolTx = PoolTransaction.load(event.transaction.hash.toHex())

  // create pool transaction and fill basic fields
  if (poolTx === null) {
    poolTx = new PoolTransaction(event.transaction.hash.toHex())

    poolTx.user = userAddress
    poolTx.pool = event.address.toHex()
    poolTx.type = type

    poolTx.timestamp = event.block.timestamp.toI32()
    poolTx.tx = event.transaction.hash
    poolTx.block = event.block.number.toI32()

    poolTx.gasPrice = gweiToEth(event.transaction.gasPrice.toBigDecimal())
    poolTx.gasLimit = event.transaction.gasLimit.toBigDecimal()
  }

  return poolTx
}

export function getPoolShares(
  poolAddress: string,
  userAddress: string
): PoolShares {
  let poolShares = PoolShares.load(getPoolSharesId(poolAddress, userAddress))
  if (poolShares === null) {
    poolShares = new PoolShares(getPoolSharesId(poolAddress, userAddress))
  }
  return poolShares
}

export function getPool(poolAddress: string): Pool {
  const pool = Pool.load(poolAddress)
  if (pool === null) {
    // what now?
    throw new Error(`Didn't find pool with address ${poolAddress} `)
  }
  return pool
}

export function calcSpotPrice(
  poolAddress: string,
  baseTokenAddress: string,
  datatokenAddress: string,
  baseTokenDecimals: i32
): BigDecimal {
  const poolContract = BPool.bind(Address.fromString(poolAddress))
  // tokenIn is always the baseToken and tokenOut is the datatoken because we want the spot price to be in baseToken eg: 1 DT = 0.5 OCEAN
  const weiPrice = poolContract.try_getSpotPrice(
    Address.fromString(baseTokenAddress),
    Address.fromString(datatokenAddress)
  ).reverted
  const price = weiToDecimal(weiPrice, baseTokenDecimals)

  return price
}

export function getDateFromTimestamp(timestamp: i32): i32 {
  // date without time
  return timestamp - (timestamp % DAY)
}
export function getPoolSnapshotId(poolAddress: string, timestamp: i32): string {
  return `${poolAddress}-${getDateFromTimestamp(timestamp)}`
}

export function createPoolSnapshot(
  poolAddress: string,
  timestamp: i32
): PoolSnapshot {
  const snapshotId = getPoolSnapshotId(poolAddress, timestamp)

  const pool = Pool.load(poolAddress)
  const snapshot = new PoolSnapshot(snapshotId)

  snapshot.pool = poolAddress

  snapshot.totalShares = pool.totalShares
  snapshot.swapVolume = decimal.ZERO
  snapshot.swapFees = decimal.ZERO
  snapshot.baseToken = pool.baseToken
  //snapshot.baseTokenLiquidity = pool.baseToken
  snapshot.datatoken = pool.datatoken
  snapshot.datatokenLiquidity = decimal.ZERO

  snapshot.date = getDateFromTimestamp(timestamp)
  snapshot.spotPrice = pool.spotPrice

  snapshot.save()
  return snapshot
}

export function getPoolSnapshot(
  poolAddress: string,
  timestamp: i32
): PoolSnapshot {
  let snapshot = PoolSnapshot.load(getPoolSnapshotId(poolAddress, timestamp))
  if (snapshot === null) {
    snapshot = createPoolSnapshot(poolAddress, timestamp)
  }

  return snapshot
}

// export function updatePoolSnapshotToken(
//   poolAddress: string,
//   timestamp: i32,
//   poolTokenId: string,
//   amount: BigDecimal,
//   balance: BigDecimal,
//   feeValue: BigDecimal
// ): void {
//   log.warning('Start create Pool Snapshot Token: {}   {}', [
//     poolAddress,
//     timestamp.toString()
//   ])
//   const dayTimestamp = timestamp - (timestamp % DAY) // Todays timestamp

//   const snapshotId = poolAddress + '-' + dayTimestamp.toString()
//   log.warning('Pool Snapshot Token: {} {} {} {}', [
//     amount.toString(),
//     balance.toString(),
//     feeValue.toString(),
//     snapshotId + '-' + poolTokenId
//   ])
//   const token = new PoolSnapshotTokenValue(snapshotId + '-' + poolTokenId)

//   token.poolSnapshot = snapshotId
//   token.value = amount
//   token.tokenReserve = balance
//   token.tokenAddress = poolTokenId
//   token.feeValue = feeValue
//   if (amount.lt(ZERO_BD)) {
//     token.type = 'out'
//   } else {
//     token.type = 'in'
//   }
//   log.warning('Snapshot Token ID: {}', [token.id])
//   token.save()
// }