// CountDownRec.CPP
//
//
#include "CountDownDB.h"

#include <apmrec.h>
#include <apmstd.h>
#include <e32math.h>
#include <f32file.h>
#include <eikenv.h>

#include <aknglobalnote.h> 

const TUint KCountDownServMajorVersionNumber=0;
const TUint KCountDownServMinorVersionNumber=1;
const TUint KCountDownServBuildVersionNumber=1;

_LIT(KCountDownServerName,"CountDownServer");
_LIT(KCountDownServerSemaphoreName, "CountDownServerSemaphore");
_LIT(KCountDownServerFilename, "CountDownSrv");
_LIT(KCountDownRunSemaphore, "CountDownRunSemaphore");

class CTimerOut : public CTimer
{
public:
	CTimerOut();
	~CTimerOut();

	void StartTimer();

public:
	void DoCancel();
	void RunL();
};

void ShowNotify(TDesC &aBuf)
{
    TRequestStatus status;
    CAknGlobalNote* globalNote = CAknGlobalNote::NewLC();
    globalNote->ShowNoteL(status, EAknGlobalInformationNote, aBuf );
    User::WaitForRequest(status);
    CleanupStack::PopAndDestroy();
}

CTimerOut::CTimerOut()
:  CTimer( EActivePriorityClockTimer )
{
    CTimer::ConstructL();
    CActiveScheduler::Add( this );
}

CTimerOut::~CTimerOut()
{
	CTimer::DoCancel();
}

void CTimerOut::StartTimer()
{
	After(12000000);
}

void CTimerOut::DoCancel()
{
}

void CTimerOut::RunL()
{
    CCountDownDB *iDB = NULL;
	iDB = new(ELeave) CCountDownDB();
    void *rscBuf = iDB->ReadRscL();
    if(rscBuf)
    {
        TInt32 *p32 = (TInt32 *)rscBuf;
        TInt32 rscCount = *p32;
        TInt32 len1, len2, len3;
        TName rscInfo1,rscInfo2,rscInfo3;
        TInt i;
        if(rscCount==3)
        {
            p32 ++;
            len1 = *p32;
            p32 ++;
            len2 = *p32;
            p32 ++;
            len3 = *p32;
            p32 ++;

            TPtr16 ptr16((TUint16 *)p32, len1+len2+len3, len1+len2+len3);

            rscInfo1.Copy(ptr16.Left(len1));
            ptr16.Delete(0, len1);
            rscInfo2.Copy(ptr16.Left(len2));
            ptr16.Delete(0, len2);
            rscInfo3.Copy(ptr16.Left(len3));
        }
        User::Free(rscBuf);
        for(i=0;i<iDB->iArrayDB->Count();i++)
        {
            TRecordDBStruct &db = iDB->iArrayDB->At(i);
            TTime time(db.iTime);
            TTime curTime;
            curTime.HomeTime();
            TInt days = GetDays(time, curTime);
            TName tips;
            if(days>0)
            {
                tips.Format(rscInfo1, &db.iName, days);
            }
            else
            {
                if(days==0)
                {
                    tips.Format(rscInfo2, &db.iName);
                }
                else
                {
                    tips.Format(rscInfo3, &db.iName, -days);
                }
                //delete
                iDB->iArrayDB->Delete(i);
                iDB->SaveDBL();
                i --;
            }
            ShowNotify(tips);
        }
    }
    delete iDB;
}

const TInt KMimeCountDownRecognizerValue=0x025DD340;
const TUid KUidMimeCountDownRecognizer={KMimeCountDownRecognizerValue};

class CApaCountDownRecognizer : public CApaDataRecognizerType // (declared in \emime\inc\APMREC.H)
{
public: // from CApaDataRecognizerType
	CApaCountDownRecognizer();
	static CApaCountDownRecognizer* CApaCountDownRecognizer::NewL();
	TDataType SupportedDataTypeL(TInt aIndex) const;
	TUint PreferredBufSize();
private:
	void Construct();
	void DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer);
	CTimerOut iTimer;
};

CApaCountDownRecognizer::CApaCountDownRecognizer()
:CApaDataRecognizerType(KUidMimeCountDownRecognizer,CApaDataRecognizerType::ENormal)
{
}

TUint CApaCountDownRecognizer::PreferredBufSize()
{
	return 3;
}

TDataType CApaCountDownRecognizer::SupportedDataTypeL(TInt /*aIndex*/) const
{
	return iDataType;
}

void CApaCountDownRecognizer::DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer)
{
}

void CApaCountDownRecognizer::Construct()
{
	iCountDataTypes=1;
	iTimer.StartTimer();
}

CApaCountDownRecognizer* CApaCountDownRecognizer::NewL()
{
	CApaCountDownRecognizer* self=new (ELeave) CApaCountDownRecognizer();   
	self->Construct(); 
	return self;
}

EXPORT_C CApaDataRecognizerType* CreateRecognizer()
// The gate function - ordinal 1
//
{
	CApaDataRecognizerType* thing=NULL;
	TRAPD(err, thing=CApaCountDownRecognizer::NewL());
	return thing; // NULL if new failed
}

GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
//
// DLL entry point
//
{
	return KErrNone;
}