const ethUtil = require('ethereumjs-util');
const sigUtil = require('@metamask/eth-sig-util');

const app = require('j7/app');
const http = require('j7/http');
const utils = require('j7/utils');
const metaFactory = require('../metadata/factory');
const bc = require('../blockchain');
const cmdHash = {};

const BASE_URL = 'https://market-test.kingsome.cn/dev/webapp/index.php';

async function getToken() {
  let nonce = '';
  const netId = await bc.getNetId();
  {
    const {err, data} = await http.get(BASE_URL,
                                       {
                                         'c': 'Market',
                                         'a': 'getNonce',
                                         'account': metaFactory.getUserAddress(),
                                         'net_id': netId
                                       });
    nonce = '' + data['nonce'];
    console.log(err, data);
  }
  {
    const tips = 'hello world';
    const msgParams = {
      types: {
        EIP712Domain: [
          { name: 'name', type: 'string' },
          { name: 'version', type: 'string' },
        ],
        set: [
          { name: 'tips', type: 'string' },
          { name: 'nonce', type: 'string' },
        ]
      },
      primaryType: 'set',
      domain: {
        name: 'Auth',
        version: '1',
      },
      message: {
        tips: tips,
        nonce: nonce
      }
    };
    const signature = sigUtil.signTypedData({
      'privateKey': Buffer.from(metaFactory.getPrivateKey(), 'hex'),
      'data': msgParams,
      'version': "V4"
    });

    const {err, data} = await http.get(BASE_URL,
                                       {
                                         'c': 'Market',
                                         'a': 'auth',
                                         'account': metaFactory.getUserAddress(),
                                         'tips': tips,
                                         'nonce': nonce,
                                         'signature': signature,
                                         'net_id': netId
                                       });
    return data['token'];
  }
}

async function login(session, params) {
  let nonce = '';
  const netId = await bc.getNetId();
  {
    const {err, data} = await http.get(BASE_URL,
                                       {
                                         'c': 'Market',
                                         'a': 'getNonce',
                                         'account': metaFactory.getUserAddress(),
                                         'net_id': netId
                                       });
    nonce = '' + data['nonce'];
    console.log(err, data);
  }
  {
    const tips = 'hello world';
    const msgParams = {
      types: {
        EIP712Domain: [
          { name: 'name', type: 'string' },
          { name: 'version', type: 'string' },
        ],
        set: [
          { name: 'tips', type: 'string' },
          { name: 'nonce', type: 'string' },
        ]
      },
      primaryType: 'set',
      domain: {
        name: 'Auth',
        version: '1',
      },
      message: {
        tips: tips,
        nonce: nonce
      }
    };
    const signature = sigUtil.signTypedData({
      'privateKey': Buffer.from(metaFactory.getPrivateKey(), 'hex'),
      'data': msgParams,
      'version': "V4"
    });

    const {err, data} = await http.get(BASE_URL,
                                       {
                                         'c': 'Market',
                                         'a': 'auth',
                                         'account': metaFactory.getUserAddress(),
                                         'tips': tips,
                                         'nonce': nonce,
                                         'signature': signature,
                                         'net_id': netId
                                       });
    console.log(err, data);
  }
  session.rspOk();
}

async function buyBox(session, params) {
  const token = await getToken();
  const type = params[0];
  const price = params[1];
  const paymentTokenAddress = params[2];
  const netId = await bc.getNetId();
  const nonce = '' + utils.getUtcTime();

  let signature = '';
  {
    const msgParams = {
      types: {
        EIP712Domain: [
          { name: 'name', type: 'string' },
          { name: 'version', type: 'string' },
          { name: 'chainId', type: 'uint256' },
          { name: 'verifyingContract', type: 'address' }
        ],
        set: [
          { name: 'item', type: 'uint256' },
          { name: 'token', type: 'address' },
          { name: 'price', type: 'uint256' },
          { name: 'salt', type: 'uint256' }
        ]
      },
      primaryType: 'set',
      domain: {
        name: 'BEBoxMall',
        version: '1',
        chainId: netId,
        verifyingContract: metaFactory.getContractByName('mall')['address'],
      },
      message: {
        item: type,
        token: paymentTokenAddress,
        price: price,
        salt: nonce
      }
    };

    console.log(msgParams);
    signature = sigUtil.signTypedData({
      'privateKey': Buffer.from(metaFactory.getPrivateKey(), 'hex'),
      'data': msgParams,
      'version': "V4"
    });

  }
  {
    //console.log('balance', await bc.getBalance(paymentTokenAddress));
    await bc.increaseAllowance(paymentTokenAddress, price);
    const params =
          {
            'c': 'Market',
            'a': 'buyBox',
            'token': token,
            'type': type,
            'buyer_address': metaFactory.getUserAddress(),
            'price': price,
            'payment_token_address': paymentTokenAddress,
            'nonce': nonce,
            'signature': signature,
            'net_id': netId
          };
    const {err, data} = await http.get(BASE_URL, params);
    console.log(err, params, data);
  }
  session.rspOk();
}

async function balance(session, params) {
  const paymentTokenAddress = params[0];
  console.log('balance', await bc.getBalance(paymentTokenAddress));
}

async function getPastEvents(session, params) {
  const instanceName = params[0];
  const eventName = params[1];
  const fromBlock = params[2];
  const toBlock = params[3];
  const events = await bc[instanceName].getPastEvents(
    eventName,
    {
      fromBlock: Number(fromBlock),
      toBlock: toBlock,
    },
  );
  console.log(events.length, events);
  session.rspData({
    'count': events.length
  });
}

async function getTrans(session, params) {
  const data = await bc.web3.eth.getTransaction(params[0]);
  console.log(data);
  session.rspData({
    'data': data
  });
}

async function execCmd(session) {
  const cmdLine = session.request('cmd').split('.');
  const cmd = cmdLine[0];
  const params = cmdLine.length > 1 ? cmdLine.slice(1) : [] ;
  if (cmdHash[cmd]) {
    cmdHash[cmd](session, params);
  } else {
    session.rspErr(404, 'not found');
  }
}

function init() {
  app.registerHandler('GM', 'execCmd', execCmd);
  cmdHash['login'] = login;
  cmdHash['buyBox'] = buyBox;
  cmdHash['balance'] = balance;
  cmdHash['getPastEvents'] = getPastEvents;
  cmdHash['getTrans'] = getTrans;
}

exports.init = init;