#ifndef DATE_TIME_TZ_DB_BASE_HPP__

#define DATE_TIME_TZ_DB_BASE_HPP__

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

 * 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-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $

 */

#include <map>

#include <vector>

#include <string>

#include <sstream>

#include <fstream>

#include <stdexcept>

#include <boost/tokenizer.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/throw_exception.hpp>

#include <boost/date_time/compiler_config.hpp>

#include <boost/date_time/time_zone_names.hpp>

#include <boost/date_time/time_zone_base.hpp>

#include <boost/date_time/time_parsing.hpp>

namespace boost {

  namespace date_time {

    //! Exception thrown when tz database cannot locate requested data file

    class data_not_accessible : public std::logic_error

    {

     public:

       data_not_accessible() : 

         std::logic_error(std::string("Unable to locate or access the required datafile.")) 

       {}

       data_not_accessible(const std::string& filespec) : 

         std::logic_error(std::string("Unable to locate or access the required datafile. Filespec: " + filespec)) 

       {}

    };

    //! Exception thrown when tz database locates incorrect field structure in data file

    class bad_field_count : public std::out_of_range

    {

     public:

       bad_field_count(const std::string& s) : 

         std::out_of_range(s) 

      {}

    };

    //! Creates a database of time_zones from csv datafile

    /*! The csv file containing the zone_specs used by the

     * tz_db_base is intended to be customized by the

     * library user. When customizing this file (or creating your own) the

     * file must follow a specific format.

     * 

     * This first line is expected to contain column headings and is therefore

     * not processed by the tz_db_base.

     *

     * Each record (line) must have eleven fields. Some of those fields can

     * be empty. Every field (even empty ones) must be enclosed in 

     * double-quotes.

     * Ex:

     * @code

     * "America/Phoenix" <- string enclosed in quotes

     * ""                <- empty field

     * @endcode

     * 

     * Some fields represent a length of time. The format of these fields 

     * must be:

     * @code

     * "{+|-}hh:mm[:ss]" <- length-of-time format

     * @endcode

     * Where the plus or minus is mandatory and the seconds are optional.

     * 

     * Since some time zones do not use daylight savings it is not always 

     * necessary for every field in a zone_spec to contain a value. All 

     * zone_specs must have at least ID and GMT offset. Zones that use 

     * daylight savings must have all fields filled except: 

     * STD ABBR, STD NAME, DST NAME. You should take note 

     * that DST ABBR is mandatory for zones that use daylight savings 

     * (see field descriptions for further details).

     *

     * ******* Fields and their description/details ********* 

     *     

     * ID: 

     * Contains the identifying string for the zone_spec. Any string will

     * do as long as it's unique. No two ID's can be the same. 

     *

     * STD ABBR:

     * STD NAME:

     * DST ABBR:

     * DST NAME:

     * These four are all the names and abbreviations used by the time 

     * zone being described. While any string will do in these fields, 

     * care should be taken. These fields hold the strings that will be 

     * used in the output of many of the local_time classes. 

     * Ex:

     * @code

     * time_zone nyc = tz_db.time_zone_from_region("America/New_York");

     * local_time ny_time(date(2004, Aug, 30), IS_DST, nyc);

     * cout << ny_time.to_long_string() << endl;

     * // 2004-Aug-30 00:00:00 Eastern Daylight Time

     * cout << ny_time.to_short_string() << endl;

     * // 2004-Aug-30 00:00:00 EDT

     * @endcode

     *

     * NOTE: The exact format/function names may vary - see local_time 

     * documentation for further details.

     *

     * GMT offset:

     * This is the number of hours added to utc to get the local time 

     * before any daylight savings adjustments are made. Some examples 

     * are: America/New_York offset -5 hours, & Africa/Cairo offset +2 hours.

     * The format must follow the length-of-time format described above.

     *

     * DST adjustment:

     * The amount of time added to gmt_offset when daylight savings is in 

     * effect. The format must follow the length-of-time format described

     * above.

     *

     * DST Start Date rule:

     * This is a specially formatted string that describes the day of year

     * in which the transition take place. It holds three fields of it's own,

     * separated by semicolons. 

     * The first field indicates the "nth" weekday of the month. The possible 

     * values are: 1 (first), 2 (second), 3 (third), 4 (fourth), 5 (fifth), 

     * and -1 (last).

     * The second field indicates the day-of-week from 0-6 (Sun=0).

     * The third field indicates the month from 1-12 (Jan=1).

     * 

     * Examples are: "-1;5;9"="Last Friday of September", 

     * "2;1;3"="Second Monday of March"

     *

     * Start time:

     * Start time is the number of hours past midnight, on the day of the

     * start transition, the transition takes place. More simply put, the 

     * time of day the transition is made (in 24 hours format). The format

     * must follow the length-of-time format described above with the 

     * exception that it must always be positive.

     *

     * DST End date rule:

     * See DST Start date rule. The difference here is this is the day 

     * daylight savings ends (transition to STD).

     *

     * End time:

     * Same as Start time.

     */

    template<class time_zone_type, class rule_type>

    class tz_db_base {

    public:

      /* Having CharT as a template parameter created problems 

       * with posix_time::duration_from_string. Templatizing 

       * duration_from_string was not possible at this time, however, 

       * it should be possible in the future (when poor compilers get 

       * fixed or stop being used). 

       * Since this class was designed to use CharT as a parameter it 

       * is simply typedef'd here to ease converting in back to a 

       * parameter the future */

      typedef char char_type;

      typedef typename time_zone_type::base_type time_zone_base_type;

      typedef typename time_zone_type::time_duration_type time_duration_type;

      typedef time_zone_names_base<char_type> time_zone_names;

      typedef boost::date_time::dst_adjustment_offsets<time_duration_type> dst_adjustment_offsets;

      typedef std::basic_string<char_type> string_type;

      //! Constructs an empty database

      tz_db_base() {}

      //! Process csv data file, may throw exceptions

      /*! May throw data_not_accessible, or bad_field_count exceptions */

      void load_from_file(const std::string& pathspec)

      {

        string_type in_str;

        std::string  buff;

        std::ifstream ifs(pathspec.c_str());

        if(!ifs){

          boost::throw_exception(data_not_accessible(pathspec));

        }

        std::getline(ifs, buff); // first line is column headings

        while( std::getline(ifs, buff)) {

          parse_string(buff);

        }

      }

      //! returns true if record successfully added to map

      /*! Takes a region name in the form of "America/Phoenix", and a 

       * time_zone object for that region. The id string must be a unique 

       * name that does not already exist in the database. */

      bool add_record(const string_type& region, 

                      boost::shared_ptr<time_zone_base_type> tz)

      {

        typename map_type::value_type p(region, tz); 

        return (m_zone_map.insert(p)).second;

      }

      //! Returns a time_zone object built from the specs for the given region

      /*! Returns a time_zone object built from the specs for the given 

       * region. If region does not exist a local_time::record_not_found 

       * exception will be thrown */

      boost::shared_ptr<time_zone_base_type> 

      time_zone_from_region(const string_type& region) const 

      {

        // get the record

        typename map_type::const_iterator record = m_zone_map.find(region);

        if(record == m_zone_map.end()){

          return boost::shared_ptr<time_zone_base_type>(); //null pointer

        }

        return record->second;

      }

      //! Returns a vector of strings holding the time zone regions in the database

      std::vector<std::string> region_list() const

      {

        typedef std::vector<std::string> vector_type;

        vector_type regions;

        typename map_type::const_iterator itr = m_zone_map.begin();

        while(itr != m_zone_map.end()) {

          regions.push_back(itr->first);

          ++itr;

        }

        return regions;

      }

    private:

      typedef std::map<string_type, boost::shared_ptr<time_zone_base_type> > map_type;

      map_type m_zone_map;

      // start and end rule are of the same type

      typedef typename rule_type::start_rule::week_num week_num;

      /* TODO: mechanisms need to be put in place to handle different

       * types of rule specs. parse_rules() only handles nth_kday

       * rule types. */

      //! parses rule specs for transition day rules

      rule_type* parse_rules(const string_type& sr, const string_type& er) const

      {

        using namespace gregorian;

        // start and end rule are of the same type, 

        // both are included here for readability

        typedef typename rule_type::start_rule start_rule;

        typedef typename rule_type::end_rule end_rule;

        // these are: [start|end] nth, day, month

        int s_nth = 0, s_d = 0, s_m = 0;

        int e_nth = 0, e_d = 0, e_m = 0;

        split_rule_spec(s_nth, s_d, s_m, sr);

        split_rule_spec(e_nth, e_d, e_m, er);

        typename start_rule::week_num s_wn, e_wn;

        s_wn = get_week_num(s_nth);

        e_wn = get_week_num(e_nth);

        return new rule_type(start_rule(s_wn, s_d, s_m),

                             end_rule(e_wn, e_d, e_m));

      }

      //! helper function for parse_rules()

      week_num get_week_num(int nth) const

      {

        typedef typename rule_type::start_rule start_rule;

        switch(nth){

        case 1:

          return start_rule::first;

        case 2:

          return start_rule::second;

        case 3:

          return start_rule::third;

        case 4:

          return start_rule::fourth;

        case 5:

        case -1:

          return start_rule::fifth;

        default:

          // shouldn't get here - add error handling later

          break;

        }

        return start_rule::fifth; // silence warnings

      }

      //! splits the [start|end]_date_rule string into 3 ints

      void split_rule_spec(int& nth, int& d, int& m, string_type rule) const

      {

        typedef boost::char_separator<char_type, std::char_traits<char_type> > char_separator_type;

        typedef boost::tokenizer<char_separator_type,

                                 std::basic_string<char_type>::const_iterator,

                                 std::basic_string<char_type> > tokenizer;

        typedef boost::tokenizer<char_separator_type,

                                 std::basic_string<char_type>::const_iterator,

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

        const char_type sep_char[] = { ';', '\0'};

        char_separator_type sep(sep_char);

        tokenizer tokens(rule, sep); // 3 fields

        tokenizer_iterator tok_iter = tokens.begin(); 

        nth = std::atoi(tok_iter->c_str()); ++tok_iter;

        d   = std::atoi(tok_iter->c_str()); ++tok_iter;

        m   = std::atoi(tok_iter->c_str());

      }

      //! Take a line from the csv, turn it into a time_zone_type.

      /*! Take a line from the csv, turn it into a time_zone_type,

       * and add it to the map. Zone_specs in csv file are expected to 

       * have eleven fields that describe the time zone. Returns true if 

       * zone_spec successfully added to database */

      bool parse_string(string_type& s)

      {

        std::vector<string_type> result;

        typedef boost::token_iterator_generator<boost::escaped_list_separator<char_type>, string_type::const_iterator, string_type >::type token_iter_type;

        token_iter_type i = boost::make_token_iterator<string_type>(s.begin(), s.end(),boost::escaped_list_separator<char_type>());

        token_iter_type end;

        while (i != end) {

          result.push_back(*i);

          i++;

        }

        enum db_fields { ID, STDABBR, STDNAME, DSTABBR, DSTNAME, GMTOFFSET,

                         DSTADJUST, START_DATE_RULE, START_TIME, END_DATE_RULE,

                         END_TIME, FIELD_COUNT };

        //take a shot at fixing gcc 4.x error

        const unsigned int expected_fields = static_cast<unsigned int>(FIELD_COUNT);

        if (result.size() != expected_fields) { 

          std::ostringstream msg;

          msg << "Expecting " << FIELD_COUNT << " fields, got " 

            << result.size() << " fields in line: " << s;

          boost::throw_exception(bad_field_count(msg.str()));

          BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return false); // should never reach

        }

        // initializations

        bool has_dst = true; 

        if(result[DSTABBR] == std::string()){

          has_dst = false;

        }

        // start building components of a time_zone

        time_zone_names names(result[STDNAME], result[STDABBR],

                              result[DSTNAME], result[DSTABBR]);

        time_duration_type utc_offset = 

          str_from_delimited_time_duration<time_duration_type,char_type>(result[GMTOFFSET]);

        dst_adjustment_offsets adjust(time_duration_type(0,0,0),

                                      time_duration_type(0,0,0),

                                      time_duration_type(0,0,0));

        boost::shared_ptr<rule_type> rules;

        if(has_dst){

          adjust = dst_adjustment_offsets(

                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[DSTADJUST]),

                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[START_TIME]),

                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[END_TIME])

                                          );

          rules = 

            boost::shared_ptr<rule_type>(parse_rules(result[START_DATE_RULE],

                                                     result[END_DATE_RULE]));

        }

        string_type id(result[ID]);

        boost::shared_ptr<time_zone_base_type> zone(new time_zone_type(names, utc_offset, adjust, rules));

        return (add_record(id, zone));

      } 

    };

} } // namespace

#endif // DATE_TIME_TZ_DB_BASE_HPP__