/*
 * Name        : Remote.cpp
 * Description : 
 * Project     : This file is part of OpenMAR, an Open Mobile Augmented Reality browser
 * Website     : http://OpenMAR.org
 *
 * Copyright (c) 2010 David Caabeiro
 *
 * All rights reserved. This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 which accompanies this 
 * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 */

#include "Remote.h"

#include "HttpClient.h"

#include <AknUtils.h>
#include <lbspositioninfo.h>
#include <http/mhttpdatasupplier.h>
#include <HttpErr.h>
#include <utf.h>

#include "Logger.h"

CRemoteLoader* CRemoteLoader::NewL(MLandmarkLoaderObserver& aObserver, const TDesC8& aProviderUri)
{
    CRemoteLoader* self = new(ELeave) CRemoteLoader(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL(aProviderUri);
    CleanupStack::Pop(self);

    return self;
}

CRemoteLoader::~CRemoteLoader()
{
    iBuffer.Close();

    delete iParser;
    delete iClient;
    delete iBaseUri;
}

CRemoteLoader::CRemoteLoader(MLandmarkLoaderObserver& aObserver)
    : CActive(CActive::EPriorityStandard), iObserver(aObserver)
{
    CActiveScheduler::Add(this);
}

void CRemoteLoader::ConstructL(const TDesC8& aProviderUri)
{
    LOGARG("[LANDMARKS] Creating remote landmark loader: %S", &aProviderUri);

    iBaseUri = aProviderUri.AllocL();
    iClient = CHttpClient::NewL(*this);

    _LIT8(KMimeType, "application/vnd.nokia.landmarkcollection+xml");
    iParser = CPosLandmarkParser::NewL(KMimeType);
}

void CRemoteLoader::RunL()
{
    if (iStatus == KPosLmOperationNotComplete || iStatus == KErrNone)
    {
        CPosLandmark* landmark = iParser->LandmarkLC();
        iObserver.LandmarkLoaderItemCreatedL(*landmark);
        CleanupStack::PopAndDestroy(landmark);
    }

    if (iStatus == KPosLmOperationNotComplete)
    {
        iOperation->NextStep(iStatus, iProgress);
        SetActive();
    }
}

void CRemoteLoader::DoCancel()
{
    // TODO: Add cancellation code
}

void CRemoteLoader::RequestL(const TCoordinate& aCoordinate, TReal32 aRadius)
{
    TRealFormat realFormat;
    realFormat.iPoint  = TChar('.');    // Override TLocale::DecimalSeparator() as separator
    realFormat.iWidth  = 8;             // Set max width of number
    realFormat.iPlaces = 5;             // Set max width of decimal portion

    TBuf8<KDefaultRealWidth> latitude;
    latitude.Num(aCoordinate.Latitude(), realFormat);

    TBuf8<KDefaultRealWidth> longitude;
    longitude.Num(aCoordinate.Longitude(), realFormat);

    // Convert to integer
    TInt radius = static_cast<TInt>(aRadius);

    TBuf8<256> uri(*iBaseUri);
    _LIT8(KParam, "?lat=%S&lon=%S&radius=%d");
    uri.AppendFormat(KParam, &latitude, &longitude, radius);

    LOGARG("[LANDMARKS] Making http request %S", &uri);

    iClient->GetL(uri);
}

void CRemoteLoader::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
    switch (aEvent.iStatus)
    {
        case THTTPEvent::EGotResponseHeaders:
        {
            RHTTPResponse resp = aTransaction.Response();
            TInt status = resp.StatusCode();

            LOGARG("[LANDMARKS] HTTP response status %d", status);

            break;
        }

        case THTTPEvent::EGotResponseBodyData:
        {
            MHTTPDataSupplier* body = aTransaction.Response().Body();

            TPtrC8 dataChunk;
            body->GetNextDataPart(dataChunk);

            // Check if there is enough remaining space
            const TInt newLength = iBuffer.Length() + dataChunk.Length();
            if (iBuffer.MaxLength() < newLength)
                iBuffer.ReAllocL(newLength);
            iBuffer.Append(dataChunk);

            body->ReleaseData();

            break;
        }

        case THTTPEvent::EResponseComplete:
            LOGTXT("[LANDMARKS] HTTP response complete");

            break ;

        case THTTPEvent::ESucceeded:
        {
            RHTTPResponse resp = aTransaction.Response();
            TInt status = resp.StatusCode();

            LOGARG("[LANDMARKS] HTTP response succeeded %d", status);

            aTransaction.Close();

            iObserver.LandmarkLoaderOpenedL(KErrNone);
            
            iParser->SetInputBuffer(iBuffer);

            iOperation = iParser->ParseContentL();

            iOperation->NextStep(iStatus, iProgress);
            SetActive();

            break;
        }

        case THTTPEvent::EFailed:
        {
            RHTTPResponse resp = aTransaction.Response();
            TInt status = resp.StatusCode();

            LOGARG("[LANDMARKS] HTTP response failed %d", status);

            aTransaction.Close();

            iObserver.LandmarkLoaderOpenedL(KErrCouldNotConnect);
            break;
        }

        default:
            LOGARG("[LANDMARKS] HTTP unknown event %d", aEvent.iStatus);

            aTransaction.Close();

            iObserver.LandmarkLoaderOpenedL(KErrUnknown);
            break;
    }
}

TInt CRemoteLoader::MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
    iObserver.LandmarkLoaderOpenedL(aError);

    return KErrNone;
}