import * as dotevnv from "dotenv"
import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
    ,Transaction,formatEther,
    ZeroHash,ethers,keccak256
} from 'ethers'
import {Calulator} from "../inc/calc";
import axios from "axios";

import {
    SecurityToken,
    SecurityToken__factory,
} from '../typechain'
import chalk from "chalk";
import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
    getElapsed, sleep,getBlockInfo} from '../inc/util'
import { sign } from "crypto";
dotevnv.config();
if (!process.env.RPCURL) {
    console.log(`No rpcur value specified...`)
}


async function getNonce(addr: string): Promise<number> {
    const nonce = await provider.getTransactionCount(addr);
    return nonce;
}



async function info(symbol: string) {
    const proxy = getDeploymentAddresses(symbol).address;
    console.log(`토큰 주소 : ${proxy}`);

    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
    await token.connect(admin);
    const ops = await token.operators();
    console.log(ops);


    const balance = await token.balanceOf(firstHolder);
    console.log(`initial balance = ${balance}`);

    let b = await token.isTokenHolderKYC('0x2071ec931b2567a1418e9bc34b786d654a079b43');
    if(!b) {
        console.log('kyc check first!');
        return;
    }

    await token.KYCtokenHolders([holder1.address,holder2.address]);

    b = await token.isTokenHolderKYC(holder1.address);
    if(!b) {
        console.log('kyc check first!');
        return;
    }
    // token.grantRole(keccak256('OPERATOR_ROLE'),'0xaaa')
}

function getAuthHeader(token: string) : any{
    return {
		headers: {
			'Content-Type': 'application/json;charset=UTF-8',
			'Access-Control-Allow-Origin': '*',
			'Authorization': `Bearer ${token}`
    		}
	};
}

async function getBalance(symbol: string, address: string ): Promise<number> {
    const path = `holders/${address}/tokens/${symbol}/balance`;
    const ret = await axios.get(gateWay + path, getAuthHeader(authToken));
    return ret.data;
}

async function getTx(signerAddress:string, tokenSymbol: string, from: string, to: string, value: number) : Promise<any> {
    const path = 'transfer/tx/data';
    const ret = await axios.post(gateWay + path, {
        signerAddress,
        tokenSymbol,
        transfers : [{
            partitionName:'초기',
            from,
            to,
            value,
            data:'0x0000000000000000000000000000000000000000000000000000000000000000',
            operatorData:'0x0000000000000000000000000000000000000000000000000000000000000000'
        }]
    },getAuthHeader(authToken));
    return ret;
}

async function send(signedTransaction: string) {
    const path = 'transaction/send';
    const ret = await axios.post(gateWay + path, {
        signedTransaction
    },getAuthHeader(authToken));
    return ret;
}

async function transfer(signer: Wallet,symbol:string,from: Wallet, to: Wallet, amount: number = 1, count: number = 10) {
    const proxy = getDeploymentAddresses(symbol).address;
    console.log(`토큰 주소 : ${proxy}`);

    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
    const decimals = await token.decimals();
    const digit = 10 ** Number(decimals);
    //console.log(`자릿수 = ${digit}`);


    let fb = await getBalance(symbol,from.address);
    let tb = await getBalance(symbol,to.address);
    fb = (1/digit) * fb;
    tb = (1/digit) * tb;
    console.log(chalk.yellow('###################### 전송전 잔고 ###################################'))
    console.log(`balance of sender(${from.address}) = ${fb.toFixed(Number(decimals))}\r\nbalance of receiver(${to.address}) = ${tb.toFixed(Number(decimals))}`);

    let firstTx:string = null;
    let lastTx:string = null;
    const start = Date.now();
    console.log(chalk.cyan(`전송시작 시간 : ${new Date(start).toUTCString()}`));

    console.log(chalk.yellow(`sending ${count} transactions`));
    let signedData = [];
    for(let i = 0; i < count; i++) {
        const rawTx = await getTx(signer.address,symbol,from.address,to.address, amount * digit);
        const tx = Transaction.from(rawTx.data);
        const signed = await signer.signTransaction(tx);
        signedData.push(signed);

        if(i == 0) {
            firstTx = keccak256(signed);
        } else if(i == count -1) {
            lastTx = keccak256(signed);
        }
    }

    // const start = Date.now();
    // console.log(chalk.cyan(`전송시작 시간 : ${new Date(start).toUTCString()}`));

    let proms = [];
    for(let i = 0; i < count; i++) {
        proms.push(send(signedData[i]));
    }

    let resolved = await Promise.all(proms);

    
    let txMap = new Map<string,boolean>();
    resolved.forEach(tx => {
        txMap.set(tx.data.transactionHash,false)
        //console.log(tx.data.transactionHash);
    });
    
    const blockHashes = await checkReceipt2(txMap,[firstTx as string, lastTx as string], 'wait for receipt...');
    const firstBlockHash = blockHashes.get(firstTx);
    const lastBlockHash = blockHashes.get(lastTx);
    console.log(`firstBlockHash = ${firstBlockHash} \nlastBlockHash = ${lastBlockHash}`);
  
    fb = await getBalance(symbol,from.address);
    tb = await getBalance(symbol,to.address);
    fb = (1/digit) * fb;
    tb = (1/digit) * tb;
    console.log(chalk.yellow('###################### 전송후 잔고 ###################################'))
    console.log(`balance of sender(${from.address}) = ${fb.toFixed(Number(decimals))}\r\nbalance of receiver(${to.address}) = ${tb.toFixed(Number(decimals))}`);

    console.log(firstTx);

    // const lastB = await getBlockInfo(lastBlockHash);
    // const lastTimeStamp = parseInt(lastB.timestamp,16);
    // console.log(`eth_getBlockByHash(${lastBlockHash}).timestamp = ${lastTimeStamp}`)

    // const d = new Date(lastTimeStamp * 1000);
    // console.log(chalk.cyan(`전송종료 시간(블록완결시간) : ${d.toUTCString()}`));

    // console.log(chalk.yellow(`start timestamp = ${start}`));
    // console.log(chalk.yellow(`end timestamp = ${lastTimeStamp * 1000}`));

    // const tps = calc.CTPS(count,start,lastTimeStamp * 1000);
    // console.log(`CTPS = ${tps}`);

}


const firstHolder = '0x2071ec931b2567a1418e9bc34b786d654a079b43';
const calc = new Calulator();
const rpcUrl = process.env.RPCURL;
const gateWay = process.env.GATE_WAY; 
const authToken=process.env.AUTHTOKEN;
const provider = new JsonRpcProvider(rpcUrl);
setProvider(provider);


const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
// const signer = holder1;

console.log(`목적 서버 : ${gateWay}`);

async function main() {
    transfer(holder1,'BCG_TEST',holder1, holder2,1, 1);
}

main();