require("dotenv").config();
import {homedir, cpus} from "os";
import parseArgv from "./utils/parseArgv";
import {ConfigType} from "./types/Config";
import * as _ from "lodash";

let program = parseArgv([], ['config']);

function findConfig(): ConfigType | undefined {
  let foundConfig;
  const envConfigPath = process.env.BITCORE_CONFIG_PATH;
  const argConfigPath = program.config;
  const configFileName = 'bitcore.config.js';
  let bitcoreConfigPaths = [
    `${homedir()}/${configFileName}`,
    `../../../../${configFileName}`,
    `../../../${configFileName}`,
    `../../${configFileName}`
  ];
  const overrideConfig = argConfigPath || envConfigPath;
  if (overrideConfig) {
    bitcoreConfigPaths.unshift(overrideConfig);
  }
  // No config specified. Search home, bitcore and cur directory
  for (let path of bitcoreConfigPaths) {
    if (!foundConfig) {
      try {
        const expanded = path[0] === '~' ? path.replace('~', homedir()) : path;
        const bitcoreConfig = require(expanded) as { bitcoreNode: ConfigType };
        foundConfig = bitcoreConfig.bitcoreNode;
      } catch (e) {
        foundConfig = undefined;
      }
    }
  }
  return foundConfig;
}

function setTrustedPeers(config: ConfigType): ConfigType {
  for (let [chain, chainObj] of Object.entries(config)) {
    for (let network of Object.keys(chainObj)) {
      let env = process.env;
      const envString = `TRUSTED_${chain.toUpperCase()}_${network.toUpperCase()}_PEER`;
      if (env[envString]) {
        let peers = config.chains[chain][network].trustedPeers || [];
        peers.push({
          host: env[envString],
          port: env[`${envString}_PORT`]
        });
        config.chains[chain][network].trustedPeers = peers;
      }
    }
  }
  return config;
}

const Config = function (): ConfigType {
  let config: ConfigType = {
    maxPoolSize: 50,
    port: 3000,
    dbHost: process.env.DB_HOST || 'localhost',
    dbName: process.env.DB_NAME || 'bitcore_node',
    dbPort: process.env.DB_PORT || '27017',
    dbUser: process.env.DB_USER || 'root',
    dbPass: process.env.DB_PASS || 'root',
    numWorkers: cpus().length,
    appInsightsInstrumentationKey: process.env.APPINSIGHTS_INSTRUMENTATIONKEY || '',
    chains: {},
    services: {
      api: {
        rateLimiter: {
          disabled: false,
          whitelist: ['::ffff:127.0.0.1', '::1']
        },
        wallets: {
          allowCreationBeforeCompleteSync: false,
          allowUnauthenticatedCalls: true
        }
      },
      event: {
        onlyWalletEvents: false
      },
      p2p: {},
      socket: {},
      storage: {}
    }
  };

  let foundConfig = findConfig();
  const mergeCopyArray = (objVal, srcVal) => (objVal instanceof Array ? srcVal : undefined);
  config = _.mergeWith(config, foundConfig, mergeCopyArray);
  if (!Object.keys(config.chains).length) {
    Object.assign(config.chains, {
      TCR: {
        [process.env.NETWORK || 'mainnet']: {
          chainSource: 'p2p',
          trustedPeers: [{
            host: process.env.PEER_HOST || 'tecracoin',
            port: process.env.PEER_PORT || '2718'
          }],
          rpc: {
            host: process.env.RPC_HOST || 'tecracoin',
            port: process.env.RPC_PORT || '9045',
            username: process.env.RPC_USER,
            password: process.env.RPC_PASSWORD
          }
        }
      }
    });
  }
  config = setTrustedPeers(config);
  return config;
};

export default Config();