/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#include "pvmf_protocol_engine_progressive_download.h"

#define LOGINFODATAPATH(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG,iLogger,PVLOGMSG_INFO,m);
#define PVMF_PROTOCOL_ENGINE_LOGINFODATAPATH(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG,iDataPathLogger,PVLOGMSG_INFO,m);
#define PVMF_PROTOCOL_ENGINE_LOGERRINFODATAPATH(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG,iDataPathErrLogger,PVLOGMSG_INFO,m);


//////	ProgressiveDownloadState_HEAD implementation ////////////////////////////
void ProgressiveDownloadState_HEAD::setRequestBasics()
{
    iComposer->setMethod(HTTP_METHOD_HEAD);
    //iComposer->setVersion(HTTP_V1_1);
    iComposer->setVersion((HTTPVersion)iCfgFile->getHttpVersion());
    StrPtrLen uri((iURI.getURI()).get_cstr(), (iURI.getURI()).get_size());
    iComposer->setURI(uri);
}

bool ProgressiveDownloadState_HEAD::setHeaderFields()
{
    if (!DownloadState::setHeaderFields()) return false;
    if (!ProtocolState::constructAuthenHeader(iCfgFile->GetUserId(), iCfgFile->GetUserAuth())) return false;

    return setExtensionFields(iCfgFile->getExtensionHeaderKeys(),
                              iCfgFile->getExtensionHeaderValues(),
                              iCfgFile->getHTTPMethodMasksForExtensionHeader(),
                              iCfgFile->getExtensionHeadersPurgeOnRedirect(),
                              HTTP_METHOD_HEAD);
}

int32 ProgressiveDownloadState_HEAD::checkParsingStatus(int32 parsingStatus)
{
    if (parsingStatus == HttpParsingBasicObject::PARSE_SUCCESS_END_OF_INPUT && iParser->isHttpHeaderParsed())
        return PROCESS_SUCCESS_END_OF_MESSAGE;

    return ProtocolState::checkParsingStatus(parsingStatus);
}

int32 ProgressiveDownloadState_HEAD::OutputDataAvailable(OUTPUT_DATA_QUEUE *aOutputQueue, const bool isHttpHeader)
{
    if (isHttpHeader)
    {
        iDataSideInfo.set(ProtocolEngineOutputDataType_HttpHeader);
        iObserver->OutputDataAvailable(*aOutputQueue, iDataSideInfo);
    }
    return HttpParsingBasicObject::PARSE_SUCCESS;
}

//////	ProgressiveDownloadState_GET implementation ////////////////////////////
int32 ProgressiveDownloadState_GET::processMicroStateGetResponsePreCheck()
{
    int32 status = DownloadState::processMicroStateGetResponsePreCheck();
    if (status != PROCESS_SUCCESS) return status;

    // set the existing download size if this is resume download
    iParser->setDownloadSize(iCfgFile->GetCurrentFileSize());

    return PROCESS_SUCCESS;
}

bool ProgressiveDownloadState_GET::setHeaderFields()
{
    // only send Range header for previous non-zero bytes position.
    // Some server may not like this, Range: bytes=0-
    if (iCfgFile->GetCurrentFileSize() > 0 && iCfgFile->GetOverallFileSize() > 0)
    {
        StrCSumPtrLen rangeKey = "Range";
        char buffer[64];
        oscl_snprintf(buffer, 64, "bytes=%d-%d", iCfgFile->GetCurrentFileSize(), iCfgFile->GetOverallFileSize());
        LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::setHeaderFields(), Range: bytes=%d-", iCfgFile->GetCurrentFileSize()));
        if (!iComposer->setField(rangeKey, buffer)) return false;
    }

    // set authentication header and common headers
    if (!ProtocolState::constructAuthenHeader(iCfgFile->GetUserId(), iCfgFile->GetUserAuth())) return false;
    if (!DownloadState::setHeaderFields()) return false;

    // change "Connection" field
    StrCSumPtrLen connectionKey = "Connection";
    char *nullPtr = NULL; // remove "Connection" field
    if (!iComposer->setField(connectionKey, nullPtr)) return false;
    // reset "Connection: Close"
    StrPtrLen  connectionValue = "Close";
    if (!iComposer->setField(connectionKey, &connectionValue)) return false;


    return setExtensionFields(iCfgFile->getExtensionHeaderKeys(),
                              iCfgFile->getExtensionHeaderValues(),
                              iCfgFile->getHTTPMethodMasksForExtensionHeader(),
                              iCfgFile->getExtensionHeadersPurgeOnRedirect());
}

int32 ProgressiveDownloadState_GET::updateDownloadStatistics()
{
    int32 status = DownloadState::updateDownloadStatistics();
    if (status == PROCESS_SUCCESS_END_OF_MESSAGE_TRUNCATED)
    {
        iSendEndOfMessageTruncate = true;
    }
    return status;
}


int32 ProgressiveDownloadState_GET::checkParsingStatus(int32 parsingStatus)
{
    // EOS means connection is down, and can be treated as download complete
    if (parsingStatus == HttpParsingBasicObject::PARSE_EOS_INPUT_DATA)
    {
        if (iParser->getDownloadSize() > 0 && iParser->isDownloadReallyHappen())
        {
            iCfgFile->SetCurrentFileSize(iParser->getDownloadSize());
            if (iParser->getContentLength() == 0) iCfgFile->SetOverallFileSize(iParser->getDownloadSize());
            LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::checkParsingStatus(), GOT EOS and COMPLETE DOWNLOAD, downloadSize=%d, contentLength=%d, isDownloadHappen=%d",
                             iParser->getDownloadSize(), iParser->getContentLength(), (int32)iParser->isDownloadReallyHappen()));
            return PROCESS_SUCCESS_END_OF_MESSAGE_BY_SERVER_DISCONNECT;
        }
    }

    // download complete with truncation
    if (iSendEndOfMessageTruncate)
    {
        iSendEndOfMessageTruncate = false;
        return PROCESS_SUCCESS_END_OF_MESSAGE_TRUNCATED;
    }

    return DownloadState::checkParsingStatus(parsingStatus);
}


// From HttpParsingBasicObjectObserver
int32 ProgressiveDownloadState_GET::OutputDataAvailable(OUTPUT_DATA_QUEUE *aOutputQueue, const bool isHttpHeader)
{
    if (isHttpHeader)
    {
        int32 status = checkContentInfoMatchingForResumeDownload();
        if (status != HttpParsingBasicObject::PARSE_SUCCESS) return status;

        iDataSideInfo.set(ProtocolEngineOutputDataType_HttpHeader);
        iObserver->OutputDataAvailable(*aOutputQueue, iDataSideInfo);
    }
    else  	// output data to data stream object
    {
        if (iParser->getDownloadSize() > iCfgFile->GetCurrentFileSize())
        {
            updateOutputDataQueue(aOutputQueue); // aOutputQueue could have the partial valid data for resume download and trucated content case
            iDataSideInfo.set(ProtocolEngineOutputDataType_NormalData);
            iObserver->OutputDataAvailable(*aOutputQueue, iDataSideInfo);
            return updateDownloadStatistics(); // could return PROCESS_SUCCESS_END_OF_MESSAGE_TRUNCATED
        }
    }
    return HttpParsingBasicObject::PARSE_SUCCESS;
}

int32 ProgressiveDownloadState_GET::checkContentInfoMatchingForResumeDownload()
{
    if (iCfgFile->IsNewSession()) return HttpParsingBasicObject::PARSE_SUCCESS;
    uint32 prevOverallFileSize = iCfgFile->GetOverallFileSize();
    if (iCfgFile->GetOverallFileSize() == iCfgFile->GetMaxAllowedFileSize() && !iCfgFile->HasContentLength())
    {
        prevOverallFileSize = 0; // no content-length for the previous download
    }
    int32 status = iParser->isNewContentRangeInfoMatchingCurrentOne(prevOverallFileSize);
    // Get internal download size synced up with new content-range info
    iParser->setDownloadSize();
    return status;
}

void ProgressiveDownloadState_GET::updateOutputDataQueue(OUTPUT_DATA_QUEUE *aOutputQueue)
{
    // get start fragment especially for resume download case
    bool aUseAllNewDownloadData;
    uint32 aStartFragNo = 0, aStartFragOffset = 0;
    getStartFragmentInNewDownloadData(*aOutputQueue, aUseAllNewDownloadData, aStartFragNo, aStartFragOffset);
    if (aUseAllNewDownloadData) return;

    LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue()->getStartFragmentInNewDownloadData() : aOutputQueue->size=%d, aStartFragNo=%d, aStartFragOffset=%d",
                     aOutputQueue->size(), aStartFragNo, aStartFragOffset));

    LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue()->getStartFragmentInNewDownloadData() : downloadSize=%d, currFileSize=%d",
                     iParser->getDownloadSize(), iCfgFile->GetCurrentFileSize()));

    // process start fragment
    if (!(aStartFragNo == 0 && aStartFragOffset == 0))   // exist offset
    {
        OsclMemoryFragment memFrag;
        uint8 *startPtr = (uint8*)((*aOutputQueue)[aStartFragNo].getMemFragPtr()) + aStartFragOffset;
        memFrag.ptr = (OsclAny*)startPtr;
        memFrag.len = (*aOutputQueue)[aStartFragNo].getMemFragSize() - aStartFragOffset;
        OsclRefCounter *refcnt = (*aOutputQueue)[aStartFragNo].getRefCounter();
        OsclRefCounterMemFrag refCountMemFrag = OsclRefCounterMemFrag(memFrag, refcnt, memFrag.len);
        refcnt->addRef(); // manually add reference counter since there will be vector push_back happens.

        for (uint32 i = 0; i <= aStartFragNo; i++)
        {
            aOutputQueue->erase(aOutputQueue->begin());
        }
        if (memFrag.len > 0) aOutputQueue->push_front(refCountMemFrag);

        LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue() after processing start fragment: aOutputQueue->size=%d",	aOutputQueue->size()));
    }

    // get end fragment especially for truncated content case
    uint32 aEndFragNo = 0, aEndFragValidLen = 0;
    getEndFragmentInNewDownloadData(*aOutputQueue, aEndFragNo, aEndFragValidLen);

    LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue()->getEndFragmentInNewDownloadData() : aOutputQueue->size=%d, aEndFragNo=%d, aEndFragValidLen=%d",
                     aOutputQueue->size(), aEndFragNo, aEndFragValidLen));

    LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue()->getStartFragmentInNewDownloadData() : downloadSize=%d, overallFileSize=%d",
                     iParser->getDownloadSize(), iCfgFile->GetOverallFileSize()));

    // process end fragment
    if (!(aEndFragNo == aOutputQueue->size() - 1 &&
            aEndFragValidLen == (*aOutputQueue)[aEndFragNo].getMemFragSize()))
    {
        OsclMemoryFragment memFrag;
        memFrag.ptr = (*aOutputQueue)[aEndFragNo].getMemFragPtr();
        memFrag.len = aEndFragValidLen;
        OsclRefCounter *refcnt = (*aOutputQueue)[aEndFragNo].getRefCounter();
        OsclRefCounterMemFrag refCountMemFrag = OsclRefCounterMemFrag(memFrag, refcnt, memFrag.len);
        refcnt->addRef(); // manually add reference counter since there will be vector push_back happens.

        for (int32 j = (int32)aOutputQueue->size() - 1; j >= (int32)aEndFragNo; j--)
        {
            aOutputQueue->erase(&(aOutputQueue->back()));
        }

        aOutputQueue->push_back(refCountMemFrag);

        LOGINFODATAPATH((0, "ProgressiveDownloadState_GET::updateOutputDataQueue() after processing end fragment: aOutputQueue->size=%d", aOutputQueue->size()));
    }
}

void ProgressiveDownloadState_GET::getStartFragmentInNewDownloadData(OUTPUT_DATA_QUEUE &aOutputQueue,
        bool &aUseAllNewDownloadData,
        uint32 &aStartFragNo,
        uint32 &aStartFragOffset)
{
    aUseAllNewDownloadData = false;
    aStartFragNo = aStartFragOffset = 0;

    uint32 validSize = iParser->getDownloadSize() - iCfgFile->GetCurrentFileSize();

    uint32 totalSize = 0, prevTotalSize = 0;
    for (uint32 i = 0; i < aOutputQueue.size(); i++)
    {
        prevTotalSize = totalSize;
        totalSize += aOutputQueue[i].getMemFragSize();
        if (prevTotalSize <= validSize && validSize < totalSize)
        {
            if (validSize < totalSize && i < aOutputQueue.size() - 1)
            {
                aStartFragNo = i;
                aStartFragOffset = validSize - prevTotalSize;
                return;
            }
        }
    }

    aUseAllNewDownloadData = (validSize == totalSize) &
                             (iParser->getDownloadSize() <= iCfgFile->GetOverallFileSize());
}

void ProgressiveDownloadState_GET::getEndFragmentInNewDownloadData(OUTPUT_DATA_QUEUE &aOutputQueue,
        uint32 &aEndFragNo,
        uint32 &aEndFragValidLen)
{
    aEndFragNo = aOutputQueue.size() - 1;
    aEndFragValidLen = aOutputQueue[aEndFragNo].getMemFragSize();

    if (iParser->getDownloadSize() > iCfgFile->GetOverallFileSize())
    {
        uint32 extraSize = iParser->getDownloadSize() - iCfgFile->GetOverallFileSize();
        uint32 reduceSize = 0, prevReduceSize = 0;
        for (int32 i = aOutputQueue.size() - 1; i >= 0; i--)
        {
            prevReduceSize = reduceSize;
            reduceSize += aOutputQueue[i].getMemFragSize();
            if (prevReduceSize <= extraSize && extraSize < reduceSize)
            {
                aEndFragNo = i;
                aEndFragValidLen = reduceSize - extraSize;
                return;
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////
//////	ProgressiveStreamingState implementation
////////////////////////////////////////////////////////////////////////////////////

int32 ProgressiveStreamingState_GET::checkParsingStatus(int32 parsingStatus)
{
    // download complete with truncation
    if (iSendEndOfMessageTruncate)
    {
        iSendEndOfMessageTruncate = false;
        return PROCESS_SUCCESS_END_OF_MESSAGE_TRUNCATED;
    }

    return DownloadState::checkParsingStatus(parsingStatus);
}