#ifndef _DATE_TIME_TIME_PARSING_HPP___

#define _DATE_TIME_TIME_PARSING_HPP___

/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.

 * Use, modification and distribution is subject to the 

 * Boost Software License, Version 1.0. (See accompanying

 * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)

 * Author: Jeff Garland, Bart Garst

 * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $

 */

#include "boost/tokenizer.hpp"

#include "boost/lexical_cast.hpp"

#include "boost/date_time/date_parsing.hpp"

#include "boost/cstdint.hpp"

#include <iostream>

namespace boost {

namespace date_time {

  //! computes exponential math like 2^8 => 256, only works with positive integers

  //Not general purpose, but needed b/c std::pow is not available 

  //everywehere. Hasn't been tested with negatives and zeros

  template<class int_type>

  inline

  int_type power(int_type base, int_type exponent)

  {

    int_type result = 1;

    for(int i = 0; i < exponent; ++i){

      result *= base;

    }

    return result;

  }

  //! Creates a time_duration object from a delimited string

  /*! Expected format for string is "[-]h[h][:mm][:ss][.fff]".

   * If the number of fractional digits provided is greater than the 

   * precision of the time duration type then the extra digits are 

   * truncated.

   *

   * A negative duration will be created if the first character in

   * string is a '-', all other '-' will be treated as delimiters.

   * Accepted delimiters are "-:,.". 

   */

  template<class time_duration, class char_type>

  inline

  time_duration

  str_from_delimited_time_duration(const std::basic_string<char_type>& s)

  {

    unsigned short min=0, sec =0;

    int hour =0; 

    bool is_neg = (s.at(0) == '-');

    boost::int64_t fs=0;

    int pos = 0;

    typedef typename std::basic_string<char_type>::traits_type traits_type;

    typedef boost::char_separator<char_type, traits_type> char_separator_type;

    typedef boost::tokenizer<char_separator_type,

                             typename std::basic_string<char_type>::const_iterator,

                             std::basic_string<char_type> > tokenizer;

    typedef typename boost::tokenizer<char_separator_type,

                             typename std::basic_string<char_type>::const_iterator,

                             typename std::basic_string<char_type> >::iterator tokenizer_iterator;

    char_type sep_chars[5] = {'-',':',',','.'};

    char_separator_type sep(sep_chars);

    tokenizer tok(s,sep);

    for(tokenizer_iterator beg=tok.begin(); beg!=tok.end();++beg){

      switch(pos) {

      case 0: {

        hour = boost::lexical_cast<int>(*beg);

        break;

      }

      case 1: {

        min = boost::lexical_cast<unsigned short>(*beg);

        break;

      }

      case 2: {

        sec = boost::lexical_cast<unsigned short>(*beg);

        break;

      };

      case 3: {

        int digits = static_cast<int>(beg->length());

        //Works around a bug in MSVC 6 library that does not support

        //operator>> thus meaning lexical_cast will fail to compile.

#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))

        // msvc wouldn't compile 'time_duration::num_fractional_digits()' 

        // (required template argument list) as a workaround a temp 

        // time_duration object was used

        time_duration td(hour,min,sec,fs);

        int precision = td.num_fractional_digits();

        // _atoi64 is an MS specific function

        if(digits >= precision) {

          // drop excess digits

          fs = _atoi64(beg->substr(0, precision).c_str());

        }

        else {

          fs = _atoi64(beg->c_str());

        }

#else

        int precision = time_duration::num_fractional_digits();

        if(digits >= precision) {

          // drop excess digits

          fs = boost::lexical_cast<boost::int64_t>(beg->substr(0, precision));

        }

        else {

          fs = boost::lexical_cast<boost::int64_t>(*beg);

        }

#endif

        if(digits < precision){

          // trailing zeros get dropped from the string, 

          // "1:01:01.1" would yield .000001 instead of .100000

          // the power() compensates for the missing decimal places

          fs *= power(10, precision - digits); 

        }

        break;

      }

      }//switch

      pos++;

    }

    if(is_neg) {

      return -time_duration(hour, min, sec, fs);

    }

    else {

      return time_duration(hour, min, sec, fs);

    }

  }

  //! Creates a time_duration object from a delimited string

  /*! Expected format for string is "[-]h[h][:mm][:ss][.fff]".

   * If the number of fractional digits provided is greater than the 

   * precision of the time duration type then the extra digits are 

   * truncated.

   *

   * A negative duration will be created if the first character in

   * string is a '-', all other '-' will be treated as delimiters.

   * Accepted delimiters are "-:,.". 

   */

  template<class time_duration>

  inline

  time_duration

  parse_delimited_time_duration(const std::string& s)

  {

    return str_from_delimited_time_duration<time_duration,char>(s);

  }

  //! Utility function to split appart string

  inline

  bool 

  split(const std::string& s,

        char sep,

        std::string& first,

        std::string& second)

  {

    int sep_pos = static_cast<int>(s.find(sep));

    first = s.substr(0,sep_pos);

    second = s.substr(sep_pos+1);

    return true;

  }

  template<class time_type>

  inline

  time_type

  parse_delimited_time(const std::string& s, char sep)

  {

    typedef typename time_type::time_duration_type time_duration;

    typedef typename time_type::date_type date_type;

    //split date/time on a unique delimiter char such as ' ' or 'T'

    std::string date_string, tod_string;

    split(s, sep, date_string, tod_string);

    //call parse_date with first string

    date_type d = parse_date<date_type>(date_string);

    //call parse_time_duration with remaining string

    time_duration td = parse_delimited_time_duration<time_duration>(tod_string);

    //construct a time

    return time_type(d, td);

  }

  //! Parse time duration part of an iso time of form: [-]hhmmss[.fff...] (eg: 120259.123 is 12 hours, 2 min, 59 seconds, 123000 microseconds)

  template<class time_duration>

  inline

  time_duration

  parse_undelimited_time_duration(const std::string& s)

  {

    int precision = 0;

    {

      // msvc wouldn't compile 'time_duration::num_fractional_digits()' 

      // (required template argument list) as a workaround, a temp 

      // time_duration object was used

      time_duration tmp(0,0,0,1);

      precision = tmp.num_fractional_digits();

    }

    // 'precision+1' is so we grab all digits, plus the decimal

    int offsets[] = {2,2,2, precision+1};

    int pos = 0, sign = 0;

    int hours = 0;

    short min=0, sec=0;

    boost::int64_t fs=0;

    // increment one position if the string was "signed"

    if(s.at(sign) == '-')

    {

      ++sign;

    }

    // stlport choked when passing s.substr() to tokenizer

    // using a new string fixed the error

    std::string remain = s.substr(sign);

    /* We do not want the offset_separator to wrap the offsets, we 

     * will never want to  process more than: 

     * 2 char, 2 char, 2 char, frac_sec length.

     * We *do* want the offset_separator to give us a partial for the

     * last characters if there were not enough provided in the input string. */

    bool wrap_off = false;

    bool ret_part = true;

    boost::offset_separator osf(offsets, offsets+4, wrap_off, ret_part); 

    typedef boost::tokenizer<boost::offset_separator,

                             std::basic_string<char>::const_iterator,

                             std::basic_string<char> > tokenizer;

    typedef boost::tokenizer<boost::offset_separator,

                             std::basic_string<char>::const_iterator,

                             std::basic_string<char> >::iterator tokenizer_iterator;

    tokenizer tok(remain, osf);

    for(tokenizer_iterator ti=tok.begin(); ti!=tok.end();++ti){

      switch(pos) {

        case 0: 

          {

            hours = boost::lexical_cast<int>(*ti); 

            break;

          }

        case 1: 

          {

            min = boost::lexical_cast<short>(*ti); 

            break;

          }

        case 2: 

          {

            sec = boost::lexical_cast<short>(*ti); 

            break;

          }

        case 3:

          {

            std::string char_digits(ti->substr(1)); // digits w/no decimal

            int digits = static_cast<int>(char_digits.length());

            //Works around a bug in MSVC 6 library that does not support

            //operator>> thus meaning lexical_cast will fail to compile.

#if (defined(BOOST_MSVC) && (_MSC_VER <= 1200))  // 1200 == VC++ 6.0

            // _atoi64 is an MS specific function

            if(digits >= precision) {

              // drop excess digits

              fs = _atoi64(char_digits.substr(0, precision).c_str());

            }

            else if(digits == 0) {

              fs = 0; // just in case _atoi64 doesn't like an empty string

            }

            else {

              fs = _atoi64(char_digits.c_str());

            }

#else

            if(digits >= precision) {

              // drop excess digits

              fs = boost::lexical_cast<boost::int64_t>(char_digits.substr(0, precision));

            }

            else if(digits == 0) {

              fs = 0; // lexical_cast doesn't like empty strings

            }

            else {

              fs = boost::lexical_cast<boost::int64_t>(char_digits);

            }

#endif

            if(digits < precision){

              // trailing zeros get dropped from the string, 

              // "1:01:01.1" would yield .000001 instead of .100000

              // the power() compensates for the missing decimal places

              fs *= power(10, precision - digits); 

            }

            break;

          }

      };

      pos++;

    }

    if(sign) {

      return -time_duration(hours, min, sec, fs);

    }

    else {

      return time_duration(hours, min, sec, fs);

    }

  }

  //! Parse time string of form YYYYMMDDThhmmss where T is delimeter between date and time

  template<class time_type>

  inline

  time_type

  parse_iso_time(const std::string& s, char sep)

  {

    typedef typename time_type::time_duration_type time_duration;

    typedef typename time_type::date_type date_type;

    //split date/time on a unique delimiter char such as ' ' or 'T'

    std::string date_string, tod_string;

    split(s, sep, date_string, tod_string);

    //call parse_date with first string

    date_type d = parse_undelimited_date<date_type>(date_string);

    //call parse_time_duration with remaining string

    time_duration td = parse_undelimited_time_duration<time_duration>(tod_string);

    //construct a time

    return time_type(d, td);

  }

} }//namespace date_time

#endif