//--------------------------
// precision timer
//--------------------------

integer useprectimer = 0; // 0 for settimerevent, 1 for precision timer
float timetotest = 0.2; // how fast should the timer run?


// these two functions set timers with and without precision, and mark the desired time target
vector timeTarget;
precTimer( float secdiff )
{
    timeTarget = vecTime();
    timeTarget.z += secdiff;
    llSetTimerEvent(secdiff - 0.05);
}
nonprecTimer( float secdiff )
{
    timeTarget = vecTime();
    timeTarget.z += secdiff;
    llSetTimerEvent(secdiff);
}


// run a report of how well the timer is doing
runReport()
{
        float min;
        float max;
        float avg;
        float total;
        float cur;
        integer i;
        integer len;
        
        llSetTimerEvent(0.0); // try to clear the event queue up a bit, altho reset should do it
        if( useprectimer == 1 ) {
            llOwnerSay("Precision timer stats:");
        } else {
            llOwnerSay("llSetTimerEvent stats:");
        }
        
        len = llGetListLength(lDiffs);
        total = 0.0;
        min = 1.0;
        max = 0.0;
        for( i = 0; i < len; i++ ) {
            cur = llList2Float(lDiffs, i);
            total += cur;
            if( cur < min ) {
                min = cur;
            }
            if( cur > max ) {
                max = cur;
            }
        }
        avg = total/(float)len;
        llOwnerSay("Total drift: " + (string)total + ", timers run: " + (string)len);
        llOwnerSay("Avg   drift: " + (string)avg);
        llOwnerSay("Min   drift: " + (string)min);
        llOwnerSay("Max   drift: " + (string)max);
        llOwnerSay("Starting another run.");
        llResetScript();
}

//--------------------------
// time utility functions
//--------------------------
vector vecTime()
{
    vector tsp;
    list tsv;

    tsv = llParseString2List( llGetTimestamp(), ["T", ":", "Z"], [] );

    tsp.x = llList2Integer(tsv, 1) - 8;
    if( tsp.x < 0 ) {
        tsp.x += 24;
    }
    tsp.y = llList2Integer(tsv, 2);
    tsp.z = llList2Float(tsv, 3);

    return tsp;
}

vector fixTime( vector inTime )
{
    vector oTime = inTime;
    
    while( oTime.z >= 60.0 ) {
        oTime.z -= 60.0;
        oTime.y++;
    }
    while( oTime.y >= 60.0 ) {
        oTime.y -= 60.0;
        oTime.z++;
    }
    return oTime;
}

float timeDiffNow( vector vTarget )
{
    vector vTime = vecTime();
    return (vTarget.x - vTime.x)*3600.0 + (vTarget.y - vTime.y) * 60.0 + (vTarget.z - vTime.z);
}

// included for reference:
float timeDiff( vector vMore, vector vLess )
{
    float hours = vMore.x - vLess.x;
    float minutes = vMore.y - vLess.y;
    float seconds = vMore.z - vLess.z;
    
    float tics = hours * 3600.0 + minutes * 60.0 + seconds;
    
//    llOwnerSay("Diff between " + (string)vMore + " and " + (string)vLess );  
//    llOwnerSay("Diff returned approx. " + (string)( (integer)tics ) + " seconds.");
    return tics;
}


//--------------------------
// PrecTimer script: report the drift in llSetTimerEvent, and show an easy way to fix it:
//--------------------------
list lDiffs; // used to store statistics

default
{
    state_entry()
    {
        lDiffs = [];
        if( useprectimer == 1 ) {
            precTimer(timetotest);
        } else {
            nonprecTimer(timetotest);
        }
    }
    
    timer()
    {
        float timeleft = timeDiffNow(timeTarget);   // ETA to target time

        if( useprectimer == 1 ) {
            //Begin very simple precision countdown:
            llResetTime();
            while( (timeleft -= llGetAndResetTime()) > 0.01 );
            //Reset the target of the precision timer:
            precTimer(timetotest);
        } else {
            //Reset the target of the nonprecision timer:
            timeTarget.z += timetotest;
        }
        lDiffs = (lDiffs=[]) + lDiffs + [llFabs(timeleft)];
        if( llGetListLength(lDiffs) > 100 ) {
            runReport();
        }
    }
    
    touch_start(integer nd)
    {
        runReport();
    }
}