/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.lens.cube.metadata;

import static java.util.Calendar.DAY_OF_MONTH;
import static java.util.Calendar.MONTH;

import static org.apache.lens.cube.metadata.DateUtil.*;
import static org.apache.lens.cube.metadata.UpdatePeriod.*;

import static org.apache.commons.lang.time.DateUtils.addMilliseconds;

import static org.testng.Assert.assertEquals;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Set;

import org.apache.lens.server.api.error.LensException;

import org.apache.commons.lang.time.DateUtils;

import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

import com.beust.jcommander.internal.Sets;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;

/**
 * Unit tests for cube DateUtil class TestDateUtil.
 */
@Slf4j
public class TestDateUtil {

  public static final String[] TEST_PAIRS = {
    "2013-Jan-01", "2013-Jan-31", "2013-Jan-01", "2013-May-31",
    "2013-Jan-01", "2013-Dec-31", "2013-Feb-01", "2013-Apr-25",
    "2012-Feb-01", "2013-Feb-01", "2011-Feb-01", "2013-Feb-01",
    "2013-Jan-02", "2013-Feb-02", "2013-Jan-02", "2013-Mar-02",
  };

  public static final SimpleDateFormat DATE_FMT = new SimpleDateFormat("yyyy-MMM-dd");

  private Date[] pairs;

  @BeforeTest
  public void setUp() {
    pairs = new Date[TEST_PAIRS.length];
    for (int i = 0; i < TEST_PAIRS.length; i++) {
      try {
        pairs[i] = DATE_FMT.parse(TEST_PAIRS[i]);
      } catch (ParseException e) {
        log.error("Parsing exception while setup.", e);
      }
    }
  }


  @Test
  public void testMonthsBetween() throws Exception {
    int i = 0;
    assertEquals(getMonthlyCoveringInfo(pairs[i], DateUtils.round(pairs[i + 1], MONTH)),
      new CoveringInfo(1, true),
      "2013-Jan-01 to 2013-Jan-31");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], DateUtils.round(pairs[i + 1], MONTH)),
      new CoveringInfo(5, true),
      "2013-Jan-01 to 2013-May-31");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], DateUtils.round(pairs[i + 1], MONTH)),
      new CoveringInfo(12, true),
      "2013-Jan-01 to 2013-Dec-31");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(2, false),
      "2013-Feb-01 to 2013-Apr-25");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(12, true),
      "2012-Feb-01 to 2013-Feb-01");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(24, true),
      "2011-Feb-01 to 2013-Feb-01");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "2013-Jan-02 to 2013-Feb-02");

    i += 2;
    assertEquals(getMonthlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(1, false),
      "2013-Jan-02 to 2013-Mar-02");
  }

  @Test
  public void testQuartersBetween() throws Exception {
    int i = 0;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "2013-Jan-01 to 2013-Jan-31");

    i += 2;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(1, false),
      "2013-Jan-01 to 2013-May-31");

    i += 2;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], DateUtils.round(pairs[i + 1], MONTH)),
      new CoveringInfo(4, true),
      "2013-Jan-01 to 2013-Dec-31");

    i += 2;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "2013-Feb-01 to 2013-Apr-25");

    i += 2;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(3, false),
      "2012-Feb-01 to 2013-Feb-01");

    i += 2;
    assertEquals(getQuarterlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(7, false),
      "2011-Feb-01 to 2013-Feb-01");
  }

  @Test
  public void testYearsBetween() throws Exception {
    int i = 0;
    assertEquals(getYearlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "" + pairs[i] + "->" + pairs[i + 1]);

    i += 2;
    assertEquals(getYearlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "" + pairs[i] + "->" + pairs[i + 1]);

    i += 2;
    assertEquals(getYearlyCoveringInfo(pairs[i], DateUtils.round(pairs[i + 1], MONTH)),
      new CoveringInfo(1, true), ""
        + pairs[i] + "->" + pairs[i + 1]);

    i += 2;
    assertEquals(getYearlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "" + pairs[i] + "->" + pairs[i + 1]);

    i += 2;
    assertEquals(getYearlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(0, false),
      "" + pairs[i] + "->" + pairs[i + 1]);

    i += 2;
    assertEquals(getYearlyCoveringInfo(pairs[i], pairs[i + 1]), new CoveringInfo(1, false),
      "" + pairs[i] + "->" + pairs[i + 1]);
  }

  @Test
  public void testWeeksBetween() throws Exception {
    CoveringInfo weeks;

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-26"), DATE_FMT.parse("2013-Jun-2"));
    assertEquals(weeks, new CoveringInfo(1, true), "2013-May-26 to 2013-Jun-2");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-27"), DATE_FMT.parse("2013-Jun-3"));
    assertEquals(weeks, new CoveringInfo(0, false), "2013-May-26 to 2013-Jun-2");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-27"), DATE_FMT.parse("2013-Jun-9"));
    assertEquals(weeks, new CoveringInfo(1, false), "2013-May-26 to 2013-Jun-2");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-27"), DATE_FMT.parse("2013-Jun-1"));
    assertEquals(weeks, new CoveringInfo(0, false), "2013-May-27 to 2013-Jun-1");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-25"), DATE_FMT.parse("2013-Jun-2"));
    assertEquals(weeks, new CoveringInfo(1, false), "2013-May-25 to 2013-Jun-1");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-26"), DATE_FMT.parse("2013-Jun-9"));
    assertEquals(weeks, new CoveringInfo(2, true), "2013-May-26 to 2013-Jun-8");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2013-May-26"), DATE_FMT.parse("2013-Jun-10"));
    assertEquals(weeks, new CoveringInfo(2, false), "2013-May-26 to 2013-Jun-10");

    weeks = getWeeklyCoveringInfo(DATE_FMT.parse("2015-Dec-27"), DATE_FMT.parse("2016-Jan-03"));
    assertEquals(weeks, new CoveringInfo(1, true), "2015-Dec-27 to 2016-Jan-03");
  }

  @Test
  public void testNowWithGranularity() throws Exception {
    String dateFmt = "yyyy/MM/dd-HH.mm.ss.SSS";
    // Tuesday Sept 23, 2014, 12.02.05.500 pm
    String testDateStr = "2014/09/23-12.02.05.500";
    final SimpleDateFormat sdf = new SimpleDateFormat(dateFmt);
    final Date testDate = sdf.parse(testDateStr);

    System.out.print("@@ testDateStr=" + testDateStr + " parsed date=" + testDate);

    // Tests without a diff, just resolve now with different granularity
    assertEquals(testDateStr, sdf.format(resolveDate("now", testDate)));
    assertEquals("2014/01/01-00.00.00.000", sdf.format(resolveDate("now.year", testDate)));
    assertEquals("2014/09/01-00.00.00.000", sdf.format(resolveDate("now.month", testDate)));
    // Start of week resolves to Sunday
    assertEquals("2014/09/21-00.00.00.000", sdf.format(resolveDate("now.week", testDate)));
    assertEquals("2014/09/23-00.00.00.000", sdf.format(resolveDate("now.day", testDate)));
    assertEquals("2014/09/23-12.00.00.000", sdf.format(resolveDate("now.hour", testDate)));
    assertEquals("2014/09/23-12.02.00.000", sdf.format(resolveDate("now.minute", testDate)));
    assertEquals("2014/09/23-12.02.05.000", sdf.format(resolveDate("now.second", testDate)));

    // Tests with a diff
    assertEquals("2014/09/22-00.00.00.000", sdf.format(resolveDate("now.day -1day", testDate)));
    assertEquals("2014/09/23-10.00.00.000", sdf.format(resolveDate("now.hour -2hour", testDate)));
    assertEquals("2014/09/24-12.00.00.000", sdf.format(resolveDate("now.hour +24hour", testDate)));
    assertEquals("2015/01/01-00.00.00.000", sdf.format(resolveDate("now.year +1year", testDate)));
    assertEquals("2014/02/01-00.00.00.000", sdf.format(resolveDate("now.year +1month", testDate)));
  }

  @Test
  public void testFloorDate() throws ParseException {
    Date date = ABSDATE_PARSER.get().parse("2015-01-01-00:00:00,000");
    Date curDate = date;
    for (int i = 0; i < 284; i++) {
      assertEquals(getFloorDate(curDate, YEARLY), date);
      curDate = addMilliseconds(curDate, 111111111);
    }
    assertEquals(getFloorDate(curDate, YEARLY), DateUtils.addYears(date, 1));
    assertEquals(getFloorDate(date, WEEKLY), ABSDATE_PARSER.get().parse("2014-12-28-00:00:00,000"));
  }

  @Test
  public void testCeilDate() throws ParseException {
    Date date = ABSDATE_PARSER.get().parse("2015-12-26-06:30:15,040");
    assertEquals(getCeilDate(date, YEARLY), ABSDATE_PARSER.get().parse("2016-01-01-00:00:00,000"));
    assertEquals(getCeilDate(date, MONTHLY), ABSDATE_PARSER.get().parse("2016-01-01-00:00:00,000"));
    assertEquals(getCeilDate(date, DAILY), ABSDATE_PARSER.get().parse("2015-12-27-00:00:00,000"));
    assertEquals(getCeilDate(date, HOURLY), ABSDATE_PARSER.get().parse("2015-12-26-07:00:00,000"));
    assertEquals(getCeilDate(date, MINUTELY), ABSDATE_PARSER.get().parse("2015-12-26-06:31:00,000"));
    assertEquals(getCeilDate(date, SECONDLY), ABSDATE_PARSER.get().parse("2015-12-26-06:30:16,000"));
    assertEquals(getCeilDate(date, WEEKLY), ABSDATE_PARSER.get().parse("2015-12-27-00:00:00,000"));
  }

  @Test
  public void testTimeDiff() throws LensException {
    ArrayList<String> minusFourDays =
      Lists.newArrayList("-4 days", "-4days", "-4day", "-4 day", "- 4days", "- 4 day");
    ArrayList<String> plusFourDays =
      Lists.newArrayList("+4 days", "4 days", "+4days", "4day", "4 day", "+ 4days", "+ 4 day", "+4 day");
    Set<TimeDiff> diffs = Sets.newHashSet();
    for (String diffStr : minusFourDays) {
      diffs.add(TimeDiff.parseFrom(diffStr));
    }
    assertEquals(diffs.size(), 1);
    TimeDiff minusFourDaysDiff = diffs.iterator().next();
    assertEquals(minusFourDaysDiff.quantity, -4);
    assertEquals(minusFourDaysDiff.updatePeriod, DAILY);

    diffs.clear();
    for (String diffStr : plusFourDays) {
      diffs.add(TimeDiff.parseFrom(diffStr));
    }
    assertEquals(diffs.size(), 1);
    TimeDiff plusFourDaysDiff = diffs.iterator().next();
    assertEquals(plusFourDaysDiff.quantity, 4);
    assertEquals(plusFourDaysDiff.updatePeriod, DAILY);
    Date now = new Date();
    assertEquals(minusFourDaysDiff.offsetFrom(plusFourDaysDiff.offsetFrom(now)), now);
    assertEquals(plusFourDaysDiff.offsetFrom(minusFourDaysDiff.offsetFrom(now)), now);
    assertEquals(minusFourDaysDiff.negativeOffsetFrom(now), plusFourDaysDiff.offsetFrom(now));
    assertEquals(minusFourDaysDiff.offsetFrom(now), plusFourDaysDiff.negativeOffsetFrom(now));
  }

  @Test
  public void testRelativeToAbsolute() throws LensException {
    Date now = new Date();
    Date nowDay = DateUtils.truncate(now, DAY_OF_MONTH);
    Date nowDayMinus2Days = DateUtils.add(nowDay, DAY_OF_MONTH, -2);
    assertEquals(relativeToAbsolute("now", now), DateUtil.formatAbsDate(now));
    assertEquals(relativeToAbsolute("now.day", now), DateUtil.formatAbsDate(nowDay));
    assertEquals(relativeToAbsolute("now.day - 2 days", now), DateUtil.formatAbsDate(nowDayMinus2Days));
    assertEquals(relativeToAbsolute("now.day - 2 day", now), DateUtil.formatAbsDate(nowDayMinus2Days));
    assertEquals(relativeToAbsolute("now.day - 2day", now), DateUtil.formatAbsDate(nowDayMinus2Days));
    assertEquals(relativeToAbsolute("now.day -2 day", now), DateUtil.formatAbsDate(nowDayMinus2Days));
    assertEquals(relativeToAbsolute("now.day -2 days", now), DateUtil.formatAbsDate(nowDayMinus2Days));
  }
  @Test
  public void testTimestamp() throws LensException {
    Date now = new Date();
    assertEquals(DateUtil.resolveDate(String.valueOf(now.getTime()+1), now), new Date(now.getTime()+1));
  }
}