const utils = require('./utils');

const BC_BASE_GAME_ID = 2005;

const BC_FUNC_CREATION = 1;
const BC_FUNC_GUILD = 3;
const BC_FUNC_BLIND_BOX = 5;
const BC_FUNC_PRESENT = 6;
const BC_FUNC_COMMON = 7;
const BC_MAX_TOKEN_IDX = 99999;

const BC_TRANSID_MAX_PARAMS_NUM = 3;
const BC_TRANSID_MAX_SEQID = 9999999;
const BC_TRANS_FUNC_ACTIVATE = 1;
const BC_TRANS_FUNC_MINT_SHARD = 2;
const BC_TRANS_FUNC_EVOLVE = 3;
const BC_TRANS_FUNC_PLUGIN = 4;
const BC_TRANS_FUNC_COMMON = 5;

const BC_EPOCH = 1643212800;

const NONE_TYPE = 0;
const HERO_TYPE = 1;
const EQUIP_TYPE = 2;
const CHIP_TYPE = 3;
const BLIND_BOX_TYPE = 4;
const FRAGMENT_TYPE = 5;
const CLAIM_BOX_TYPE = 6;

function isValidBcGameId(gameId) {
  return gameID > BASE_BC_GAME_ID && gameID < BC_BASE_GAME_ID + 99;
}

function isValidBcTime(time) {
  return time >= BC_EPOCH && time < BC_EPOCH + 3600 * 24 * 365 * 20;
}

function isValidBcFuncId(funcId) {
  return funcId > 0 && funcId < 10;
}

function toBcTime(time) {
  return time - BC_EPOCH;
}

function toBcGameId(gameId) {
  return gameId - BC_BASE_GAME_ID;
}

function toNormalAddress(address) {
  return address.toLowerCase();
}

function genTokenId(gameId, funcId, time, subIdx, idx) {
  const tokenId =
        funcId.toString() +
        //utils.pad(toBcGameId(gameId), 2) +
        utils.pad(toBcTime(time), 9) +
        utils.pad(subIdx, 1) +
        utils.pad(1 + (idx % BC_MAX_TOKEN_IDX), 5);
  return tokenId;
}

function isValidOldTokenId(tokenId) {
  return utils.isPureNumberStr(tokenId.toString()) && tokenId.toString().length == 18;
}

function isValidTokenId(tokenId) {
  return utils.isPureNumberStr(tokenId.toString()) && tokenId.toString().length == 16;
}

function isSameAddress(a, b) {
  return a.toLowerCase() == b.toLowerCase();
}

/*
  max(uint64): 18446744073709551615 = len(20)
  max(uint256): 115792089237316195423570985008687907853269984665640564039457584007913129639935 = len(78)
  max(int32): 2147483648 = len(10)
  len(tokenid) = 16
  transHead: funcId(2)|time(9)|seqId(7) = len(18)
 */

function genTransId(funcId, time, seqId, params) {
  let transId =
      utils.pad(funcId, 1) +
      utils.pad(toBcTime(time), 9) +
      utils.pad(seqId % BC_TRANSID_MAX_SEQID, 7);
  params.forEach
  (
    (element) => {
      transId += utils.pad(element, 20);
    }
  );
  for (let i = 0; i < BC_TRANSID_MAX_PARAMS_NUM - params.length; ++i) {
      transId += utils.pad(0, 20);
  }
  return transId;
}

function isValidTransId(transId) {
  return utils.isPureNumberStr(transId.toString()) &&
    (transId.toString().length == 77 || transId.toString().length == 78);
}

function extractParamsFromTransId(transId) {
  if (!isValidTransId(transId)) {
    return null;
  }
  const transIdStr = transId.toString();
  const params = [];
  for (let i = 0; i < 3; ++i) {
    const param = transId.substr(transIdStr.length - 20 * (3 - i), 20);
    params.push(utils.removeLeadZero(param));
  }
  return params;
}

function extractSubParams(param) {
  const subParams = [0, 0];
  if (param.toString().length < 20) {
    param = utils.pad(param, 20);
  }
  if (param.toString().length > 20) {
    throw 'extractSubparams error to long:' + param;
  } else {
    subParams[0] = param.toString().substr(0, 10);
    subParams[1] = param.toString().substr(10);
  }
  subParams[0] = utils.removeLeadZero(subParams[0]);
  subParams[1] = utils.removeLeadZero(subParams[1]);
  return subParams;
}

function isEmptyAddress(address) {
  return address.toString().length < 10;
}

function isValidAddress(address) {
  if (address == '0x0000000000000000000000000000000000000000') {
    return false;
  }
  return address.toString().length > 10;
}

function isSysAddress(address) {
  return toNormalAddress(address) == '0x0000000000000000000000000000000000000000';
}

exports.BC_BASE_GAME_ID = BC_BASE_GAME_ID;
exports.BC_FUNC_CREATION = BC_FUNC_CREATION;
exports.BC_FUNC_GUILD = BC_FUNC_GUILD;
exports.BC_FUNC_BLIND_BOX = BC_FUNC_BLIND_BOX;
exports.BC_FUNC_PRESENT = BC_FUNC_PRESENT;
exports.BC_FUNC_COMMON = BC_FUNC_COMMON;
exports.BC_EPOCH = BC_EPOCH;
exports.BC_MAX_TOKEN_IDX = BC_MAX_TOKEN_IDX;
exports.BC_TRANSID_MAX_PARAMS_NUM = BC_TRANSID_MAX_PARAMS_NUM;
exports.BC_TRANS_FUNC_ACTIVATE = BC_TRANS_FUNC_ACTIVATE;
exports.BC_TRANS_FUNC_MINT_SHARD = BC_TRANS_FUNC_MINT_SHARD;
exports.BC_TRANS_FUNC_EVOLVE = BC_TRANS_FUNC_EVOLVE;
exports.BC_TRANS_FUNC_PLUGIN = BC_TRANS_FUNC_PLUGIN;
exports.BC_TRANS_FUNC_COMMON = BC_TRANS_FUNC_COMMON;
exports.NONE_TYPE = NONE_TYPE;
exports.HERO_TYPE = HERO_TYPE;
exports.EQUIP_TYPE = EQUIP_TYPE;
exports.CHIP_TYPE = CHIP_TYPE;
exports.BLIND_BOX_TYPE = BLIND_BOX_TYPE;
exports.FRAGMENT_TYPE = FRAGMENT_TYPE;
exports.CLAIM_BOX_TYPE = CLAIM_BOX_TYPE;
exports.isValidBcGameId = isValidBcGameId;
exports.isValidBcTime = isValidBcTime;
exports.isValidBcFuncId = isValidBcFuncId;
exports.toBcTime = toBcTime;
exports.toBcGameId = toBcGameId;
exports.toNormalAddress = toNormalAddress;
exports.genTokenId = genTokenId;
exports.isValidTokenId = isValidTokenId;
exports.isSameAddress = isSameAddress;
exports.genTransId = genTransId;
exports.isValidTransId = isValidTransId;
exports.extractParamsFromTransId = extractParamsFromTransId;
exports.extractSubParams = extractSubParams;
exports.isEmptyAddress = isEmptyAddress;
exports.isValidAddress = isValidAddress;
exports.isSysAddress = isSysAddress;