/**
 * This software was developed and / or modified by Raytheon Company,
 * pursuant to Contract DG133W-05-CQ-1067 with the US Government.
 * 
 * U.S. EXPORT CONTROLLED TECHNICAL DATA
 * This software product contains export-restricted data whose
 * export/transfer/disclosure is restricted by U.S. law. Dissemination
 * to non-U.S. persons whether in the United States or abroad requires
 * an export license or other authorization.
 * 
 * Contractor Name:        Raytheon Company
 * Contractor Address:     6825 Pine Street, Suite 340
 *                         Mail Stop B8
 *                         Omaha, NE 68106
 *                         402.291.0100
 * 
 * See the AWIPS II Master Rights File ("Master Rights File.pdf") for
 * further licensing information.
 **/
package com.raytheon.edex.plugin.time;

import java.util.Date;

import junit.framework.Assert;
import junit.framework.TestCase;

import org.junit.After;
import org.junit.Before;

import com.raytheon.uf.common.time.TimeRange;

/**
 * Test case for TimeRange class based on AWIPS Common test case
 * 
 * <pre>
 * SOFTWARE HISTORY
 * Date         Ticket#    Engineer    Description
 * ------------ ---------- ----------- --------------------------
 * Jun 19, 2007            chammack    Initial Creation.	
 * 
 * </pre>
 * 
 * @author chammack
 * @version 1.0
 */

public class TestTimeRange extends TestCase {
    private final TimeRange n1 = new TimeRange();

    private final TimeRange n2 = new TimeRange();

    private final TimeRange tr = new TimeRange(100000, 200); // good time

    // range
    public static void main(String[] args) {

    }

    /**
     * @throws java.lang.Exception
     */
    @Override
    @Before
    public void setUp() throws Exception {
    }

    /**
     * @throws java.lang.Exception
     */
    @Override
    @After
    public void tearDown() throws Exception {
    }

    public void testValid() {
        Assert.assertFalse(n1.isValid());
    }

    public void testEquals() {
        Assert.assertTrue(n1.equals(n2));
        Assert.assertFalse(n1.equals(tr));
        Assert.assertFalse(tr.equals(n1));
    }

    public void testJoin() {
        TimeRange x = n1.join(n2);
        TimeRange y = n1.join(tr);
        TimeRange z = tr.join(n1);

        Assert.assertFalse(x.isValid());
        Assert.assertFalse(y.isValid());
        Assert.assertFalse(z.isValid());
    }

    public void testIntersection() {
        TimeRange x = n1.intersection(n2);
        TimeRange y = n1.intersection(tr);
        TimeRange z = tr.intersection(n1);

        Assert.assertFalse(x.isValid());
        Assert.assertFalse(y.isValid());
        Assert.assertFalse(z.isValid());
    }

    public void testGap() {
        TimeRange x = n1.gap(n2);
        TimeRange y = n1.gap(tr);
        TimeRange z = tr.gap(n1);

        Assert.assertFalse(x.isValid());
        Assert.assertFalse(y.isValid());
        Assert.assertFalse(z.isValid());
    }

    public void testSpan() {
        TimeRange x = n1.span(n2);
        TimeRange y = n1.span(tr);
        TimeRange z = tr.span(n1);

        Assert.assertFalse(x.isValid());
        Assert.assertFalse(y.isValid());
        Assert.assertFalse(z.isValid());
    }

    public void testCombineWith() {
        TimeRange x = n1.combineWith(n2);
        TimeRange y = n1.combineWith(tr);
        TimeRange z = tr.combineWith(n1);

        Assert.assertFalse(x.isValid());
        Assert.assertTrue(y.isValid());
        Assert.assertTrue(z.isValid());

    }

    public void testConstructor() {
        Date t1 = new Date();
        Date t2 = new Date(t1.getTime() + 1000);
        TimeRange tr10 = new TimeRange(t1, t2);
        TimeRange tr11 = new TimeRange(t2, t1);
        TimeRange tr12 = new TimeRange(t1, 1000);
        TimeRange tr13 = new TimeRange(t2, -1000);

        Assert.assertEquals(tr10.getDuration(), 1000);
        Assert.assertEquals(tr11.getDuration(), 1000);
        Assert.assertEquals(tr12.getDuration(), 1000);
        Assert.assertEquals(tr13.getDuration(), 1000);

        Assert.assertEquals(tr10.getStart(), t1);
        Assert.assertEquals(tr11.getStart(), t1);
        Assert.assertEquals(tr12.getStart(), t1);

        Assert.assertEquals(tr10.getEnd(), t2);
        Assert.assertEquals(tr11.getEnd(), t2);
        Assert.assertEquals(tr12.getEnd(), t2);

        Assert.assertEquals(tr10, tr11);
        Assert.assertEquals(tr10, tr12);
        Assert.assertEquals(tr10, tr13);
    }

    public void testComparison() {
        Date[] t = new Date[8];
        TimeRange[] trtest = new TimeRange[29];
        for (int i = 0; i < t.length; i++) {
            t[i] = new Date(i * 100);
        }

        for (int i = 0, k = 0; i < 7; i++) {
            for (int j = i + 1; j < 8; j++) {
                trtest[k++] = new TimeRange(t[i], t[j]);
            }
        }

        TimeRange trbase = new TimeRange(t[2], t[5]);

        boolean[] answers = { false, false, true, true, true, true, true,
                false, true, true, true, true, true, true, true, true, true,
                true, true, true, true, true, true, true, true, false, false,
                false };

        for (int k = 0; k < 28; k++) {
            Assert.assertEquals(trbase.overlaps(trtest[k]), answers[k]);
        }

        answers = new boolean[] { false, true, false, false, false, false,
                false, true, false, false, false, false, false, false, false,
                false, false, false, false, false, false, false, false, false,
                false, true, true, false };

        for (int k = 0; k < 28; k++) {
            Assert.assertEquals(trbase.isAdjacentTo(trtest[k]), answers[k]);
        }

        answers = new boolean[] { false, false, true, true, true, false, false,
                false };

        for (int k = 0; k < 8; k++) {
            Assert.assertEquals(trbase.contains(t[k]), answers[k]);
        }

        int[] answersInt = { 28, 4, 4, 4, 4, 5, 6, 10, 10, 10, 10, 11, 12, 15,
                15, 15, 16, 17, 15, 15, 16, 17, 15, 16, 17, 16, 17, 28 };

        for (int k = 0; k < 28; k++) {
            TimeRange trJoin = trbase.join(trtest[k]);
            if (answersInt[k] == 28) {
                Assert.assertFalse(trJoin.isValid());
            } else if (answersInt[k] != 28) {
                Assert.assertTrue(trJoin.isValid());
            } else if (!trJoin.isValid()) {
                continue;
            } else {
                Assert.assertEquals(trJoin, trtest[answersInt[k]]);
            }

        }

        answersInt = new int[] { 28, 28, 13, 14, 15, 15, 15, 28, 13, 14, 15,
                15, 15, 13, 14, 15, 15, 15, 18, 19, 19, 19, 22, 22, 22, 28, 28,
                28 };

        for (int k = 0; k < 28; k++) {
            TimeRange trInt = trbase.intersection(trtest[k]);
            if (answersInt[k] == 28) {
                Assert.assertFalse(trInt.isValid());
            } else if (answersInt[k] != 28) {
                Assert.assertTrue(trInt.isValid());
            } else if (!trInt.isValid()) {
                continue;
            } else {
                Assert.assertEquals(trInt, trtest[answersInt[k]]);
            }

        }

        answersInt = new int[] { 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
                28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 25 };

        for (int k = 0; k < 28; k++) {
            TimeRange trgap = trbase.gap(trtest[k]);
            if (answersInt[k] == 28) {
                Assert.assertFalse(trgap.isValid());
            } else if (answersInt[k] != 28) {
                Assert.assertTrue(trgap.isValid());
            } else if (!trgap.isValid()) {
                continue;
            } else {
                Assert.assertEquals(trgap, trtest[answersInt[k]]);
            }

        }

        answersInt = new int[] { 4, 4, 4, 4, 4, 5, 6, 10, 10, 10, 10, 11, 12,
                15, 15, 15, 16, 17, 15, 15, 16, 17, 15, 16, 17, 16, 17, 17 };

        for (int k = 0; k < 28; k++) {
            TimeRange trcombine = trbase.combineWith(trtest[k]);
            if (answersInt[k] == 28) {
                Assert.assertFalse(trcombine.isValid());
            } else if (answersInt[k] != 28) {
                Assert.assertTrue(trcombine.isValid());
            } else if (!trcombine.isValid()) {
                continue;
            } else {
                Assert.assertEquals(trcombine, trtest[answersInt[k]]);
            }

        }

        answersInt = new int[] { 4, 4, 4, 4, 4, 5, 6, 10, 10, 10, 10, 11, 12,
                15, 15, 15, 16, 17, 15, 15, 16, 17, 15, 16, 17, 16, 17, 17 };

        for (int k = 0; k < 28; k++) {
            TimeRange trspan = trbase.span(trtest[k]);
            if (answersInt[k] == 28) {
                Assert.assertFalse(trspan.isValid());
            } else if (answersInt[k] != 28) {
                Assert.assertTrue(trspan.isValid());
            } else if (!trspan.isValid()) {
                continue;
            } else {
                Assert.assertEquals(trspan, trtest[answersInt[k]]);
            }

        }
    }

    public void testContains() {
        TimeRange con1 = new TimeRange(1000, 2000);
        TimeRange con2 = new TimeRange(50, 2500);
        TimeRange con3 = new TimeRange(1000, 2500);
        TimeRange con4 = new TimeRange(20, 25);
        TimeRange con5 = new TimeRange(3000, 3500);
        TimeRange con6 = new TimeRange(200, 1500);
        TimeRange con7 = new TimeRange(1900, 2100);
        TimeRange con8 = new TimeRange(1100, 1800);
        TimeRange con9 = new TimeRange(1000, 1400);
        TimeRange con10 = new TimeRange(1100, 2000);

        Assert.assertFalse(con1.contains(con2));

        Assert.assertFalse(con1.contains(con3));

        Assert.assertFalse(con1.contains(con4));

        Assert.assertFalse(con1.contains(con5));

        Assert.assertFalse(con1.contains(con6));

        Assert.assertFalse(con1.contains(con7));

        Assert.assertTrue(con1.contains(con8));

        Assert.assertTrue(con1.contains(con9));

        Assert.assertTrue(con1.contains(con10));

        Assert.assertTrue(con1.contains(con1));

    }

    public void testContainsSpecial() {
        TimeRange zero = new TimeRange(1000, 1000);
        TimeRange nonZeroBefore = new TimeRange(900, 1000);
        TimeRange nonZeroAfter = new TimeRange(1001, 1100);
        TimeRange nonZeroIncAfter = new TimeRange(1000, 1100);
        TimeRange bigSpan = new TimeRange(900, 1100);
        Date beforeBaseTime = new Date(999);
        Date baseTime = new Date(1000);
        Date afterBaseTime = new Date(1001);

        Assert.assertTrue(zero.contains(baseTime));
        Assert.assertFalse(zero.contains(beforeBaseTime));
        Assert.assertFalse(zero.contains(afterBaseTime));

        Assert.assertFalse(nonZeroBefore.contains(zero));
        Assert.assertFalse(nonZeroAfter.contains(zero));
        Assert.assertTrue(nonZeroIncAfter.contains(zero));

        Assert.assertTrue(zero.contains(zero));

        Assert.assertFalse(zero.contains(nonZeroBefore));
        Assert.assertFalse(zero.contains(nonZeroAfter));

        Assert.assertFalse(zero.contains(bigSpan));
        Assert.assertFalse(zero.contains(nonZeroIncAfter));

        Assert.assertFalse(nonZeroBefore.overlaps(zero));
        Assert.assertFalse(nonZeroAfter.overlaps(zero));
        Assert.assertTrue(nonZeroIncAfter.overlaps(zero));
        Assert.assertTrue(bigSpan.overlaps(zero));
        Assert.assertTrue(zero.overlaps(zero));
        Assert.assertFalse(zero.overlaps(nonZeroBefore));
        Assert.assertFalse(zero.overlaps(nonZeroAfter));
        Assert.assertTrue(zero.overlaps(nonZeroIncAfter));
    }

    public void testIntersectionZero() {
        // intersection with 0 duration test
        TimeRange zero = new TimeRange(1000, 1000);
        TimeRange interLess = new TimeRange(900, 1000);
        TimeRange interAfter = new TimeRange(1002, 2000);
        TimeRange interAfterInc = new TimeRange(1000, 2000);
        TimeRange interSpan = new TimeRange(500, 2000);

        TimeRange answer = interLess.intersection(zero);
        Assert.assertFalse(answer.isValid());

        answer = interAfter.intersection(zero);
        Assert.assertFalse(answer.isValid());

        answer = interAfterInc.intersection(zero);
        Assert.assertFalse(answer.isValid());

        answer = interSpan.intersection(zero);
        Assert.assertFalse(answer.isValid());

        answer = zero.intersection(interLess);
        Assert.assertFalse(answer.isValid());

        answer = zero.intersection(interAfter);
        Assert.assertFalse(answer.isValid());

        answer = zero.intersection(interAfterInc);
        Assert.assertFalse(answer.isValid());

        answer = zero.intersection(interSpan);
        Assert.assertFalse(answer.isValid());

    }

    public void testCenterTime() {
        Date start = new Date();
        TimeRange trvalid = new TimeRange(start, 3600);
        Date trcenter = new Date(start.getTime() + 1800);

        Assert.assertEquals(trvalid.getCenterTime(), trcenter);

    }

    public void testDurationAsPrettyString() {
        Date start = new Date();
        TimeRange tr = new TimeRange(start, 3600 * 24);
        Assert.assertEquals("1d", tr.durationAsPrettyString());

        tr = new TimeRange(start, 3600);
        Assert.assertEquals("1h", tr.durationAsPrettyString());

        tr = new TimeRange(start, 60);
        Assert.assertEquals("0h 1m", tr.durationAsPrettyString());

        tr = new TimeRange(start, 1);
        Assert.assertEquals("0h 0m 1s", tr.durationAsPrettyString());

        tr = new TimeRange(start, 3600 * 24 + 1);
        Assert.assertEquals("1d 0h 0m 1s", tr.durationAsPrettyString());

    }

}