text: // Copyright (c) 2010 Satoshi Nakamoto
  // Copyright (c) 2009-2015 The Bitcoin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "chainparamsbase.h"
  
  #include "tinyformat.h"
  #include "util.h"
  
  #include <assert.h>
  
  const std::string CBaseChainParams::MAIN = "main";
  const std::string CBaseChainParams::TESTNET = "test";
  const std::string CBaseChainParams::REGTEST = "regtest";
  
  void AppendParamsHelpMessages(std::string& strUsage, bool debugHelp)
  {
      strUsage += HelpMessageGroup(_("Chain selection options:"));
      strUsage += HelpMessageOpt("-testnet", _("Use the test chain"));
      if (debugHelp) {
          strUsage += HelpMessageOpt("-regtest", "Enter regression test mode, which uses a special chain in which blocks can be solved instantly. "
                                     "This is intended for regression testing tools and app development.");
      }
  }
  
  /**
   * Main network
   */
  class CBaseMainParams : public CBaseChainParams
  {
  public:
      CBaseMainParams()
      {
          nRPCPort = 17182;	//change RPC port
      }
  };
  
  /**
   * Testnet (v3)
   */
  class CBaseTestNetParams : public CBaseChainParams
  {
  public:
      CBaseTestNetParams()
      {
          nRPCPort = 27182;	//change RPC port
          strDataDir = "testnet4";
      }
  };
  
  /*
   * Regression test
   */
  class CBaseRegTestParams : public CBaseChainParams
  {
  public:
      CBaseRegTestParams()
      {
          nRPCPort = 27882;
          strDataDir = "regtest";
      }
  };
  
  static std::unique_ptr<CBaseChainParams> globalChainBaseParams;
  
  const CBaseChainParams& BaseParams()
  {
      assert(globalChainBaseParams);
      return *globalChainBaseParams;
  }
  
  std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain)
  {
      if (chain == CBaseChainParams::MAIN)
          return std::unique_ptr<CBaseChainParams>(new CBaseMainParams());
      else if (chain == CBaseChainParams::TESTNET)
          return std::unique_ptr<CBaseChainParams>(new CBaseTestNetParams());
      else if (chain == CBaseChainParams::REGTEST)
          return std::unique_ptr<CBaseChainParams>(new CBaseRegTestParams());
      else
          throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
  }
  
  void SelectBaseParams(const std::string& chain)
  {
      globalChainBaseParams = CreateBaseChainParams(chain);
  }
  
  std::string ChainNameFromCommandLine()
  {
      bool fRegTest = gArgs.GetBoolArg("-regtest", false);
      bool fTestNet = gArgs.GetBoolArg("-testnet", false);
  
      if (fTestNet && fRegTest)
          throw std::runtime_error("Invalid combination of -regtest and -testnet.");
      if (fRegTest)
          return CBaseChainParams::REGTEST;
      if (fTestNet)
          return CBaseChainParams::TESTNET;
      return CBaseChainParams::MAIN;
  }
  