/* Copyright (c) 2002,2003 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
 */

#include <boost/cstdint.hpp>
#include "boost/date_time/gregorian/gregorian.hpp"
#include "../testfrmwk.hpp"
#include <iostream>
#include <sstream>

void test_yearlimit(int yr, bool allowed)
{
    std::stringstream sdesc;
    sdesc << "should" << (allowed ? "" : " not") << " be able to make a date in year " << yr;

    try {
        boost::gregorian::date chkyr(yr, 1, 1);
        check(sdesc.str(), allowed);
    }
    catch (std::out_of_range&) { check(sdesc.str(), !allowed); }
}

int
main()
{

  using namespace boost::gregorian;

  //various constructors
#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
  date def;
  check("Default constructor", def == date(not_a_date_time));
#endif
  
  date d1(1900,1,1);
  date d2 = date(2000,1,1);
  date d3(d2);
  check("Copy constructor", d3 == d2);
  date d4(2000,12,31);
  date d4a(2000,Dec,31);
  //d4a.print(std::cout); std::cout << std::endl;
  check("month_rep constructor",   d4 == d4a);
  //std::cout << d3 << std::endl;
  //retrieval functions
  check_equal("1900-01-01 day is 01",     d1.day(),   1);
  check_equal("1900-01-01 month is 01",   d1.month(), 1);
  check_equal("1900-01-01 year is 1900",  d1.year(),  1900);
  check_equal("2000-12-31 day is 31",     d4.day(),   31);
  check_equal("2000-12-31 month is 12",   d4.month(), 12);
  check_equal("2000-12-31 year is 2000",  d4.year(),  2000);
  //operator<
  check("1900-01-01 is less than 2000-01-01",          d1 < d2);
  check("2000-01-01 is NOT less than 2000-01-01",      !(d1 < d1));
  //operator<=
  check("2000-01-01 is less equal than 2000-01-01",    d1 <= d1);
  //operator>
  check("2000-01-01 is greater than 1900-01-01",       d2 > d1);
  check("2000-01-01 is NOT greater than 2000-01-01",   !(d1 < d1));
  //operator>=
  check("2000-01-01 is greater equal than 2000-01-01", d1 >= d1);
  //operator!=
  check("2000-01-01 is NOT equal to 1900-01-01",       d2 != d1);
  //operator==
  check_equal("2000-01-01 is equal 2000-01-01",        d3,   d2);
  check("2000-01-01 is greater equal 2000-01-01",      d3 >= d2);
  check("2000-01-01 is greater equal 2000-01-01",      d3 <= d2);

  date::ymd_type ymd = d1.year_month_day();
  check_equal("ymd year",  ymd.year,  1900);
  check_equal("ymd month", ymd.month, 1);
  check_equal("ymd day",   ymd.day,   1);

  //The max function will not compile with Borland 5.5
  //Complains about must specialize basic_data<limits> ???
//   std::cout << "Max date is " << (date::max)() << std::endl;
//   //std::cout << "Max date is " << (basic_date< date_limits<unsigned int,1900> >::max)() << std::endl;
//   //std::cout << "Max date is " << (date_limits<unsigned int, 1900>::max)() << std::endl;

  const date answers[] = {date(1900,Jan,1),date(1900,Jan,4),date(1900,Jan,7),
                          date(1900,Jan,10),date(1900,Jan,13)};
  date_duration off(3);
  date d5(1900,1,1);
  for (int i=0; i < 5; ++i) {
    //std::cout << d5 << "  ";
    check(" addition ", d5 == answers[i]);
    d5 = d5 + off;
  }
  std::cout << std::endl;

   const date answers1[] = {date(2000,2,26),date(2000,2,28),date(2000,Mar,1)};
   date d8(2000,Feb,26);
   for (int j=0; j < 3; ++j) {
     //std::cout << d8 << "  ";
     check(" more addition ", d8 == answers1[j]);
     d8 = d8 + days(2);
   }
   // std::cout << std::endl;

  date d6(2000,2,28);
  date d7(2000,3,1);
  date_duration twoDays(2);
  date_duration negtwoDays(-2);
  date_duration zeroDays(0);
  check_equal("2000-03-01 - 2000-02-28 == 2 days",   twoDays,     (d7-d6));
  check_equal("2000-02-28 - 2000-03-01 == - 2 days", negtwoDays,  (d6-d7));
  check_equal("2000-02-28 - 2000-02-28 == 0 days",   zeroDays,    (d6-d6));
  check_equal("2000-02-28 + 2 days == 2000-03-01 ",  d6 + twoDays, d7);
  check_equal("2000-03-01 - 2 days == 2000-02-28 ",  d7 - twoDays, d6);
  check_equal("Add duration to date", date(1999,1,1) + date_duration(365), date(2000,1,1));
  check_equal("Add zero days", date(1999,1,1) + zeroDays, date(1999,1,1));
  //can't do this...
  //check("Add date to duration", date_duration(365) + date(1999,1,1) == date(2000,1,1));

  {
    date d(2003,Oct,31);
    date_duration dd(55);
    d += dd;
    check("date += date_duration", d == date(2003,Dec,25));
    d -= dd;
    check("date -= date_duration", d == date(2003,Oct,31));
    /* special_values is more thoroughly tested later,
     * this is just a test of += & -= with special values */
    d += date_duration(pos_infin);
    check("date += inf_dur", d == date(pos_infin));
    d -= dd;
    check("inf_date -= dur", d == date(pos_infin));
  }
  {
    date d(2003,Oct,31);
    date_duration dd1(pos_infin), dd2(neg_infin), dd3(not_a_date_time);
    check_equal("date + inf_dur", d + dd1, date(pos_infin));
    check_equal("date + inf_dur", d + dd2, date(neg_infin));
    check_equal("date + nan_dur", d + dd3, date(not_a_date_time));
    check_equal("date - inf_dur", d - dd1, date(neg_infin));
    check_equal("date - inf_dur", d - dd2, date(pos_infin));
    check_equal("date - nan_dur", d - dd3, date(not_a_date_time));
    check_equal("inf_date + inf_dur", date(pos_infin) + dd1, date(pos_infin));
    check_equal("inf_date - inf_dur", date(pos_infin) - dd1, date(not_a_date_time));
    check_equal("inf_date + inf_dur", date(neg_infin) + dd1, date(not_a_date_time));
    check_equal("inf_date - inf_dur", date(neg_infin) - dd1, date(neg_infin));
  }


  try {
    date d9(2000, Jan, 32);
    check("day out of range", false);
    //never reached if working -- but stops compiler warnings :-)
    std::cout << "Oops: " << to_iso_string(d9) << std::endl;
  }
  catch (bad_day_of_month&) {
    check("day out of range", true);
  }
  try {
    date d9(2000, Jan, 0);
    check("day out of range", false);
    //never reached if working -- but stops compiler warnings :-)
    std::cout << "Oops: " << to_iso_string(d9) << std::endl;
  }
  catch (bad_day_of_month&) {
    check("day out of range", true);
  }

  try {
    date d20(2000, Feb, 31);
    check("day out of range", false);
    //never reached if working -- but stops compiler warnings :-)
    std::cout << "Oops: " << to_iso_string(d20) << std::endl;
  }
  catch (bad_day_of_month&) {
    check("day out of range", true);
  }

  //more subtle -- one day past in a leap year
  try {
    date d21(2000, Feb, 30);
    check("day out of range", false);
    //never reached if working -- but stops compiler warnings :-)
    std::cout << "Oops: " << to_iso_string(d21) << std::endl;
  }
  catch (bad_day_of_month&) {
    check("day out of range", true);
  }

  //more subtle -- one day past in a leap year
  try {
    date d22(2000, Feb, 29);
    check("last day of month ok", true);
    std::cout << to_iso_string(d22) << std::endl; //stop compiler warning
  }
  catch (bad_day_of_month&) {
    check("last day of month -- oops bad exception", false);
  }

  //Not a leap year -- now Feb 29 is bad
  try {
    date d23(1999, Feb, 29);
    check("day out of range", false);
    //never reached if working -- but stops compiler warnings :-)
    std::cout << "Oops: " << to_iso_string(d23) << std::endl;
  }
  catch (bad_day_of_month&) {
    check("day out of range", true);
  }

  //check out some special values
  check("check not a date - false",           !d7.is_not_a_date());
  check("check positive infinity - false",    !d7.is_pos_infinity());
  check("check negative infinity - false",    !d7.is_neg_infinity());

  date d10(neg_infin);
  check("check negative infinity - true",     d10.is_infinity());
  d10 = d10 + twoDays; //still neg infinity
  check("check negative infinity - true",     d10.is_neg_infinity());

  date d11(pos_infin);
  check("check positive infinity - true",     d11.is_infinity());
  d11 = d11 + twoDays;
  check("check positive infinity add - true", d11.is_pos_infinity());

  date d12(not_a_date_time);
  check("check not a date",                   d12.is_not_a_date());
  check("check infinity compare   ",          d10 != d11);
  check("check infinity compare   ",          d10 < d11);
  check("check infinity nad compare   ",      d12 != d11);
  date d13(max_date_time);
  check("check infinity - max compare   ",      d13 < d11);
  check_equal("max date_time value   ",       d13, date(9999,Dec, 31));
  std::cout << to_simple_string(d13) << std::endl;
  date d14(min_date_time);
  check("check infinity - min compare   ",      d14 > d10);
  std::cout << to_simple_string(d14) << std::endl;
  check_equal("min date_time value   ",      d14, date(1400,Jan, 1));


  date d15(1400,1,1);
  std::cout << d15.day_of_week().as_long_string() << std::endl;
  check("check infinity - min compare   ",      d10 < d15);

  // most of this testing is in the gregorian_calendar tests
  std::cout << d15.julian_day() << std::endl;
  check_equal("check julian day   ", d15.julian_day(), 
      static_cast<boost::uint32_t>(2232400));
  check_equal("check modjulian day   ", d15.modjulian_day(), -167601);
  date d16(2004,2,29);
  check_equal("check julian day   ", d16.julian_day(), 
      static_cast<boost::uint32_t>(2453065));
  check_equal("check modjulian day   ", d16.modjulian_day(), 
      static_cast<boost::uint32_t>(53064));

  // most of this testing is in the gregorian_calendar tests
  date d31(2000, Jun, 1);
  check_equal("check iso week number   ", d31.week_number(), 22);
  date d32(2000, Aug, 1);
  check_equal("check iso week number   ", d32.week_number(), 31);
  date d33(2000, Oct, 1);
  check_equal("check iso week number   ", d33.week_number(), 39);
  date d34(2000, Dec, 1);
  check_equal("check iso week number   ", d34.week_number(), 48);
  date d35(2000, Dec, 24);
  check_equal("check iso week number   ", d35.week_number(), 51);
  date d36(2000, Dec, 25);
  check_equal("check iso week number   ", d36.week_number(), 52);
  date d37(2000, Dec, 31);
  check_equal("check iso week number   ", d37.week_number(), 52);
  date d38(2001, Jan, 1);
  check_equal("check iso week number   ", d38.week_number(), 1);

  try {
    int dayofyear1 = d38.day_of_year();
    check_equal("check day of year number", dayofyear1, 1);
    check_equal("check day of year number", d37.day_of_year(), 366);
    date d39(2001,Dec,31);
    check_equal("check day of year number", d39.day_of_year(), 365);
    date d40(2000,Feb,29);
    check_equal("check day of year number", d40.day_of_year(), 60);
    date d41(1400,Jan,1);
    check_equal("check day of year number", d41.day_of_year(), 1);
    date d42(1400,Jan,1);
    check_equal("check day of year number", d42.day_of_year(), 1);
    date d43(2002,Nov,17);
    check_equal("check day of year number", d43.day_of_year(), 321);
  }
  catch(std::exception& e) {
    std::cout << e.what() << std::endl;
    check("check day of year number", false);
  }

  //converts to date and back -- should get same result
  check_equal("tm conversion functions 2000-1-1", date_from_tm(to_tm(d2)), d2);
  check_equal("tm conversion functions 1900-1-1", date_from_tm(to_tm(d1)), d1);
  check_equal("tm conversion functions min date 1400-1-1 ", date_from_tm(to_tm(d14)), d14);
  check_equal("tm conversion functions max date 9999-12-31", date_from_tm(to_tm(d13)), d13);

  try{
    date d(neg_infin);
    tm d_tm = to_tm(d);
    check("Exception not thrown (special_value to_tm)", false);
    std::cout << d_tm.tm_sec << std::endl; //does nothing useful but stops compiler from complaining about unused d_tm
  }catch(std::out_of_range&){
    check("Caught expected exception (special_value to_tm)", true);
  }catch(...){
    check("Caught un-expected exception (special_value to_tm)", false);
  }

  // trac-13159
  test_yearlimit(    0, false);
  test_yearlimit( 1399, false);
  test_yearlimit( 1400,  true);
  test_yearlimit( 1401,  true);
  test_yearlimit( 9999,  true);
  test_yearlimit(10000, false);
  test_yearlimit(10001, false);

  return printTestStats();
}