/*

* Copyright (c) 2007 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:   Calendar Lunar Plugin 

*

*/

#include "calendarui_debug.h"

#include "calenlunarlocalizer.h"

#include "calenlunarinfo.h"

#include "calenlunarlocalizedinfo.h"

#include "calenextrarowformatter.h"

#include <calenregionalutil.rsg>

#include <AknBidiTextUtils.h>

#include <avkon.rsg>

#include <badesca.h> 

#include <eikenv.h>

#include <StringLoader.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

//CONSTANTS

const TInt KCharMonth = 0x6708;

const TInt KCharFirstMonth = 0x6b63;

const TInt KCharChu = 0x521d;

const TInt KCharTen = 0x5341;

const TInt KCharTwenty= 0x5eff;

_LIT(KChineseDigits, 

     "\x0030\x4e00\x4e8c\x4e09\x56db\x4e94\x516d\x4e03\x516b\x4e5d");

_LIT( KResourceChinesePluginFile, "calenregionalutil.rsc" );

#define KResourcePath KDC_RESOURCE_FILES_DIR

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::NewL

// -----------------------------------------------------------------------------

//

EXPORT_C CCalenLunarLocalizer* CCalenLunarLocalizer::NewL()

    {

    TRACE_ENTRY_POINT;

    CCalenLunarLocalizer* self = new (ELeave) CCalenLunarLocalizer;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::~CCalenLunarLocalizer

// -----------------------------------------------------------------------------

//

EXPORT_C CCalenLunarLocalizer::~CCalenLunarLocalizer()

    {

    TRACE_ENTRY_POINT;

    delete iFestivalNames;

    delete iSolarTermNames;

    delete iHeavenlyStemNames;

    delete iTerrestialBranchNames;

    delete iAnimalYearNames;

    delete iGregorianDateFormat;

    delete iRowFormatter;

    if( iResourceFileOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );

        }

    TRACE_EXIT_POINT;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::CCalenLunarLocalizer

// -----------------------------------------------------------------------------

//

EXPORT_C CCalenLunarLocalizer::CCalenLunarLocalizer() : iEikEnv( CEikonEnv::Static() )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::ConstructL

// -----------------------------------------------------------------------------

//

EXPORT_C void CCalenLunarLocalizer::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iRowFormatter = CCalenExtraRowFormatter::NewL();

    TFileName dllName;

    // Get the complate path of the DLL from where it is currently loaded

    Dll::FileName( dllName );

    TFileName resourceFilename;

    resourceFilename.Append(dllName.Mid(0,2));

    resourceFilename.Append(KResourcePath);

    resourceFilename.Append(KResourceChinesePluginFile);

    BaflUtils::NearestLanguageFile( CEikonEnv::Static()->FsSession(), resourceFilename );

    // Add the resource file.

    iResourceFileOffset = CEikonEnv::Static()->AddResourceFileL( resourceFilename );

    iFestivalNames = iEikEnv->ReadDesCArrayResourceL(R_CALEN_CHI_FESTIVALS);

    iSolarTermNames = iEikEnv->ReadDesCArrayResourceL(R_CALEN_CHI_SOLAR_ITEMS);

    iHeavenlyStemNames = iEikEnv->ReadDesCArrayResourceL(R_CALEN_CHI_HEAV_STEMS);

    iTerrestialBranchNames = iEikEnv->ReadDesCArrayResourceL(R_CALEN_CHI_TERR_BRANCHES);

    iAnimalYearNames = iEikEnv->ReadDesCArrayResourceL(R_CALEN_CHI_ANIMAL_YEARS);

    iGregorianDateFormat = StringLoader::LoadL(R_QTN_DATE_USUAL_WITH_ZERO);

#ifdef _DEBUG

    // Validate assumptions

    TInt maxStem = -1;

    for (TInt i = 0; i < iHeavenlyStemNames->Count(); i++)

        {

        maxStem = Max( maxStem, iHeavenlyStemNames->MdcaPoint(i).Length() );

        }

    TInt maxBranch = -1;

    for (TInt i = 0; i < iTerrestialBranchNames->MdcaPoint(i).Length() ; i++)

        {

        maxBranch = Max( maxBranch, iTerrestialBranchNames->MdcaPoint(i).Length() );        

        }

    ASSERT( maxStem + maxBranch <= 100);

#endif

    TRACE_EXIT_POINT;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::LocalizeL

// -----------------------------------------------------------------------------

//

EXPORT_C CCalenLunarLocalizedInfo* CCalenLunarLocalizer::LocalizeL( TCalenLunarInfo& aInfo )

    {

    TRACE_ENTRY_POINT;

    CCalenLunarLocalizedInfo* localized = CCalenLunarLocalizedInfo::NewL();

    CleanupStack::PushL( localized );

    if ( aInfo.HasFestival() ) 

        {

        localized->iFestival.Set( iFestivalNames->MdcaPoint( aInfo.iFestival ) );

        }

    if ( aInfo.HasSolarTerm() ) 

        {

        localized->iSolarTerm.Set( iSolarTermNames->MdcaPoint( aInfo.iSolarTerm ) );

        }

    // Animal year

    localized->iAnimalYear.Set( iAnimalYearNames->MdcaPoint( aInfo.AnimalYear() ) );

    // Lunar year    

    CPtrCArray* yearSubs = new (ELeave) CPtrCArray(2);

    CleanupStack::PushL( yearSubs );

    yearSubs->AppendL( iHeavenlyStemNames->MdcaPoint( aInfo.iHeavenlyStem ) );

    yearSubs->AppendL( iTerrestialBranchNames->MdcaPoint( aInfo.iTerrestialBranch ) );

    HBufC* tmp = StringLoader::LoadLC( R_CALE_LUNAR_YEAR, *yearSubs, iEikEnv );

#ifdef _DEBUG

    RDebug::Print( *tmp );

#endif

    localized->iLunarYear = *tmp;

    CleanupStack::PopAndDestroy( tmp );

    CleanupStack::PopAndDestroy( yearSubs );

#ifdef _DEBUG

    RDebug::Print(     localized->iLunarYear  );

#endif

    LocalizeMonthAndDayL(localized, aInfo);

    // Full lunar date

    CPtrCArray* subs = new (ELeave) CPtrCArray(2);

    CleanupStack::PushL( subs );

    subs->AppendL( localized->LunarMonthAndDay() );

    subs->AppendL( localized->LunarYear() );

    tmp = StringLoader::LoadLC( R_CALE_LUNAR_FULL_DATE, *subs );

    localized->iFullLunarDate = *tmp;

    CleanupStack::PopAndDestroy( tmp );

    CleanupStack::PopAndDestroy( subs );

    aInfo.iGregorianDate.FormatL( localized->iGregorianDate, 

                                 *iGregorianDateFormat );

    CleanupStack::Pop( localized );

    TRACE_EXIT_POINT;

    return localized;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::GetExtraRowTextL

// -----------------------------------------------------------------------------

//

EXPORT_C TPtrC CCalenLunarLocalizer::GetExtraRowTextL( CCalenLunarLocalizedInfo& aLocInfo, TInt aMaxWidth, 

                                              const CFont& aFont, TBool aTwoLines )

    {

    TRACE_ENTRY_POINT;

    RArray<CCalenLunarLocalizedInfo::TField> fields;

    CleanupClosePushL( fields );

    fields.AppendL( CCalenLunarLocalizedInfo::EFestival );

    fields.AppendL( CCalenLunarLocalizedInfo::ESolarTerm );

    fields.AppendL( CCalenLunarLocalizedInfo::ELunarMonthAndDay );

    fields.AppendL( CCalenLunarLocalizedInfo::EAnimalYear );

    fields.AppendL( CCalenLunarLocalizedInfo::ELunarYear );

    TPtrC text = iRowFormatter->FormatExtraRowInformationL( aLocInfo, fields, aMaxWidth, aFont

                                                            , aTwoLines 

                                                            );

    CleanupStack::PopAndDestroy( &fields );

    TRACE_EXIT_POINT;

    return text;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::LocalizeMonthAndDayL

// -----------------------------------------------------------------------------

//

void CCalenLunarLocalizer::LocalizeMonthAndDayL(CCalenLunarLocalizedInfo* aLocInfo,

                                                TCalenLunarInfo& aInfo)

    {

    // Lunar Month and Day

    TInt dateResource = aInfo.iLunarDate.iLeapMonth ? R_CALE_LUNAR_LEAP_DATE : R_CALE_LUNAR_DATE;

    TBuf<10> month;

    TBuf<10> day;

    GetChineseMonth(aInfo.iLunarDate, month);

    GetChineseDay(aInfo.iLunarDate, day);

    CPtrCArray* monthAndDaySubs = new (ELeave) CPtrCArray(2);

    CleanupStack::PushL( monthAndDaySubs );

    monthAndDaySubs->AppendL(month);

    monthAndDaySubs->AppendL(day);

    HBufC* tmp = StringLoader::LoadLC( dateResource, *monthAndDaySubs );

    aLocInfo->iLunarMonthAndDay = *tmp;

    CleanupStack::PopAndDestroy( tmp );

    CleanupStack::PopAndDestroy( monthAndDaySubs );

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::GetChineseMonth

// -----------------------------------------------------------------------------

//

void CCalenLunarLocalizer::GetChineseMonth(const TChineseDate& aChineseDate,

                                           TDes& aDes)

    {

    TRACE_ENTRY_POINT;

    if (aChineseDate.iMonth == 1)

        {

        aDes.Append(KCharFirstMonth); // Special character for first month

        }

    else

        {

        GetChineseDigits(aChineseDate.iMonth, aDes);

        }

    aDes.Append(KCharMonth);

    TRACE_EXIT_POINT;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::GetChineseDay

// -----------------------------------------------------------------------------

//

void CCalenLunarLocalizer::GetChineseDay(const TChineseDate& aChineseDate,

                                         TDes& aDes)

    {

    TRACE_ENTRY_POINT;

    if (aChineseDate.iDay <= 10) // day

        {

        aDes.Append(KCharChu); 

        }

    GetChineseDigits(aChineseDate.iDay, aDes);

    TRACE_EXIT_POINT;

    }

// -----------------------------------------------------------------------------

// CCalenLunarLocalizer::GetChineseDigits

// -----------------------------------------------------------------------------

//

void CCalenLunarLocalizer::GetChineseDigits(TInt aNum, TDes& aDes)

    {

    TRACE_ENTRY_POINT;

    ASSERT( 0 < aNum && aNum <= 30 );

    TInt tens = aNum / 10;

    TInt ones = aNum % 10;

    if (aNum < 10) 

        {

        aDes.Append((KChineseDigits())[ones]);

        }

    else if (10 == aNum)

        {

        aDes.Append(KCharTen);

        }

    else if (10 < aNum && aNum < 20)

        {

        aDes.Append(KCharTen);

        aDes.Append((KChineseDigits())[ones]);

        }

    else if (20 == aNum)

        {

        aDes.Append((KChineseDigits())[tens]);

        aDes.Append(KCharTen);

        }

    else if (20 < aNum && aNum < 30)

        {

        aDes.Append(KCharTwenty);

        aDes.Append((KChineseDigits())[ones]);

        }

    else if (30 == aNum)

        {

        aDes.Append((KChineseDigits())[tens]);

        aDes.Append(KCharTen);

        }

    else 

        {

        __ASSERT_DEBUG(EFalse, User::Invariant());

        }

    TRACE_EXIT_POINT;

    }

//EOF