import "reflect-metadata"

import PrivateKeyProvider = require("truffle-privatekey-provider");
import {fromMasterSeed} from "ethereumjs-wallet/hdkey";
import {mnemonicToSeedSync} from "bip39";
import {ReflauntWallet} from "../../../models/ReflauntWallet";
import {ContractService} from "../ContractService";
import {execSync} from "child_process";
import Web3 from "web3";
import {ReflauntInstanceShim} from "../../../models/ReflauntInstanceShim";

jest.mock('../ProviderService');
jest.mock('../HdWalletService');

const privateKey = 'ffc2a24dfb610daef396ef9533b52960d233a585b0b1c2c06155e55509a86382';
const address = '0x26c6ba91ab880e34365a82da8c94153a9284e4e2';
const mnemonic = 'blame left final crime wing curious actual light drip trip patient daughter';
const nodeUrl = 'http://localhost:9988';

const providerServiceImpl = {
    config: {
        nodeUrl: '',
        wsUrl: '',
        mnemonic: ''
    },
    getPrivateKeyProvider: jest.fn(() => {
        return new PrivateKeyProvider(privateKey, nodeUrl)
    }),
    getPublicProvider: jest.fn(() => {
        return new Web3.providers.WebsocketProvider(nodeUrl)
    })
};
const hdWalletServiceImpl = {
    maxWallet: 2000000000,
    walletCache: null,
    hdKey: fromMasterSeed(mnemonicToSeedSync(mnemonic)),
    getWallet: jest.fn(() => {
        return new ReflauntWallet({
            id: 1,
            address: address,
            wallet: {
                privateKey: privateKey
            }
        })
    }),
    generateWallet: jest.fn(() => {}),
    getWalletPath: jest.fn(() => {
        return `m/44'/60'/0'/0/1`
    })
};

beforeEach(async function () {
    execSync('./node_modules/.bin/truffle migrate --network docker --reset');
});

describe('ContractService.loginAs', () => {
    test('Should get reflaunt contract from user id private key', async () => {
        const instance: ReflauntInstanceShim = await new ContractService(providerServiceImpl, hdWalletServiceImpl).loginAs(1);
        const name = await instance.name();
        expect(name).toEqual('Reflaunt');
        expect(instance.wallet.address).toEqual(address);
        expect(instance.web3.currentProvider).toBeInstanceOf(PrivateKeyProvider);
        expect(instance.web3.currentProvider['address']).toEqual(address);
    });
});

describe('ContractService.getContract', () => {
    test('Should get reflaunt contract publicly', async () => {
        const instance: ReflauntInstanceShim = await new ContractService(providerServiceImpl, hdWalletServiceImpl).getContract();
        const name = await instance.name();
        expect(name).toEqual('Reflaunt');
        expect(instance.wallet).toBeUndefined();
        expect(instance.web3.currentProvider).toBeInstanceOf(Web3.providers.WebsocketProvider);
        expect(instance.web3.currentProvider['address']).toBeUndefined()
    });
});