/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
package com.nokia.mj.test.lapi;

import j2meunit.framework.*;
import javax.microedition.location.*;

public class PeriodicUpdateTest extends TestCase implements LocationListener
{
    final static int ONLY_STATUS_INTERVAL = 0;

    final static int DEFAULT_INTERVAL = -1;

    final static int INTERVAL = 10;

    final static int TIMEOUT = 3;

    final static int MAXAGE = 2;

    final static int LARGE_TIMEOUT = 12;

    final static int LARGE_MAXAGE = 11;

    final static int[] badInterval = new int[] { -2, -12345, Integer.MIN_VALUE };

    final static int[] badTimeout = new int[] { 0, -2, -12345,
            Integer.MIN_VALUE
                                              };

    final static int[] badMaxAge = badTimeout;

    private Coordinates currentCoords;

    private Location[] iLocations;

    private int iNumUpdates;

    private long[] iLocUpdateCallbackTime;

    final static int TIMETOFIX = 5;

    protected LocationProvider iLP = null;

    long[] iTimeArray;

    public PeriodicUpdateTest()
    {
    }

    public PeriodicUpdateTest(String sTestName, TestMethod rTestMethod)
    {
        super(sTestName, rTestMethod);
    }

    /***************************************************************************
     * Creates the test suite. You need to add a new aSuite.addTest antry for
     * any new test methods, otherwise they won't be run.
     */
    public Test suite()
    {
        TestSuite aSuite = new TestSuite();

        aSuite.addTest(new PeriodicUpdateTest("testBadArguments",
                                              new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc).testBadArguments();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest("testGoodArguments",
                                              new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc).testGoodArguments();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest("testLocationListenerDefault",
                                              new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc).testLocationListenerDefault();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest(
                           "testLocationListenerInterval_1s", new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc)
                .testLocationListenerInterval_1s();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest(
                           "testLocationListenerInterval_3s", new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc)
                .testLocationListenerInterval_3s();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest(
                           "testLocationListenerInterval_7s", new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc)
                .testLocationListenerInterval_7s();
            }
        }));

        aSuite.addTest(new PeriodicUpdateTest("testChangeListener",
                                              new TestMethod()
        {
            public void run(TestCase tc)
            {
                ((PeriodicUpdateTest) tc).testChangeListener();
            }
        }));

        return aSuite;

    }

    private void assertContinue(String aReason, boolean aCond)
    {
        if (!aCond)
            assertTrue(aReason, false);
    }

    public void testBadArguments()
    {
        providerSetUp(null);
        assertContinue("LocationProvider is null", iLP != null);

        assertBad(INTERVAL, TIMEOUT, LARGE_MAXAGE); // MaxAge > Interval
        assertBad(INTERVAL, LARGE_TIMEOUT, MAXAGE); // Timeout > Interval
        assertBad(INTERVAL, LARGE_TIMEOUT, LARGE_MAXAGE);

        for (int i = 0; i < badInterval.length; ++i)
        {
            assertBad(badInterval[i], TIMEOUT, MAXAGE);
        }

        for (int i = 0; i < badTimeout.length; ++i)
        {
            assertBad(INTERVAL, badTimeout[i], MAXAGE);
            assertBad(INTERVAL, badTimeout[i], LARGE_MAXAGE);
        }

        for (int i = 0; i < badMaxAge.length; ++i)
        {
            assertBad(INTERVAL, TIMEOUT, badMaxAge[i]);
            assertBad(INTERVAL, LARGE_TIMEOUT, badMaxAge[i]);
        }

        for (int i = 0; i < badInterval.length; ++i)
        {
            for (int j = 0; j < badTimeout.length; ++j)
            {
                for (int k = 0; k < badMaxAge.length; ++k)
                {
                    assertBad(badInterval[i], badTimeout[j], badMaxAge[k]);
                }
            }
        }
        assertTrue("", true);
    }

    public void testGoodArguments()
    {
        providerSetUp(null);
        assertContinue("LocationProvider is null", iLP != null);

        // These arguments should not throw exceptions
        testGoodWithBad(this, DEFAULT_INTERVAL);
        testGoodWithBad(this, ONLY_STATUS_INTERVAL);

        testGoodWithBad(null, INTERVAL);
        testGoodWithBad(null, DEFAULT_INTERVAL);
        testGoodWithBad(null, ONLY_STATUS_INTERVAL);

        for (int i = 0; i < badInterval.length; ++i)
        {
            testGoodWithBad(null, badInterval[i]);
        }

        int bigValue = Integer.MAX_VALUE / 1000000;
        assertGood(this, bigValue, bigValue, bigValue);

        assertGood(this, Integer.MAX_VALUE, Integer.MAX_VALUE,
                   Integer.MAX_VALUE);

        assertTrue("", true);
    }

    public void testLocationListenerDefault()
    {
        final int MAXTIME = 1000 * (TIMETOFIX + 13 + 1); // Interval ~ 6.25

        providerSetUp(null); // Simulation PSY should be default
        assertContinue("LocationProvider is null", iLP != null);

        // Start listening for location changes
        iLP.setLocationListener(this, -1, -1, -1);

        getUpdates(2, MAXTIME);

        checkLocationData(iLocations[0]);
        checkLocationData(iLocations[1]);

        iLocations = null;
        assertTrue("", true);
    }

    public void testLocationListenerInterval_1s()
    {
        testInterval(1, 4);
        assertTrue("", true);
    }

    public void testLocationListenerInterval_3s()
    {
        testInterval(3, 5);
        assertTrue("", true);
    }

    public void testLocationListenerInterval_7s()
    {
        testInterval(7, 3);
        assertTrue("", true);
    }

    public void testChangeListener()
    {
        providerSetUp(null);
        assertContinue("LocationProvider is null", iLP != null);

        final int PERIOD1 = 10; // seconds
        final int PERIOD2 = 7; // seconds

        LocationListener listener = new LocationListener()
        {
            public void providerStateChanged(LocationProvider lp, int s)
            {
            }

            public void locationUpdated(LocationProvider lp, Location l)
            {
            }
        };

        // Change interval
        iLP.setLocationListener(this, PERIOD1, -1, -1);
        int maxtime = 1000 * (2 * PERIOD1 + TIMETOFIX);
        getUpdates(2, maxtime);

        iLP.setLocationListener(this, PERIOD2, -1, -1);
        maxtime = 1000 * (2 * PERIOD2 + TIMETOFIX);
        getUpdates(2, maxtime);

        // Change listener
        iLP.setLocationListener(listener, -1, -1, -1);

        try
        {
            if (iLP != null)
                iLP.setLocationListener(null, -1, -1, -1);
        }
        catch (Exception e)
        {
        }
        assertTrue("", true);
    }

    public void providerStateChanged(LocationProvider l, int event)
    {
    }

    public void locationUpdated(LocationProvider l, Location fix)
    {
        iLocUpdateCallbackTime[iNumUpdates] = System.currentTimeMillis();

        iLocations[iNumUpdates] = fix;
        ++iNumUpdates;
        assertContinue("LocationProvider is null", l != null);
    }

    // ------------------------ Helper methods -----------------------

    private void assertBad(int aInterval, int aTimeout, int aMaxAge)
    {
        try
        {
            iLP.setLocationListener(this, aInterval, aTimeout, aMaxAge);
            // Oops, no exception thrown, remove listener
            iLP.setLocationListener(null, -1, -1, -1);
            assertContinue("Bad arguments should throw exception: " + aInterval
                           + "," + aTimeout + "," + aMaxAge, false);
        }
        catch (IllegalArgumentException iae)
        {
            // OK
            assertContinue("no message allowed for the exception: " + iae, iae
                           .getMessage() == null);
        }
        catch (Exception e)
        {
            assertContinue("Unknown error: " + e, false);
        }
    }

    private void testGoodWithBad(LocationListener aListener, int aInterval)
    {
        assertGood(aListener, aInterval, LARGE_TIMEOUT, LARGE_MAXAGE);

        for (int i = 0; i < badTimeout.length; ++i)
        {
            assertGood(aListener, aInterval, badTimeout[i], LARGE_MAXAGE);
        }

        for (int i = 0; i < badMaxAge.length; ++i)
        {
            assertGood(aListener, aInterval, LARGE_TIMEOUT, badMaxAge[i]);
        }

        for (int j = 0; j < badTimeout.length; ++j)
        {
            for (int k = 0; k < badMaxAge.length; ++k)
            {
                assertGood(aListener, aInterval, badTimeout[j], badMaxAge[k]);
            }
        }
    }

    private void assertGood(LocationListener aListener, int aInterval,
                            int aTimeout, int aMaxAge)
    {
        try
        {
            iLP.setLocationListener(aListener, aInterval, aTimeout, aMaxAge);
        }
        catch (IllegalArgumentException iae)
        {
            assertContinue("setLocationListener(" + aListener + "," + aInterval
                           + "," + aTimeout + "," + aMaxAge + ") threw exception:\n"
                           + iae, false);
        }

        // remove listener
        try
        {
            if (iLP != null)
                iLP.setLocationListener(null, -1, -1, -1);
        }
        catch (Exception e)
        {
        }
    }

    private void testInterval(int aInterval, int aNumberOfFixes)
    {
        assertContinue("Must test with at least one fix!", aNumberOfFixes > 0);

        final int TIMETOFIX = 100; // 100 ms
        final int TIMEOUT = 1000 + 2 * TIMETOFIX;
        final int MAXTIME = 1000 * (aNumberOfFixes * aInterval) + TIMEOUT;

        Criteria criteria = new Criteria();
        criteria.setPreferredResponseTime(TIMETOFIX);

        providerSetUp(criteria);
        assertContinue("LocationProvider is null", iLP != null);

        // Start listening for location changes
        iLP.setLocationListener(this, aInterval, -1, -1);

        getUpdates(aNumberOfFixes, MAXTIME);

        checkLocationData(iLocations[0]);
        // Fixes at interval starts after first fix
        long startTime = iLocUpdateCallbackTime[0];
        long lastTimeOfFix = startTime;

        for (int i = 1; i < aNumberOfFixes; ++i)
        {
            checkLocationData(iLocations[i]);
            long timeOfFix = iLocUpdateCallbackTime[i];
            long timeDiff = timeOfFix - lastTimeOfFix;
            assertContinue("Period difference is less than allowed for fix" + i
                           + ": " + timeDiff, timeDiff > (aInterval - TIMEOUT) * 1000);
            assertContinue("Period difference is more than allowed for fix" + i
                           + ": " + timeDiff, timeDiff < (aInterval + TIMEOUT) * 1000);
            assertContinue("Timestamp too late for fix" + i,
                           (timeOfFix - startTime) < ((i + 1) * aInterval * 1000));
            lastTimeOfFix = timeOfFix;
        }
        iLocations = null;
    }

    private void getUpdates(int aNumUpdates, int aTimeout)
    {
        iLocations = new Location[aNumUpdates];
        iLocUpdateCallbackTime = new long[aNumUpdates];
        iNumUpdates = 0;

        // Wait for the first result or timeout
        boolean timeout = false;
        long startTime = System.currentTimeMillis();
        while (iNumUpdates < aNumUpdates)
        {
            // Wait a moment before checking things
            try
            {
                Thread.sleep(250);
            }
            catch (InterruptedException ie)
            {
            }

            // Use a safeguard timeout in case the updating thread hangs
            // or takes too long
            if (System.currentTimeMillis() - startTime > aTimeout)
            {
                timeout = true;
                break;
            }
        }

        try
        {
            if (iLP != null)
                iLP.setLocationListener(null, -1, -1, -1);
        }
        catch (Exception e)
        {
        }

        assertContinue("Got a timeout", !timeout);
    }

    protected void providerSetUp(Criteria aCriteria)
    {
        iLP = null;
        try
        {
            iLP = LocationProvider.getInstance(aCriteria);
            if (iLP != null)
            {
                int state = iLP.getState();
                assertContinue("Initial state=" + state
                               + ", expected AVAILABLE",
                               state == LocationProvider.AVAILABLE);
            }
        }
        catch (LocationException le)
        {
        }
    }

    protected void checkLocationData(Location aLoc)
    {
        assertContinue("Location is null", aLoc != null);
        assertContinue("Location is invalid", aLoc.isValid());
        assertContinue("Location is valid, but Coordinates are null", aLoc
                       .getQualifiedCoordinates() != null);

        long timestamp = aLoc.getTimestamp();
        long now = System.currentTimeMillis();
        assertContinue("Timestamp incorrect: t=" + timestamp + ", now=" + now,
                       now >= timestamp && (now - timestamp < 30000) && timestamp > 0);

        QualifiedCoordinates coords = aLoc.getQualifiedCoordinates();
        double lat = coords.getLatitude();
        double lon = coords.getLongitude();

        assertContinue("Latitude out of range", lat >= -90.0 || lat <= 90.0);
        assertContinue("Longitude out of range", lon >= -180.0 || lon < 180.0);

        float hacc = coords.getHorizontalAccuracy();
        assertContinue("Horizontal accuracy is negative", Float.isNaN(hacc)
                       || hacc >= 0);

        float vacc = coords.getVerticalAccuracy();
        assertContinue("Vertical accuracy is negative", Float.isNaN(vacc)
                       || vacc >= 0);

        float speed = aLoc.getSpeed();
        assertContinue("Speed is negative", Float.isNaN(speed) || speed >= 0);

        float course = aLoc.getCourse();
        assertContinue("Course out of range", Float.isNaN(course)
                       || (course >= 0 && course < 360));

        String nmea = aLoc.getExtraInfo("application/X-jsr179-location-nmea");
        if (nmea != null)
        {
            assertTrue("Bad NMEA data", nmea.startsWith("$GP"));
        }
    }
}

// End of file