import {Address} from "../Address"
import {Network} from "../Network"
import {PublicKey} from "../PublicKey"
import {Signature} from "../crypto/Signature"

/**
 * A Bitcoin transaction script. Each transaction's inputs and outputs
 * has a script that is evaluated to validate its spending.
 *
 * See https://en.bitcoin.it/wiki/Script
 *
 * @constructor
 * @param {Object|string|Buffer=} from optional data to populate script
 */
export class Script {
    constructor(from: any | string | Buffer);

    chunks: any[];

    /**
     * @returns {boolean} if this is a pay to pubkey hash output script
     */
    isPublicKeyHashOut(): boolean;

    /**
     * @returns {boolean} if this is a pay to public key hash input script
     */
    isPublicKeyHashIn(): boolean;

    /**
     * @returns {boolean} if this is a public key output script
     */
    isPublicKeyOut(): boolean;

    /**
     * @returns {boolean} if this is a pay to public key input script
     */
    isPublicKeyIn(): boolean;

    /**
     * @returns {boolean} if this is a p2sh output script
     */
    isScriptHashOut(): boolean;

    /**
     * @returns {boolean} if this is a p2sh input script
     * Note that these are frequently indistinguishable from pubkeyhashin
     */
    isScriptHashIn(): boolean;

    /**
     * @returns {boolean} if this is a mutlsig output script
     */
    isMultisigOut(): boolean;

    /**
     * @returns {boolean} if this is a multisig input script
     */
    isMultisigIn(): boolean;

    /**
     * @returns {boolean} true if this is a valid standard OP_RETURN output
     */
    isDataOut(): boolean;

    /**
     * Retrieve the associated data for this script.
     * In the case of a pay to public key hash or P2SH, return the hash.
     * In the case of a standard OP_RETURN, return the data
     * @returns {Buffer}
     */
    getData(): Buffer;

    /**
     * @returns {boolean} if the script is only composed of data pushing
     * opcodes or small int opcodes (OP_0, OP_1, ..., OP_16)
     */
    isPushOnly(): boolean;

    /**
     * @returns {object} The Script type if it is a known form,
     * or Script.UNKNOWN if it isn't
     */
    classify(): any;

    /**
     * @returns {object} The Script type if it is a known form,
     * or Script.UNKNOWN if it isn't
     */
    classifyOutput(): any;

    /**
     * @returns {object} The Script type if it is a known form,
     * or Script.UNKNOWN if it isn't
     */
    classifyInput(): any;

    /**
     * @returns {boolean} if script is one of the known types
     */
    isStandard(): boolean;

    /**
     * Adds a script element at the start of the script.
     * @param {*} obj a string, number, Opcode, Buffer, or object to add
     * @returns {Script} this script instance
     */
    prepend(obj: any): Script;

    /**
     * Compares a script with another script
     */
    equals(): void;

    /**
     * Adds a script element to the end of the script.
     *
     * @param {*} obj a string, number, Opcode, Buffer, or object to add
     * @returns {Script} this script instance
     *
     */
    add(obj: any): Script;

    /**
     * @returns {Script} a new Multisig output script for given public keys,
     * requiring m of those public keys to spend
     * @param {PublicKey[]} publicKeys - list of all public keys controlling the output
     * @param {number} threshold - amount of required signatures to spend the output
     * @param {Object=} opts - Several options:
     *        - noSorting: defaults to false, if true, don't sort the given
     *                      public keys before creating the script
     */
    static buildMultisigOut(publicKeys: PublicKey[], threshold: number, opts?: any): Script;

    /**
     * A new Multisig input script for the given public keys, requiring m of those public keys to spend
     *
     * @param {PublicKey[]} pubkeys list of all public keys controlling the output
     * @param {number} threshold amount of required signatures to spend the output
     * @param {Array} signatures and array of signature buffers to append to the script
     * @param {Object=} opts
     * @param {boolean=} opts.noSorting don't sort the given public keys before creating the script (false by default)
     * @param {Script=} opts.cachedMultisig don't recalculate the redeemScript
     *
     * @returns {Script}
     */
    static buildMultisigIn(pubkeys: PublicKey[], threshold: number, signatures: any[], opts?: {
        noSorting?: boolean;
        cachedMultisig?: Script;
    }): Script;

    /**
     * A new P2SH Multisig input script for the given public keys, requiring m of those public keys to spend
     *
     * @param {PublicKey[]} pubkeys list of all public keys controlling the output
     * @param {number} threshold amount of required signatures to spend the output
     * @param {Array} signatures and array of signature buffers to append to the script
     * @param {Object=} opts
     * @param {boolean=} opts.noSorting don't sort the given public keys before creating the script (false by default)
     * @param {Script=} opts.cachedMultisig don't recalculate the redeemScript
     *
     * @returns {Script}
     */
    static buildP2SHMultisigIn(pubkeys: PublicKey[], threshold: number, signatures: any[], opts?: {
        noSorting?: boolean;
        cachedMultisig?: Script;
    }): Script;

    /**
     * @returns {Script} a new pay to public key hash output for the given
     * address or public key
     * @param {(Address|PublicKey)} to - destination address or public key
     */
    static buildPublicKeyHashOut(to: Address | PublicKey): Script;

    /**
     * @returns {Script} a new pay to public key output for the given
     *  public key
     */
    static buildPublicKeyOut(): Script;

    /**
     * @returns {Script} a new OP_RETURN script with data
     * @param {(string|Buffer)} data - the data to embed in the output
     * @param {(string)} encoding - the type of encoding of the string
     */
    static buildDataOut(data: string | Buffer, encoding: string): Script;

    /**
     * @param {Script|Address} script - the redeemScript for the new p2sh output.
     *    It can also be a p2sh address
     * @returns {Script} new pay to script hash script for given script
     */
    static buildScriptHashOut(script: Script | Address): Script;

    /**
     * Builds a scriptSig (a script for an input) that signs a public key output script.
     *
     * @param {Signature|Buffer} signature - a Signature object, or the signature in DER canonical encoding
     * @param {number=} sigtype - the type of the signature (defaults to SIGHASH_ALL)
     */
    static buildPublicKeyIn(signature: Signature | Buffer, sigtype?: number): void;

    /**
     * Builds a scriptSig (a script for an input) that signs a public key hash
     * output script.
     *
     * @param {Buffer|string|PublicKey} publicKey
     * @param {Signature|Buffer} signature - a Signature object, or the signature in DER canonical encoding
     * @param {number=} sigtype - the type of the signature (defaults to SIGHASH_ALL)
     */
    static buildPublicKeyHashIn(publicKey: Buffer | string | PublicKey, signature: Signature | Buffer, sigtype?: number): void;

    /**
     * @returns {Script} an empty script
     */
    static empty(): Script;

    /**
     * @returns {Script} a new pay to script hash script that pays to this script
     */
    toScriptHashOut(): Script;

    /**
     * @return {Script} an output script built from the address
     */
    static fromAddress(): Script;

    /**
     * Will return the associated address information object
     * @return {Address|boolean}
     */
    getAddressInfo(): Address | boolean;

    /**
     * @param {Network=} network
     * @return {Address|boolean} the associated address for this script if possible, or false
     */
    toAddress(network?: Network): Address | boolean;

    /**
     * Analogous to bitcoind's FindAndDelete. Find and delete equivalent chunks,
     * typically used with push data chunks.  Note that this will find and delete
     * not just the same data, but the same data with the same push data op as
     * produced by default. i.e., if a pushdata in a tx does not use the minimal
     * pushdata op, then when you try to remove the data it is pushing, it will not
     * be removed, because they do not use the same pushdata op.
     */
    findAndDelete(): void;

    /**
     * Comes from bitcoind's script interpreter CheckMinimalPush function
     * @returns {boolean} if the chunk {i} is the smallest way to push that particular data.
     */
    checkMinimalPush(): boolean;

    /**
     * Comes from bitcoind's script DecodeOP_N function
     * @param {number} opcode
     * @returns {number} numeric value in range of 0 to 16
     */
    _decodeOP_N(opcode: number): number;

    /**
     * Comes from bitcoind's script GetSigOpCount(boolean) function
     * @param {boolean} use current (true) or pre-version-0.6 (false) logic
     * @returns {number} number of signature operations required by this script
     */
    getSignatureOperationsCount(use: boolean): number;
}