import { expect } from "chai";
import { V2 } from "../lib/ApiTypes";

export function expectBlockEqual(actual: V2.Block, expected: any) {
    for (const key of Object.keys(expected)) {
        switch (key) {
            case "confirmations":
                expect(actual.confirmations).to.be.gte(expected.confirmations);
                break;
            case "txs":
                expect(actual.txs.length).to.equal(expected.txs.length);
                for (let i = 0; i < actual.txs.length; i++) {
                    expectBlockTxEqual(actual.txs[i], expected.txs[i]);
                }
                break;
            default:
                expect(actual[key]).to.equal(expected[key], key);
        }
    }
}

export function expectBlockTxEqual(actual: V2.BlockTx, expected: any) {
    for (const key of Object.keys(expected)) {
        switch (key) {
            case "confirmations":
                expect(actual.confirmations).to.be.gte(expected.confirmations);
                break;
            case "vin":
                expect(actual.vin.length).to.equal(expected.vin.length);
                for (let i = 0; i < actual.vin.length; i++) {
                    expectBlockTxInputEqual(actual.vin[i], expected.vin[i]);
                }
                break;
            case "vout":
                expect(actual.vout.length).to.equal(expected.vout.length);
                for (let i = 0; i < actual.vout.length; i++) {
                    expectBlockTxOutputEqual(actual.vout[i], expected.vout[i]);
                }
                break;
            default:
                expect(actual[key]).to.equal(expected[key], key);
                break;
        }
    }
}

export function expectBlockTxInputEqual(actual: V2.BlockTxInput, expected: any) {
    for (const key of Object.keys(expected)) {
        switch (key) {
            case "addresses":
                expect(actual.addresses.length).to.equal(expected.addresses.length, key);
                for (let i = 0; i < actual.addresses.length; i++) {
                    expect(actual.addresses[i]).to.equal(expected.addresses[i], key);
                }
                break;
            default:
                expect(actual[key]).to.equal(expected[key]);
                break;
        }
    }
}

export function expectBlockTxOutputEqual(actual: V2.BlockTxOutput, expected: any) {
    for (const key of Object.keys(expected)) {
        switch (key) {
            case "addresses":
                expect(actual.addresses.length).to.equal(expected.addresses.length, key);
                for (let i = 0; i < actual.addresses.length; i++) {
                    expect(actual.addresses[i]).to.equal(expected.addresses[i], key);
                }
                break;
            default:
                expect(actual[key]).to.equal(expected[key], key);
                break;
        }
    }
}