const blockHash = "0000000000000000000266819fe415c51f9c025e1059b4c1332c1033236166f0";

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,
}

const computedHash = getBlockHash(blockData);
console.log("Computed block hash:", computedHash);
console.log("Actual block hash: ", blockHash);
console.log("Hash verification:", computedHash === blockHash ? "Valid ✅" : "Invalid ❌");

const miningResult = mineBlock({
  blockData: omit(blockData, "nonce"),
  startNonce: blockData.nonce - 20,
});
console.log("Mining completed!");
console.log("Found valid hash:", miningResult.hash);
console.log("Nonce used:", miningResult.nonce);

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")

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;
}