/*
* Copyright (c) 2005-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:  This is a project specific include file for building the 
*                clock related functions as part of libc library.
*
*/


#include <e32base.h>
#include <e32cons.h>
#include <tz.h>
#include <tzconverter.h>
#include "TzLocalizer.h" 
#include "TzLocalizationDataTypes.h"
#include "vtzrules.h"
#include "utf.h" 
#include "timefuncs.h"
#include "lposix.h"
#include "sysif.h"
#include "libc_wsd_defs.h"

// This represents the base EpochTime in microseconds, 
// which happens to be January 1, 1970 (midnight UTC/GMT), 
// not counting leap seconds. This effectively represents 
// the number of microseconds in 1970 years.    
static const TInt64 KEpochTime = 62168256000000000;



#ifndef EMULATOR
struct tm cachetm;
time_t prevchange;
time_t nextchange;
#else //EMULATOR



GET_GLOBAL_VAR_FROM_TLS(cachetm, struct tm)
#define cachetm (*GET_WSD_VAR_NAME(cachetm, g)())
GET_GLOBAL_VAR_FROM_TLS(prevchange, time_t)
#define prevchange (*GET_WSD_VAR_NAME(prevchange, g)())
GET_GLOBAL_VAR_FROM_TLS(nextchange, time_t)
#define nextchange (*GET_WSD_VAR_NAME(nextchange, g)())
#endif //EMULATOR

#if !defined(__SERIES60_30__) 
TTzTimeReference FindChangeBracket(TTime& aTime ,TTime& aUTime, CVTzActualisedRules& aRule,TBool& aDstOn)
    {
    TInt cnt = aRule.Count();
    TInt lowestOffset = -1, curOffset=-1;
    TBool isInit = EFalse;
    TTime CurTime(aTime);
    TTime Previous(-1), Next(-1);
    TTzTimeReference ref(ETzWallTimeReference);
    
//datetime to be created from the UTC time.    
    TDateTime dateTime = aUTime.DateTime();
    
// Initially set aDstOn to False
    aDstOn = EFalse;
    
// Loop to find the lowest time offset applicable in the year.    
    for(TInt idx=0; idx<cnt; idx++)
        {
        TVTzActualisedRule& Actual = aRule[idx];  
        if (Actual.iTimeOfChange.DateTime().Year() == dateTime.Year())
            {
            if (!isInit)
                {
                lowestOffset = Actual.iNewOffset;
                isInit = ETrue;    
                }

            if (isInit && Actual.iNewOffset < lowestOffset)
                {
                lowestOffset = Actual.iNewOffset;
                }   
            }
        }
//    Loop to find the current offset, previous time of change and the next time of change.
    for(TInt idx=0; idx<cnt; idx++)
        {
        TVTzActualisedRule& Actual = aRule[idx];
        if(Actual.iTimeReference == ETzUtcTimeReference && CurTime != aUTime)
            {
            CurTime = aUTime;
            ref = ETzUtcTimeReference;
            }
        //  Rules are arranged in increasing order of iTimeofChange
        if(CurTime >= Actual.iTimeOfChange)
            {
            Previous = Actual.iTimeOfChange;
            curOffset = Actual.iNewOffset;
            }
        else
            {
            Next = Actual.iTimeOfChange;
            break;
            }
       }
/*
 * If the Next and Previous were not set due to some reason,
 * Set them to one year after and one year before the time passed.
 */     
    if(Next == -1)
        {
        /* Next year */
        Next = CurTime + (TTimeIntervalSeconds)(365*86400);
        }
    if (Previous == -1)
        {
        /* Prev Year */
        Previous = CurTime - (TTimeIntervalSeconds)(365*86400);
        }
    aTime = Previous;
    aUTime = Next;
    if(lowestOffset != -1 && curOffset > lowestOffset)
        {
        aDstOn = ETrue;
        }
    return ref;
    }
#endif

void UpdateDstAndTznameL(RTz &aServer,CTzId& aId,struct tm* aTmStruct, TTime aTime, TTime aUTime, TDateTime aDate, TTzTimeReference aReference)
    {
#if !defined(__SERIES60_30__) 
    CTzRules* zonerules = aServer.GetTimeZoneRulesL(aId, aTime, aTime, aReference);
    CleanupStack::PushL(zonerules);
    CVTzActualisedRules* actual = CVTzActualisedRules::NewL(aDate.Year()-1, aDate.Year()+1);
    CleanupStack::PushL(actual);
    zonerules->GetActualisedRulesL(*actual);
    TTime PrevTime(aTime), NextTime(aUTime);
    TBool IsDstOn;
    /* Send local TTimes */
    if(FindChangeBracket(PrevTime, NextTime, *actual, IsDstOn)== ETzWallTimeReference)
        {
        aServer.ConvertToUniversalTime(PrevTime,aId);
        aServer.ConvertToUniversalTime(NextTime,aId);
        }
    prevchange = (PrevTime.Int64() - KEpochTime)/1000000;
    nextchange = (NextTime.Int64() - KEpochTime)/1000000;

    aTmStruct->tm_isdst = IsDstOn;
    CleanupStack::PopAndDestroy(actual);
    CleanupStack::PopAndDestroy(zonerules);
#else // __SERIES60_30__ defined
    aServer;
    aTime;
    aUTime;
    aDate;
    aReference;
#endif

    if(RProcess().HasCapability(ECapabilityReadUserData,ECapabilityWriteUserData,NULL))
        {
        //          tm_zone updated only in this case. Otherwise always has UTC.
        CTzLocalizer *localizer = CTzLocalizer::NewL();
        CleanupStack::PushL(localizer);
        CTzLocalizedTimeZone* timezone = localizer->GetLocalizedTimeZoneL(aId.TimeZoneNumericID());
        CleanupStack::PushL(timezone);
        TPtrC zoneNameDesc;
        if (aTmStruct->tm_isdst)
            {
            zoneNameDesc.Set(timezone->ShortDaylightName());
            }
        else            
            {
            zoneNameDesc.Set(timezone->ShortStandardName());
            }
        //TODO: Value should not be hardcoded here. Get it from the struct state again.
        TPtr8 ptr((unsigned char*)tzname[0],zoneNameDesc.Size());
        CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr,zoneNameDesc);
        CleanupStack::PopAndDestroy(timezone);  
        CleanupStack::PopAndDestroy(localizer);
        }
    aTmStruct->tm_zone = tzname[0];
    }

void ConvertUtcToLocalTimeL(const time_t* aUTCTime, struct tm* const atmStruct)
    {
    if(!aUTCTime)
        {
        User::Leave(KErrArgument);
        }

    TTime   time(KEpochTime + (*aUTCTime) * (TInt64)1000000);
    TTime   Utime(time);

    // Cache Logic.
    TTimeIntervalSeconds UtcOffset = User::UTCOffset();
    if( cachetm.tm_gmtoff == UtcOffset.Int() && prevchange <= *aUTCTime && *aUTCTime<= nextchange)
        {
        time += UtcOffset;         // Convert to local time.
        TDateTime tdt = time.DateTime();
        cachetm.tm_sec = tdt.Second();
        cachetm.tm_min = tdt.Minute();
        cachetm.tm_hour = tdt.Hour();    
        cachetm.tm_mday = tdt.Day() + 1;
        cachetm.tm_mon = tdt.Month();
        cachetm.tm_year = tdt.Year() - 1900;    // This is as per the tm structure format.  
        cachetm.tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. 
        cachetm.tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
        *atmStruct = cachetm;
        return;
        }

    RTz     tzServer;
    User::LeaveIfError(tzServer.Connect());
    CleanupClosePushL(tzServer);

    TDateTime tdt = time.DateTime();
    
    //enable the cache
    CTzConverter* ctzConverter = CTzConverter::NewL(tzServer);
    CleanupStack::PushL(ctzConverter);
    if(ctzConverter->ConvertToLocalTime(time) == KErrNone)      
        {
        tdt = time.DateTime();
        atmStruct->tm_sec = tdt.Second();
        atmStruct->tm_min = tdt.Minute();
        atmStruct->tm_hour = tdt.Hour();
        atmStruct->tm_mday = tdt.Day() + 1;
        atmStruct->tm_mon = tdt.Month();
        atmStruct->tm_year = tdt.Year() - 1900;    // This is as per the tm structure format.  
        atmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. 
        atmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so 

        atmStruct->tm_gmtoff = (time.Int64() - Utime.Int64())/1000000;
        
        TInt timeZoneId = ctzConverter->CurrentTzId();
        CTzId* zoneid = CTzId::NewL((TUint)timeZoneId);
        CleanupStack::PushL(zoneid);
        
        atmStruct->tm_isdst  = -1;
        UpdateDstAndTznameL(tzServer, *zoneid, atmStruct, time, Utime, tdt, ETzWallTimeReference);
        CleanupStack::PopAndDestroy(zoneid);
        }   
    CleanupStack::PopAndDestroy(2);
    cachetm = *atmStruct;
    }

void ConvertLocalToUtcTimeL(time_t* aUTCTime, struct tm* const aTmStruct)
    {
    if(!aTmStruct || aTmStruct->tm_year < 0 || aTmStruct->tm_mon < 0 || aTmStruct->tm_mday < 1 || aTmStruct->tm_hour < 0 || aTmStruct->tm_min < 0 || aTmStruct->tm_sec < 0 )
        {
        User::Leave(KErrArgument);
        }

    TDateTime tdt(aTmStruct->tm_year + 1900, (TMonth)aTmStruct->tm_mon, aTmStruct->tm_mday-1, 
                    aTmStruct->tm_hour, aTmStruct->tm_min, aTmStruct->tm_sec, 0);
    TTime   time(tdt);
    TTime   oldTime(time);

//  Cache Logic 
    TTimeIntervalSeconds UtcOffset = User::UTCOffset();
    if(cachetm.tm_gmtoff == UtcOffset.Int() && cachetm.tm_year == aTmStruct->tm_year && cachetm.tm_mon == aTmStruct->tm_mon && cachetm.tm_mday == aTmStruct->tm_mday)
        {
        aTmStruct->tm_gmtoff = cachetm.tm_gmtoff;
        aTmStruct->tm_isdst = cachetm.tm_isdst;
        aTmStruct->tm_zone = cachetm.tm_zone;    
        aTmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. 
        aTmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
        time -= UtcOffset;                 // Converting to UTC time.
        TInt64 utcTimeMicroSec = time.Int64();
        TInt64 epochRefTime = utcTimeMicroSec - KEpochTime;
        (*aUTCTime) = (TInt) (epochRefTime / 1000000);
        return;
        }

    RTz     tzServer;   
    User::LeaveIfError(tzServer.Connect());
    CleanupClosePushL(tzServer);    

    CTzConverter* ctzConverter = CTzConverter::NewL(tzServer);      
    CleanupStack::PushL(ctzConverter);
 /* Following fields are updated if successful:
  * tm_wday
  * tm_yday
  * tm_isdst
  * tm_gmtoffset
  * tm_zone ( Conditional on capabilities available)
  */
    if(ctzConverter->ConvertToUniversalTime(time) == KErrNone)
        {
        //conversion successful
        TInt64 utcTimeMicroSec = time.Int64();
        TInt64 epochRefTime = utcTimeMicroSec - KEpochTime;
        (*aUTCTime) = (TInt) (epochRefTime / 1000000);
        aTmStruct->tm_wday = (oldTime.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. 
        aTmStruct->tm_yday = oldTime.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
        aTmStruct->tm_gmtoff = (oldTime.Int64() - utcTimeMicroSec)/1000000;
        
        TInt timeZoneId = ctzConverter->CurrentTzId();
        CTzId* zoneid = CTzId::NewL((TUint)timeZoneId);
        CleanupStack::PushL(zoneid);

        aTmStruct->tm_isdst  = -1;
        UpdateDstAndTznameL(tzServer, *zoneid, aTmStruct, oldTime, time, tdt, ETzUtcTimeReference);
        CleanupStack::PopAndDestroy(zoneid);
        }
    cachetm = *aTmStruct;
    CleanupStack::PopAndDestroy(2);
    }

// converts a UTC time to local time, or, local time to UTC time.  
TInt ConvertTime(const TInt atimeConverFlg, time_t *aUTCTime, struct tm *const atmStruct)
    {
    TInt err = 0;
    CActiveScheduler* oldAs = CActiveScheduler::Current();
    RHeap* oldHeap = User::SwitchHeap(Backend()->Heap());
    CActiveScheduler* newAs = new CActiveScheduler();
    User::SwitchHeap(oldHeap);
    if(!newAs)
        {
        errno = ENOMEM;
        return ENOMEM;
        }
    if(oldAs)
        {
        (void)CActiveScheduler::Replace(newAs);
        }
    else
        {
        CActiveScheduler::Install(newAs);
        }

    // Cleanup stack needed
    CTrapCleanup* cleanup=CTrapCleanup::New();
    if (cleanup)
        {
        if(EUtcToLocal == atimeConverFlg)
            {
            TRAP(err, ConvertUtcToLocalTimeL(aUTCTime, atmStruct));
            }
        else if(ELocalToUtc == atimeConverFlg)
            {
            TRAP(err, ConvertLocalToUtcTimeL(aUTCTime, atmStruct));
            }
        delete cleanup;
        }
    else
        {
        err = ENOMEM;
        }
    if(oldAs)
        {
        (void)CActiveScheduler::Replace(oldAs);
        }
    oldHeap = User::SwitchHeap(Backend()->Heap());
    delete newAs;
    User::SwitchHeap(oldHeap);
    return MapError(err,errno);
    }

