/**
 * 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.cassandra.serializers;

import java.nio.ByteBuffer;
import java.util.concurrent.TimeUnit;

import org.junit.Test;

public class TimeSerializerTest
{
    @Test
    public void testSerializerFromString()
    {
        // nano
        long expected = 5;
        Long time = TimeSerializer.timeStringToLong("00:00:00.000000005");
        assert time == expected : String.format("Failed nano conversion.  Expected %s, got %s", expected, time);

        // usec
        expected = TimeUnit.MICROSECONDS.toNanos(123);
        time = TimeSerializer.timeStringToLong("00:00:00.000123000");
        assert time == expected : String.format("Failed usec conversion.  Expected %s, got %s", expected, time);

        // milli
        expected = TimeUnit.MILLISECONDS.toNanos(123);
        time = TimeSerializer.timeStringToLong("00:00:00.123000");
        assert time == expected : String.format("Failed milli conversion.  Expected %s, got %s", expected, time);

        // sec
        expected = TimeUnit.SECONDS.toNanos(15);
        time = TimeSerializer.timeStringToLong("00:00:15.000");
        assert time == expected : String.format("Failed sec conversion.  Expected %s, got %s", expected, time);

        // min
        expected = TimeUnit.MINUTES.toNanos(13);
        time = TimeSerializer.timeStringToLong("00:13:00.000");
        assert time == expected : String.format("Failed min conversion.  Expected %s, got %s", expected, time);

        // hour
        expected = TimeUnit.HOURS.toNanos(2);
        time = TimeSerializer.timeStringToLong("02:0:00.000");
        assert time == expected : String.format("Failed min conversion.  Expected %s, got %s", expected, time);

        // complex
        expected = buildExpected(4, 31, 12, 123, 456, 789);
        time = TimeSerializer.timeStringToLong("4:31:12.123456789");
        assert time == expected : String.format("Failed complex conversion.  Expected %s, got %s", expected, time);

        // upper bound
        expected = buildExpected(23, 59, 59, 999, 999, 999);
        time = TimeSerializer.timeStringToLong("23:59:59.999999999");
        assert time == expected : String.format("Failed upper bounds conversion.  Expected %s, got %s", expected, time);

        // Test partial nano
        expected = buildExpected(12, 13, 14, 123, 654, 120);
        time = TimeSerializer.timeStringToLong("12:13:14.12365412");
        assert time == expected : String.format("Failed partial nano timestring.  Expected %s, got %s", expected, time);

        // Test raw long value
        expected = 10;
        time = TimeSerializer.timeStringToLong("10");
        assert time == expected : String.format("Failed long conversion.  Expected %s, got %s", expected, time);

        // Test 0 long
        expected = 0;
        time = TimeSerializer.timeStringToLong("0");
        assert time == expected : String.format("Failed long conversion.  Expected %s, got %s", expected, time);
    }

    private long buildExpected(int hour, int minute, int second, int milli, int micro, int nano)
    {
        return  TimeUnit.HOURS.toNanos(hour) +
                TimeUnit.MINUTES.toNanos(minute) +
                TimeUnit.SECONDS.toNanos(second) +
                TimeUnit.MILLISECONDS.toNanos(milli) +
                TimeUnit.MICROSECONDS.toNanos(micro) +
                nano;
    }

    @Test
    public void testSerializerToString()
    {
        String source = "00:00:00.000000011";
        Long time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "00:00:00.000012311";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "00:00:00.123000000";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "00:00:12.123450000";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "00:34:12.123450000";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "15:00:12.123450000";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        // boundaries
        source = "00:00:00.000000000";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        source = "23:59:59.999999999";
        time = TimeSerializer.timeStringToLong(source);
        assert(source.equals(TimeSerializer.instance.toString(time)));

        // truncated
        source = "01:14:18.12";
        time = TimeSerializer.timeStringToLong(source);
        String result = TimeSerializer.instance.toString(time);
        assert(result.equals("01:14:18.120000000"));

        source = "01:14:18.1201";
        time = TimeSerializer.timeStringToLong(source);
        result = TimeSerializer.instance.toString(time);
        assert(result.equals("01:14:18.120100000"));

        source = "01:14:18.1201098";
        time = TimeSerializer.timeStringToLong(source);
        result = TimeSerializer.instance.toString(time);
        assert(result.equals("01:14:18.120109800"));
    }

    @Test public void testSerialization()
    {
        String source = "01:01:01.123123123";
        Long nt = TimeSerializer.timeStringToLong(source);

        ByteBuffer buf = TimeSerializer.instance.serialize(nt);
        TimeSerializer.instance.validate(buf);

        Long result = TimeSerializer.instance.deserialize(buf);
        String strResult = TimeSerializer.instance.toString(result);

        assert(strResult.equals(source));
    }

    @Test (expected=MarshalException.class)
    public void testBadHourLow()
    {
        Long time = TimeSerializer.timeStringToLong("-1:0:0.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadHourHigh()
    {
        Long time = TimeSerializer.timeStringToLong("24:0:0.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadMinuteLow()
    {
        Long time = TimeSerializer.timeStringToLong("23:-1:0.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadMinuteHigh()
    {
        Long time = TimeSerializer.timeStringToLong("23:60:0.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testEmpty()
    {
        Long time = TimeSerializer.timeStringToLong("");
    }

    @Test (expected=MarshalException.class)
    public void testBadSecondLow()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:-1.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadSecondHigh()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:60.123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadSecondHighNoMilli()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:60");
    }

    @Test (expected=MarshalException.class)
    public void testBadNanoLow()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:59.-123456789");
    }

    @Test (expected=MarshalException.class)
    public void testBadNanoHigh()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:59.1234567899");
    }

    @Test (expected=MarshalException.class)
    public void testBadNanoCharacter()
    {
        Long time = TimeSerializer.timeStringToLong("23:59:59.12345A789");
    }

    @Test (expected=MarshalException.class)
    public void testNegativeLongTime()
    {
        Long time = TimeSerializer.timeStringToLong("-10");
    }

    @Test (expected=MarshalException.class)
    public void testRawLongOverflow()
    {
        Long input = TimeUnit.DAYS.toNanos(1) + 1;
        Long time = TimeSerializer.timeStringToLong(input.toString());
    }
}
