interface BlockDataResponse {
  id: string
  height: number
  version: number
  timestamp: number
  tx_count: number
  size: number
  weight: number
  merkle_root: string
  previousblockhash: string
  mediantime: number
  nonce: number
  bits: number
  difficulty: number
}

const blockData: BlockData = {
  version: blockDataResponse.version,
  previousBlockHash: blockDataResponse.previousblockhash,
  merkleRoot: blockDataResponse.merkle_root,
  timestamp: blockDataResponse.timestamp,
  bits: blockDataResponse.bits,
  nonce: blockDataResponse.nonce,
}

export const queryUrl = async <T>(url: string): Promise<T> => {
  const response = await fetch(url)
  await assertFetchResponse(response)
  return response.json()
}

export type BlockData = {
  version: number
  previousBlockHash: string
  merkleRoot: string
  timestamp: number
  bits: number
  nonce: number
}

export const getBlockHash = ({
  version,
  previousBlockHash,
  merkleRoot,
  timestamp,
  bits,
  nonce,
}: BlockData): string => {
  const header = Buffer.alloc(80)
  header.writeInt32LE(version, 0)
  Buffer.from(previousBlockHash, "hex").reverse().copy(header, 4)
  Buffer.from(merkleRoot, "hex").reverse().copy(header, 36)
  header.writeUInt32LE(timestamp, 68)
  header.writeUInt32LE(bits, 72)
  header.writeUInt32LE(nonce, 76)
  return bitcoinHash(header)
}

export const bitcoinHash = (data: Buffer): string =>
  sha256(sha256(data)).reverse().toString("hex")

type MineBlockInput = { blockData: Omit<BlockData, "nonce">; startNonce: number }
type MineBlockResult = { nonce: number; hash: string }

export const mineBlock = ({
  blockData,
  startNonce,
}: MineBlockInput): MineBlockResult => {
  let nonce = startNonce
  while (true) {
    const hash = getBlockHash({ ...blockData, nonce })
    if (checkDifficulty(hash, blockData.bits)) {
      return { nonce, hash }
    }
    nonce++
  }
}

export const checkDifficulty = (hash: string, bits: number): boolean => {
  const exponent = bits >> 24
  const coefficient = bits & 0x007fffff
  const targetBytes = Buffer.alloc(32).fill(0)

  const coefficientHex = coefficient.toString(16).padStart(6, "0")
  Buffer.from(coefficientHex, "hex").copy(
    targetBytes,
    32 - Math.floor(((exponent + 1) * 8) / 8),
  )

  const targetHex = targetBytes.toString("hex")
  return hash <= targetHex
}