import Web3 from 'web3';
import { cry, Transaction } from 'thor-devkit';
import { SolidoSigner } from '@decent-bet/solido';
import { Wallet } from 'xdvplatform-wallet';
import { WalletTransaction } from './WalletTransaction';


export class WalletSigner implements SolidoSigner {
    constructor(public payload: WalletTransaction,
        public wallet: Wallet,
        private thorify:  Web3) { }

    async requestSigning(): Promise<any> {
        try {
            
            let body: Transaction.Body = {
                chainTag: this.payload.chainTag === '0x27' ? 0x27 : 0x9a,
                blockRef: this.payload.blockRef,
                expiration: 32,
                clauses: [{
                    to: this.payload.to,
                    data: this.payload.data,
                    value: this.payload.value,
                }],
                gasPriceCoef: this.payload.gasPriceCoef,
                gas: this.payload.gas,
                dependsOn: null,
                nonce: new Date().getTime(),
            }
            
            let tx = new Transaction(body)
            let signingHash = cry.blake2b256(tx.encode())
            
            const kp = await this.wallet.getPrivateKey('ES256K');
            const signature = cry.secp256k1.sign(signingHash, kp.getPrivate('hex'));
            
            const a = await (this.thorify as Web3).eth.sendSignedTransaction('0x'+signature.toString('hex'));
            return a;
        } catch (error) {
            throw error;
        }
    }


    async wait(lookupInfo: any) {
        let found: any = {};
        let exit = 5;
        let n = lookupInfo.beforeBlock - 2;
        // eslint-disable-next-line no-constant-condition
        while (true) {
            n += 1;
            exit -= 1;
            // eslint-disable-next-line no-await-in-loop
            const block = await connex.thor.block(n).get();
            if (block) {
                // eslint-disable-next-line no-await-in-loop
                const txs = await from(block.transactions)
                    .pipe(
                        // eslint-disable-next-line no-loop-func
                        mergeMap(i => connex.thor.transaction(i).get()),
                        // is origin  and clauses[0].data
                        filter((i: Connex.Thor.Transaction) => i.clauses.length > 0
                            && i.clauses[0].data === lookupInfo.data)
                    )
                    .toPromise();

                // console.log(txs);

                if (txs) {
                    found = {
                        id: txs.id,
                    };
                    break;
                }
                if (exit === 0) break;
            }
        }

        if (found.id) {
            const receipt = await connex.thor.transaction(found.id).getReceipt();
            if (receipt.reverted) {
                throw new Error('Reverted');
            }
            return receipt;
        }
        return null;
    }
}