// Copyright (c) 2000-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:

//

#include "ConvertDates.h"

// Constants 

const TInt KFirstYear = 0;

const TInt KFromOffset = 0;

const TInt KToOffset = 5;

const TInt KCycleOffset = 10;

const TInt KYearOffset = 13;

const TInt KMnthOffset = 19;

const TInt KLeapMonthOffset = 22;

const TInt KDyOffset = 24;

const TInt KCycleLen = 2;

const TInt KSignLen = 1;

const TInt KYearLen = 5;

const TInt KMonthLen = 2;

//const TInt KLeapMonthLen = 1;

const TInt KDayLen = 2;

//

_LIT(KRoot,						"C:\\");

_LIT(KSpace,					" ");

_LIT(KResult,					" Result ");

_LIT(KTestHeader,				"Test Results");

_LIT(KCalconLogFileDirectory,	"calcon");

_LIT(KCalconLogFile,			"c:\\calcon\\calcon.txt");

_LIT(KInputFile,				"c:\\input.txt");

_LIT(KOutputFile,				"c:\\output.txt");

_LIT8(KImcvCRLF,				"\r\n");

//

// Construction/Destruction

//

CConvertDates::~CConvertDates()

	{

	iInputFile.Close();

	iOutputFile.Close();

	iRFSession.Close();

	}

CConvertDates* CConvertDates::NewL()

	{

	CConvertDates* self = CConvertDates::NewLC();

	CleanupStack::Pop();

	return self;

	}

CConvertDates* CConvertDates::NewLC()

	{

	CConvertDates* self = new(ELeave) CConvertDates;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CConvertDates::ConstructL()

	{

	// constructors, public member data, static casts

	TGregorianCalendar gregorianCalendar;

	TChineseCalendar chineseCalendar;

	TArithmeticalDate date;

	date.iYear=2001;

	date.iMonth=1;

	date.iDay=24; // 24th January 2001

	gregorianCalendar.SetDate(date);

	static_cast<TCalendar&>(chineseCalendar)=gregorianCalendar;

	TChineseDate chineseDate;

	chineseCalendar.GetDate(chineseDate); // cycle=78, Year=18, Month=1, Day=1 (New Year's day)

	User::LeaveIfError(iRFSession.Connect());

	iRFSession.SetSessionPath(KRoot);

	if	(iLogger.LogValid())

		iLogger.CloseLog();

	TParse p;

	p.Set(KCalconLogFile, NULL, NULL);

	iLogger.Connect();

	iLogger.CreateLog(KCalconLogFileDirectory, p.NameAndExt(), EFileLoggingModeOverwrite);

	iLogger.SetDateAndTime(EFalse, EFalse);

	iLogger.Write(KTestHeader);

	}

void CConvertDates::ConvertL()

	{

	TBuf8<100> logLine;

	TBuf<64> errBuf;

	// open the input and output files

	OpenFilesL();

	TInt fileErr = KErrNone;

	while(fileErr == KErrNone)

		{

		// read date from the input file

		fileErr = ReadLine();

		if	(fileErr==KErrNone)

			{

			// get the cal types to convert from and to

			TRAPD(err,GetCalL(iDateLine));

			if	(err)

				{

				errBuf.Format(_L("\r\nError get calendar conversion type %d\r\n"),err);

				iLogger.Write(errBuf);

				}

			else

				{

				// do the conversion

				Cal1ToCal2();

				// set the cal types to convert from and to

				logLine.Zero();

				TRAP(err,SetCalL(logLine));

				if	(err)

					{

					errBuf.Format(_L("\r\nError set calendar conversion type %d\r\n"),err);

					iDateLine.Append(errBuf);

					}

				else

					{

					iDateLine.Append(logLine);

					iDateLine.Append(_L8("\r\n"));

					iLogger.Write(iDateLine);

					if	(iOutputFile.Write(iDateLine))

						{

						User::Leave(KErrCorrupt);

						}

					}

				}

			}

		}

	}

void CConvertDates::OpenFilesL()

	{

	User::LeaveIfError(iInputFile.Open(iRFSession, KInputFile, EFileStreamText|EFileRead|EFileShareExclusive));

	User::LeaveIfError(iOutputFile.Replace(iRFSession, KOutputFile, EFileStreamText|EFileWrite|EFileShareExclusive));

	}

void CConvertDates::GetCalL(TDes8& aDateToConvert)

	{

	TInt dateError;

	TDateTime dt(0,EJanuary,0,0,0,0,0);

	TLex8 lexCycle(aDateToConvert.Mid(KCycleOffset,KCycleLen));

	TLex8 lexYear(aDateToConvert.Mid(KYearOffset,KYearLen));

	TLex8 lexMonth(aDateToConvert.Mid(KMnthOffset,KMonthLen));

//	TLex8 lexLeapMonth(aDateToConvert.Mid(KLeapMonthOffset,KLeapMonthLen));

	TLex8 lexDay(aDateToConvert.Mid(KDyOffset,KDayLen));

	// get cycle

	if	(lexCycle.Val(iChinDateOut.iCycle) != KErrNone)

		{

		User::Leave(KErrCorrupt);

		}

	// get year

	if	(lexYear.Val(iArithDateOut.iYear) != KErrNone)

		{

		User::Leave(KErrGeneral);

		}

	iChinDateOut.iYear = iArithDateOut.iYear;

	// get month

	if	(lexMonth.Val(iArithDateOut.iMonth) != KErrNone)

		{

		User::Leave(KErrGeneral);

		}

	iChinDateOut.iMonth = iArithDateOut.iMonth;

	// get leap month

	if	(aDateToConvert[KLeapMonthOffset] == 't')

		{

		iChinDateOut.iLeapMonth = ETrue;

		}

	else

		{

		iChinDateOut.iLeapMonth = EFalse;

		}

	// get day

	if	(lexDay.Val(iArithDateOut.iDay) != KErrNone)

		{

		User::Leave(KErrCorrupt);

		}

	iChinDateOut.iDay = iArithDateOut.iDay;

	switch(aDateToConvert[KFromOffset])

		{

	case 'g':

		iCalTypeFrom = EGreg;

		dateError = iGreg.SetDate(iArithDateOut);

		iGreg.GregorianToDateTime(dt);

		iGreg.DateTimeToGregorian(dt);

		break;

	case 'c':

		iCalTypeFrom = EChin;

		dateError = iChin.SetDate(iChinDateOut);

		iChin.ChineseToDateTime(dt);

		iChin.DateTimeToChinese(dt);

		break;

	default:

		dateError = KErrCorrupt;

		break;

		}

	if	(dateError)

		User::Leave(dateError);

	switch(aDateToConvert[KToOffset])

		{

	case 'g':

		iCalTypeTo = EGreg;

		break;

	case 'c':

		iCalTypeTo = EChin;

		break;

	default:

		break;

		}

	}

void CConvertDates::Cal1ToCal2() const

	{

	switch(iCalTypeFrom)

		{

	case EGreg:

		{

		switch(iCalTypeTo)

			{

		case EChin:

			(TCalendar&)(iChin) = (TCalendar&)(iGreg);

			break;

		default:

			break;

			}

		}

		break;

	case EChin:

		{

	switch(iCalTypeTo)

		{

		case EGreg:

			(TCalendar&)(iGreg) = (TCalendar&)(iChin);

			break;

		default:

			break;

		}

		}

		break;

	default:

		break;

	}

	}

void CConvertDates::SetCalL(TDes8& aConvertedDate)

	{

	TArithmeticalDate Date;

	TChineseDate ChinDate;

	TBuf8<KYearLen> TempDate;

	switch(iCalTypeFrom)

		{

	case EGreg:

		{

		switch(iCalTypeTo)

			{

		case EChin:

			iChin.GetDate(ChinDate);

			break;

		default:

			break;

			}

		}

		break;

	case EChin:

		{

		switch(iCalTypeTo)

			{

		case EGreg:

			iGreg.GetDate(Date);

			TempDate.Copy(_L("greg "));

		default:

			break;

			}

		}

		break;

	default:

		break;

		}

	if	(iCalTypeTo == EChin)

		{

		TBuf8<10> TempFormatStr;

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KCycleLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,ChinDate.iCycle);

		aConvertedDate.Append(KResult);

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempDate.FillZ();

		TempDate.Format(_L8("+"));

		aConvertedDate.Append(TempDate);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KYearLen - KSignLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,ChinDate.iYear);

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KMonthLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,ChinDate.iMonth);

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempDate.FillZ();

		if	(ChinDate.iLeapMonth == EFalse)

			{

			TempDate.Format(_L8("f"));

			}

		else

			{

			TempDate.Format(_L8("t"));

			}

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KDayLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,ChinDate.iDay);

		aConvertedDate.Append(TempDate);

		}

	else

		{

		TBuf8<10> TempFormatStr;

		if	(Date.iYear >= KFirstYear)

			{

			TempDate.Format(_L8("+"));

			}

		else

			{

			TempDate.Format(_L8("-"));

			}

		aConvertedDate.Append(KResult);

		aConvertedDate.Append(TempDate);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KYearLen - KSignLen);

		TempDate.FillZ();

		if	(Date.iYear >= KFirstYear)

			{

			TempDate.Format(TempFormatStr,Date.iYear);

			}

		else

			{

			TempDate.Format(TempFormatStr,-Date.iYear);

			}

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KMonthLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,Date.iMonth);

		aConvertedDate.Append(TempDate);

		aConvertedDate.Append(KSpace);

		TempFormatStr.FillZ();

		TempFormatStr.Format(_L8("%%0%dd"),KDayLen);

		TempDate.FillZ();

		TempDate.Format(TempFormatStr,Date.iDay);

		aConvertedDate.Append(TempDate);

		}

	}

//

// Read line of test from file

//

TInt CConvertDates::ReadLine()

    {

    TInt err = KErrNone;

    //  Read into the buffer

    TBuf8<256> buffer;              // Max read of the Read() function..    

    iDateLine.Zero();

    //  Get the current file position

    TInt filePos = 0;

    iInputFile.Seek(ESeekCurrent, filePos);

    //  Read the buffer

    err = iInputFile.Read(buffer);

    //end of file?

    TInt s = buffer.Length();

    if	( s == 0)

        {

        err = KErrEof;

        }

    if	(err == KErrNone)

        {

        //  Copy to the lfcr and then set the file pointer

        //  to the point after that...

        TInt pos = buffer.Find(KImcvCRLF);

        if	( pos != -1)

            {

            iDateLine.Justify(buffer, pos, ELeft, ' ');

            filePos += (pos+2);

            //  Set the file pointer back to after the lfcr..

            iInputFile.Seek(ESeekStart, filePos);                

            }

        //  Else fill the whole buffer 256 chars..

        else

            {

            iDateLine.Copy(buffer);

            }

        }

    return err;

    }