import { BufferReader } from "../buffer/BufferReader"
import { BufferWriter } from "../buffer/BufferWriter"
import {BN} from "../crypto/BN"

export namespace BlockHeader {
    /**
     * @typedef {Object} BlockHeader.fromObjectParams
     * @property {(string)} string
     * @property {number} version
     * @property {(string|Buffer|ArrayBuffer|SharedArrayBuffer)} prevHash
     * @property {(string|Buffer)} merkleRoot
     * @property {number} time
     * @property {number} bits
     * @property {number} nonce
     */
    type fromObjectParams = {
        hash: string;
        version: number;
        prevHash: string|Buffer;
        merkleRoot: string|Buffer;
        time: number;
        bits: number;
        nonce: number;
    };
    /**
     * @typedef {Object} BlockHeader.toObjectParams
     * @property {(string)} string
     * @property {number} version
     * @property {(string)} prevHash
     * @property {(string)} merkleRoot
     * @property {number} time
     * @property {number} bits
     * @property {number} nonce
     */
    type toObjectParams = {
        hash: string;
        version: number;
        prevHash: string;
        merkleRoot: string;
        time: number;
        bits: number;
        nonce: number;
    };
}

/**
 * Instantiate a BlockHeader from a Buffer, JSON object, or Object with
 * the properties of the BlockHeader
 *
 * @param {Buffer|BlockHeader.fromObjectParams} - A Buffer, JSON string, or Object
 * @returns {BlockHeader} - An instance of block header
 * @constructor
 */
export class BlockHeader {
    constructor();

    id: string;
    hash: string;
    version: number;
    prevHash: string|Buffer;
    merkleRoot: string|Buffer;
    time: number;
    bits: number;
    nonce: number;

    /**
     * @param {BlockHeader.fromObjectParams} obj - A plain JavaScript object
     * @returns {BlockHeader} - An instance of block header
     */
    static fromObject(obj: BlockHeader.fromObjectParams): BlockHeader;

    /**
     * @param {Buffer|string} data Raw block binary data or buffer
     * @returns {BlockHeader} - An instance of block header
     */
    static fromRawBlock(data: Buffer | string): BlockHeader;

    /**
     * @param {Buffer} buf - A buffer of the block header
     * @returns {BlockHeader} - An instance of block header
     */
    static fromBuffer(buf: Buffer): BlockHeader;

    /**
     * @param {string} str - A hex encoded buffer of the block header
     * @returns {BlockHeader} - An instance of block header
     */
    static fromString(str: string): BlockHeader;

    /**
     * @param {BufferReader} br - A BufferReader of the block header
     * @returns {BlockHeader} - An instance of block header
     */
    static fromBufferReader(br: BufferReader): BlockHeader;

    /**
     * @function
     * @returns {Object} - A plain object of the BlockHeader
     */
    toObject(): any;

    /**
     * @function
     * @returns {Object} - A plain object of the BlockHeader
     */
    toJSON(): any;

    /**
     * @returns {Buffer} - A Buffer of the BlockHeader
     */
    toBuffer(): Buffer;

    /**
     * @returns {string} - A hex encoded string of the BlockHeader
     */
    toString(): string;

    /**
     * @param {BufferWriter} bw - An existing instance BufferWriter
     * @returns {BufferWriter} - An instance of BufferWriter representation of the BlockHeader
     */
    toBufferWriter(bw: BufferWriter): BufferWriter;

    /**
     * Returns the target difficulty for this block
     * @param {Number} bits
     * @returns {BN} An instance of BN with the decoded difficulty bits
     */
    getTargetDifficulty(bits: number): BN;

    /**
     * @link https://en.bitcoin.it/wiki/Difficulty
     * @return {Number}
     */
    getDifficulty(): number;

    /**
     * @returns {Buffer} - The little endian hash buffer of the header
     */
    _getHash(): Buffer;

    /**
     * @returns {Boolean} - If timestamp is not too far in the future
     */
    validTimestamp(): boolean;

    /**
     * @returns {Boolean} - If the proof-of-work hash satisfies the target difficulty
     */
    validProofOfWork(): boolean;

    /**
     * @returns {string} - A string formatted for the console
     */
    inspect(): string;
}