#include <ctype.h>

#include <iostream>

#include <fstream>

#include <iterator>

#include <stdexcept>

#include <sstream>

#include <map>

#include "rutil/ConfigParse.hxx"

#include "rutil/Log.hxx"

#include "rutil/Logger.hxx"

#include "rutil/ParseBuffer.hxx"

#include "rutil/WinLeakCheck.hxx"

using namespace resip;

using namespace std;

#define RESIPROCATE_SUBSYSTEM Subsystem::SIP

namespace resip

{

ConfigParse::ConfigParse()

{

}

ConfigParse::~ConfigParse()

{

}

void

ConfigParse::parseConfig(int argc, char** argv, const resip::Data& defaultConfigFilename)

{

   ConfigParse::parseConfig(argc, argv, defaultConfigFilename, 0);

}

void 

ConfigParse::parseConfig(int argc, char** argv, const resip::Data& defaultConfigFilename, int skipCount)

{

   parseCommandLine(argc, argv, skipCount);  // will fill in mCmdLineConfigFilename if present

   if(mCmdLineConfigFilename.empty())

   {

      parseConfigFile(defaultConfigFilename);

   }

   else

   {

      parseConfigFile(mCmdLineConfigFilename);

   }

   mConfigValues = mFileConfigValues;

   // Overlay the command line config options on top of the config options from the file

   // The command line config options take precedence / override anything in the file

   for(

      ConfigValuesMap::iterator it = mCmdLineConfigValues.begin();

      it != mCmdLineConfigValues.end();

      it++)

   {

      if(mConfigValues.find(it->first) != mConfigValues.end())

      {

         mConfigValues.erase(it->first);

      }

      mConfigValues.insert(ConfigValuesMap::value_type(it->first, it->second));

   } 

}

void 

ConfigParse::parseCommandLine(int argc, char** argv, int skipCount)

{

   int startingArgForNameValuePairs = 1 + skipCount;

   char *firstArg = argv[startingArgForNameValuePairs];

   // First argument is the configuration filename - it is optional and is never proceeded with a - or /

#ifdef WIN32

   if(argc >= (startingArgForNameValuePairs + 1) && firstArg[0] != '-' && firstArg[0] != '/')

#else

   if(argc >= (startingArgForNameValuePairs + 1) && firstArg[0] != '-')

#endif

   {

      mCmdLineConfigFilename = firstArg;

      startingArgForNameValuePairs++;

   }

   // Loop through command line arguments and process them

   for(int i = startingArgForNameValuePairs; i < argc; i++)

   {

      Data argData(argv[i]);

      // Process all commandNames that don't take values

      if(isEqualNoCase(argData, "-?") || 

         isEqualNoCase(argData, "--?") ||

         isEqualNoCase(argData, "--help") ||

         isEqualNoCase(argData, "/?"))

      {

         printHelpText(argc, argv);

         throw Exception("Help text requested - process stopping", __FILE__, __LINE__);

      }

      else if(argData.at(0) == '-' || argData.at(0) == '/')

      {

         Data name;

         Data value;

         ParseBuffer pb(argData);

         try

         {

            pb.skipChars(Data::toBitset("-/"));  // Skip any leading -'s or /'s

            const char * anchor = pb.position();

            pb.skipToOneOf("=:");

            if(!pb.eof())

            {

               pb.data(name, anchor);

               pb.skipChar();

               anchor = pb.position();

               pb.skipToEnd();

               pb.data(value, anchor);

               //cout << "Command line Name='" << name << "' value='" << value << "'" << endl;

               insertConfigValue("command line", mCmdLineConfigValues, name, value);

            }

            else

            {

               cerr << "Invalid command line parameters:"  << endl;

               cerr << " Name/Value pairs must contain an = or a : between the name and the value" << endl;

               cerr << " Bad argument: " << argData << endl;

               Data exceptionString("Name/Value pairs must contain an = or a : between the name and the value (Bad argument: " + argData + ")");

               throw Exception(exceptionString, __FILE__, __LINE__);

            }

         }

         catch(BaseException& ex)

         {

            cerr << "Invalid command line parameters:"  << endl;

            cerr << " Exception parsing Name/Value pairs: " << ex << endl;

            cerr << " Bad argument: " << argData << endl;

            throw;

         }

      }

      else

      {

         cerr << "Invalid command line parameters:"  << endl;

         cerr << " Name/Value pairs must be prefixed with either a -, --, or a /" << endl;

         cerr << " Bad argument: " << argData << endl;

         Data exceptionString("Name/Value pairs must be prefixed with either a -, --, or a / (Bad argument: " + argData + ")");

         throw Exception(exceptionString,  __FILE__, __LINE__);

      }

   }

}

void

ConfigParse::parseConfigFile(const Data& filename)

{

   // Store off base config path

   ParseBuffer pb(filename);

   const char* anchor = pb.start();

   pb.skipToEnd();

   pb.skipBackToOneOf("/\\");

   if(!pb.bof())

   {

      mConfigBasePath = pb.data(pb.start());

   }

   ifstream configFile(filename.c_str());

   if(!configFile)

   {

      Data exceptionString("Error opening/reading configuration file: " + filename);

      throw Exception(exceptionString,  __FILE__, __LINE__);

   }

   string sline;

   while(getline(configFile, sline)) 

   {

      Data name;

      Data value;

      ParseBuffer pb(sline.c_str(), sline.size());

      pb.skipWhitespace();

      anchor = pb.position();

      if(pb.eof() || *anchor == '#') continue;  // if line is a comment or blank then skip it

      // Look for end of name

      pb.skipToOneOf("= \t");

      pb.data(name,anchor);

      if(*pb.position()!='=') 

      {

         pb.skipToChar('=');

      }

      pb.skipChar('=');

      pb.skipWhitespace();

      anchor = pb.position();

      if(!pb.eof())

      {

         pb.skipToOneOf("\r\n");

         pb.data(value, anchor);

      }

      //cout << "Config file Name='" << name << "' value='" << value << "'" << endl;

      Data lowerName(name);

      lowerName.lowercase();

      if(lowerName == "include")

      {

         parseConfigFile(value);

      }

      else

      {

         insertConfigValue("config file", mFileConfigValues, name, value);

      }

   }

}

void

ConfigParse::getConfigIndexKeys(const resip::Data& indexName, std::set<Data>& keys) const

{

   Data::size_type numPos = indexName.size();

   Data indexNameLower(indexName);

   indexNameLower.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.begin();

   for(; it != mConfigValues.end(); it++)

   {

      const Data& keyName = it->first;

      if(keyName.prefix(indexNameLower) && keyName.size() > numPos

         && isdigit(static_cast< unsigned char >(keyName[numPos])))

      {

         Data::size_type i = numPos + 1;

         while(i < keyName.size() && isdigit(static_cast< unsigned char >(keyName[i])))

         {

            i++;

         }

         Data indexFullName = keyName.substr(0, i);

         if(keys.find(indexFullName) == keys.end())

         {

            keys.insert(indexFullName);

         }

      }

   }

}

bool 

ConfigParse::getConfigValue(const resip::Data& name, resip::Data &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.find(lowerName);

   if(it != mConfigValues.end())

   {

      value = it->second;

      return true;

   }

   // Not found

   return false;

}

Data 

ConfigParse::getConfigData(const resip::Data& name, const resip::Data& defaultValue, bool useDefaultIfEmpty) const

{

   Data ret(defaultValue);

   if(getConfigValue(name, ret) && ret.empty() && useDefaultIfEmpty)

   {

      return defaultValue;

   }

   return ret;

}

bool 

ConfigParse::getConfigValue(const resip::Data& name, bool &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.find(lowerName);

   if(it != mConfigValues.end())

   {

      if(it->second == "1" || 

         isEqualNoCase(it->second, "true") || 

         isEqualNoCase(it->second, "on") || 

         isEqualNoCase(it->second, "enable"))

      {

         value = true;

         return true;

      }

      else if(it->second == "0" ||

              isEqualNoCase(it->second, "false") || 

              isEqualNoCase(it->second, "off") || 

              isEqualNoCase(it->second, "disable"))

      {

         value = false;

         return true;

      }

      cerr << "Invalid boolean setting:  " << name << " = " << it->second << ": Valid values are: 1,true,on,enable,0,false,off or disable" << endl;

      return false;

   }

   // Not found

   return false;

}

bool 

ConfigParse::getConfigBool(const resip::Data& name, bool defaultValue) const

{

   bool ret = defaultValue;

   getConfigValue(name, ret);

   return ret;

}

bool 

ConfigParse::getConfigValue(const resip::Data& name, unsigned long &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.find(lowerName);

   if(it != mConfigValues.end())

   {

      value = it->second.convertUnsignedLong();

      return true;

   }

   // Not found

   return false;

}

unsigned long 

ConfigParse::getConfigUnsignedLong(const resip::Data& name, unsigned long defaultValue) const

{

   unsigned long ret = defaultValue;

   getConfigValue(name, ret);

   return ret;

}

bool 

ConfigParse::getConfigValue(const resip::Data& name, int &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.find(lowerName);

   if(it != mConfigValues.end())

   {

      value = it->second.convertInt();

      return true;

   }

   // Not found

   return false;

}

int 

ConfigParse::getConfigInt(const resip::Data& name, int defaultValue) const

{

   int ret = defaultValue;

   getConfigValue(name, ret);

   return ret;

}

bool

ConfigParse::getConfigValue(const resip::Data& name, unsigned short &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.find(lowerName);

   if(it != mConfigValues.end())

   {

      value = it->second.convertInt();

      return true;

   }

   // Not found

   return false;

}

unsigned short

ConfigParse::getConfigUnsignedShort(const resip::Data& name, int defaultValue) const

{

   int ret = defaultValue;

   getConfigValue(name, ret);

   return ret;

}

bool 

ConfigParse::getConfigValue(const resip::Data& name, std::vector<resip::Data> &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   std::pair<ConfigValuesMap::const_iterator,ConfigValuesMap::const_iterator> valuesIts = mConfigValues.equal_range(lowerName);

   bool found = false;

   for (ConfigValuesMap::const_iterator it=valuesIts.first; it!=valuesIts.second; ++it)

   {

      found = true;

      ParseBuffer pb(it->second);

      Data item;

      while(!it->second.empty() && !pb.eof())

      {

         pb.skipWhitespace();

         const char *start = pb.position();

         pb.skipToOneOf(ParseBuffer::Whitespace, ",");  // allow white space 

         pb.data(item, start);

         value.push_back(item);

         if(!pb.eof())

         {

            pb.skipChar();

         }

      }

   }

   return found;

}

bool

ConfigParse::getConfigValue(const resip::Data& name, std::vector<int> &value) const

{

   std::vector<Data> _value;

   if(!getConfigValue(name, _value))

   {

      return false;

   }

   for(auto v : _value)

   {

      value.push_back(v.convertInt());

   }

   return true;

}

bool

ConfigParse::getConfigValue(const resip::Data& name, std::set<resip::Data> &value) const

{

   Data lowerName(name);  lowerName.lowercase();

   std::pair<ConfigValuesMap::const_iterator,ConfigValuesMap::const_iterator> valuesIts = mConfigValues.equal_range(lowerName);

   bool found = false;

   for (ConfigValuesMap::const_iterator it=valuesIts.first; it!=valuesIts.second; ++it)

   {

      found = true;

      ParseBuffer pb(it->second);

      Data item;

      while(!it->second.empty() && !pb.eof())

      {

         pb.skipWhitespace();

         const char *start = pb.position();

         pb.skipToOneOf(ParseBuffer::Whitespace, ",");  // allow white space

         pb.data(item, start);

         value.insert(item);

         if(!pb.eof())

         {

            pb.skipChar();

         }

      }

   }

   return found;

}

ConfigParse::NestedConfigMap

ConfigParse::getConfigNested(const resip::Data& mapsPrefix) const

{

   NestedConfigMap m;

   Data::size_type numPos = mapsPrefix.size();

   Data mapsPrefixLower(mapsPrefix);

   mapsPrefixLower.lowercase();

   ConfigValuesMap::const_iterator it = mConfigValues.begin();

   for(; it != mConfigValues.end(); it++)

   {

      const Data& keyName = it->first;

      if(keyName.prefix(mapsPrefixLower) && keyName.size() > numPos

         && isdigit(static_cast< unsigned char >(keyName[numPos])))

      {

         Data::size_type i = numPos + 1;

         while(i < keyName.size() && isdigit(static_cast< unsigned char >(keyName[i])))

         {

            i++;

         }

         if(keyName.size() - i < 1)

         {

            stringstream err_text;

            err_text << "Configuration key " << keyName << " missing subkey name";

            Data err_data(err_text.str());

            throw Exception(err_data, __FILE__, __LINE__);

         }

         Data index = keyName.substr(numPos, i - numPos);

         Data nestedKey = keyName.substr(i, keyName.size() - i);

         NestedConfigParse& nested = m[index.convertInt()];

         nested.insertConfigValue(nestedKey, it->second);

      }

   }

   return m;

}

void 

ConfigParse::insertConfigValue(const Data& source, ConfigValuesMap& configValues, const resip::Data& name, const resip::Data& value)

{

   resip::Data lowerName(name);

   lowerName.lowercase();

   if(configValues.find(lowerName) != configValues.end())

   {

      stringstream err_text;

      err_text << "Duplicate configuration key " << name << " while parsing " << source;

      Data err_data(err_text.str());

      throw Exception(err_data, __FILE__, __LINE__);

   }

   configValues.insert(ConfigValuesMap::value_type(lowerName, value));

}

void 

ConfigParse::insertConfigValue(const resip::Data& name, const resip::Data& value)

{

    insertConfigValue("manually added setting", mConfigValues, name, value);

}

resip::Data

ConfigParse::removePath(const resip::Data& fileAndPath) const

{

   Data filenameOnly;

   ParseBuffer pb(fileAndPath);

   const char* anchor = pb.position();

   while(pb.skipToOneOf("/\\") && !pb.eof())

   {

      pb.skipChar();

      anchor = pb.position();

   }

   pb.data(filenameOnly, anchor);

   return filenameOnly;

}

bool 

ConfigParse::AddBasePathIfRequired(Data& filename) const

{

   if(!filename.empty())

   {

      // If filename already has a path specified, then don't touch it

      ParseBuffer pb(filename);

      pb.skipToOneOf("/\\");

      if(pb.eof())

      {

         // No slashes in filename, so no path present

         filename = mConfigBasePath + filename;

         return true;

      }

   }

   return false;

}

EncodeStream& 

operator<<(EncodeStream& strm, const ConfigParse& config)

{

   // Yes this is horribly inefficient - however it's only used when a user requests it

   // and we want to see the items in a sorted list and hash_maps are not sorted.

   std::multimap<Data, Data> sortedMap;

   ConfigParse::ConfigValuesMap::const_iterator it = config.mConfigValues.begin();

   for(; it != config.mConfigValues.end(); it++)

   {

      sortedMap.insert(std::multimap<Data, Data>::value_type(it->first, it->second));

   }

   std::multimap<Data, Data>::const_iterator it2 = sortedMap.begin();

   for(; it2 != sortedMap.end(); it2++)

   {

      strm << it2->first << " = " << it2->second << endl;

   }

   return strm;

}

}

/* ====================================================================

 * The Vovida Software License, Version 1.0 

 * 

 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.

 * Copyright (C) 2013-2023 Daniel Pocock https://danielpocock.com

 * Copyright (C) 2023 Software Freedom Institute LLC https://softwarefreedom.institute

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 * 

 * 3. The names "VOCAL", "Vovida Open Communication Application Library",

 *    and "Vovida Open Communication Application Library (VOCAL)" must

 *    not be used to endorse or promote products derived from this

 *    software without prior written permission. For written

 *    permission, please contact vocal@vovida.org.

 *

 * 4. Products derived from this software may not be called "VOCAL", nor

 *    may "VOCAL" appear in their name, without prior written

 *    permission of Vovida Networks, Inc.

 * 

 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND

 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA

 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES

 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 * 

 * ====================================================================

 * 

 * This software consists of voluntary contributions made by Vovida

 * Networks, Inc. and many individuals on behalf of Vovida Networks,

 * Inc.  For more information on Vovida Networks, Inc., please see

 * <http://www.vovida.org/>.

 *

 */