const app = require('j7/app');
const utils = require('j7/utils');
const log = require('j7/log');

const metaClassList = [];
const metaClasses = {};

function registerMetaClass(fileName, primKey, wrapClass, aliseName = '') {
  const metaClass = {
    'fileName' : fileName,
    'primKey' : primKey,
    'wrapClassName': wrapClass,
    'wrapClass': require('./' + wrapClass),
    'rawList' : [],
    'rawHash' : {},
    'wrapList' : [],
    'wrapHash' : {},
    'aliseName': aliseName
  };
  metaClassList.push(metaClass);
  if (aliseName) {
    metaClasses[aliseName] = metaClass;
  } else {
    metaClasses[wrapClass] = metaClass;
  }
}

function load() {
  metaClassList.forEach((metaClass) => {
    const json = utils.readJsonFromFile(metaClass['fileName']);
    if (!json) {
      throw new Error('读取配置' + metaClass['fileName'] + '失败');
    }
    if (Array.isArray(json)) {
      metaClass['rawList'] = json;

    } else {
      metaClass['rawList'].push(json);
    }
    let idx = 0;
    metaClass['rawList'].forEach(function (item) {
      const wrapOjb = new metaClass['wrapClass'](item, metaClass);
      const wrapProxy = new Proxy(wrapOjb, wrapOjb._getHandler());
      metaClass['wrapList'].push(wrapProxy);
      if (metaClass['primKey'] == '') {
        metaClass['rawHash'][idx] = item;
        metaClass['wrapHash'][idx] = wrapProxy;
      } else {
        metaClass['rawHash'][item[metaClass['primKey']]] = item;
        metaClass['wrapHash'][item[metaClass['primKey']]] = wrapProxy;
      }
      ++idx;
    });
    //log.debug(utils.jsonEncode(metaClass));
  });
  {
    for (let i = 0; i < 3; ++i) {
      metaClassList.forEach((metaClass) => {
        metaClass['wrapList'].forEach((item) => {
          if (item['_init' + i]) {
            item['_init' + i](exports);
          }
        });
      });
    }
    metaClassList.forEach((metaClass) => {
      metaClass['wrapList'].forEach((item) => {
        item.lock();
      });
    });
  }
}

function init() {
  let configDir = './config/';
  if (utils.isOnlineEnv()) {
    configDir = '../config/';
  } else if (utils.getArgv('env') == 'dev'){
    configDir = './config_dev/';
  }
  console.log(configDir, utils.getArgv('env'));

  let resDir = './res/';
  if (utils.isOnlineEnv()) {
    resDir = '../res/';
  } else if (utils.getArgv('env') == 'dev'){
    resDir = './res_dev/';
  }

  registerMetaClass(configDir + 'config.json',
                    '',
                    'Config'
                   );
  registerMetaClass(configDir + 'web3.json',
                    '',
                    'Web3'
                   );
  registerMetaClass(configDir + 'contract.json',
                    '',
                    'Contract'
                   );
  registerMetaClass(configDir + 'marketdb_mysql.json',
                    '',
                    'MarketDb'
                   );
  registerMetaClass(configDir + 'present_list.json',
                    '',
                    'PresentList'
                   );

  registerMetaClass(resDir + 'item@item.json',
                    'id',
                    'Item'
                   );

  load();
  {
    getMetaByKey('PresentList', '0')['list'].forEach((item) => {
      registerMetaClass(resDir + item + '@present.json',
                        'id',
                        'Present',
                        'Present' + item
                       );
    });
  }
  {
    traverseMetaList('MarketDb', (dbConf, idx) => {
      app.registerDb('MarketDb' + idx, dbConf);
    });
  }
}

function getMetaClass(name) {
  return utils.hasKey(metaClasses, name) ? metaClasses[name] : null;
}

function getMetaByKey(name, key) {
  const metaClass = getMetaClass(name);
  return metaClass && key in metaClass['wrapHash'] ? metaClass['wrapHash'][key] : null;
}

function getMetaList(name) {
  const metaClass = getMetaClass(name);
  return metaClass ? metaClass['wrapList'] : null;
}

function callMetaStatic(name, method, ...args) {
  const metaClass = getMetaClass(name);
  return metaClass['wrapClass'][method](...args);
}

function traverseMetaList(name, cb) {
  const metaList = getMetaList(name);
  if (metaList) {
    for (let i = 0; i < metaList.length; ++i) {
      if (!cb(metaList[i], i, metaList.length)) {
        break;
      }
    }
  }
}

function getWeb3Conf() {
  return getMetaByKey('Web3', '0');
}

function getContracts() {
  return getMetaList('Contract');
}

function getContractByName(name) {
  return getMetaByKey('Contract', name);
}

function getContractByAddress(address) {
  let contract = null;
  getContracts().forEach((item) => {
    if (item['address'] == address) {
      contract = item;
    }
  });
  return contract;
}

function getUserAddress() {
  return getWeb3Conf()['user_address'];
}

function getPrivateKey() {
  return getWeb3Conf()['private_key'];
}

exports.init = init;

exports.getMetaByKey = getMetaByKey;
exports.traverseMetaList = traverseMetaList;
exports.callMetaStatic = callMetaStatic;

exports.getWeb3Conf = getWeb3Conf;
exports.getContracts = getContracts;
exports.getContractByName = getContractByName;
exports.getContractByAddress = getContractByAddress;
exports.getUserAddress = getUserAddress;
exports.getPrivateKey = getPrivateKey;