/* ------------------------------------------------------------------
 * 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.
 * -------------------------------------------------------------------
 */
#ifndef PVMF_SOURCE_CONTEXT_DATA_H_INCLUDED
#define PVMF_SOURCE_CONTEXT_DATA_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif
#ifndef OSCL_STRING_H_INCLUDED
#include "oscl_string.h"
#endif
#ifndef OSCL_STRING_CONTAINERS_H_INCLUDED
#include "oscl_string_containers.h"
#endif
#ifndef PV_UUID_H_INCLUDED
#include "pv_uuid.h"
#endif
#ifndef PV_INTERFACE_H_INCLUDED
#include "pv_interface.h"
#endif

#define PVMF_SOURCE_CONTEXT_DATA_UUID PVUuid(0xf218cdfc,0x797d,0x453e,0x9c,0x94,0x8f,0x0e,0x83,0x8a,0xa1,0x99)

#define PVMF_SOURCE_CONTEXT_DATA_COMMON_UUID PVUuid(0xa6b5f829,0x8ead,0x4c21,0xad,0x40,0x8c,0xc5,0x10,0x05,0xb5,0xfa)
#define PVMF_SOURCE_CONTEXT_DATA_STREAMING_UUID PVUuid(0x0b8a0087,0xd539,0x4ee0,0x88,0x8d,0x0c,0x1c,0x70,0xf0,0x33,0x59)
#define PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_HTTP_UUID PVUuid(0x731e4269,0x849b,0x4123,0x92,0x6f,0xaf,0x27,0xc9,0x8a,0x2e,0xab)
#define PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_PVX_UUID PVUuid(0x3dbb1b51,0x49ea,0x4933,0xa6,0xec,0x26,0x97,0x43,0x12,0xb6,0xd6)
#define PVMF_SOURCE_CONTEXT_DATA_PVR_UUID PVUuid(0x442059a2,0x76b6,0x11dc,0x83,0x14,0x08,0x00,0x20,0x0c,0x9a,0x66)
#define PVMF_SOURCE_CONTEXT_DATA_PACKETSOURCE_UUID PVUuid(0x7f064f8c,0xa90d,0x11dc,0x83,0x14,0x08,0x00,0x20,0x0c,0x9a,0x66)
//3f9c615e-31e2-474c-9add-29c61dd07ead

class OsclFileHandle;
class PVMFCPMPluginAccessInterfaceFactory;

#define BITMASK_PVMF_SOURCE_INTENT_PLAY          0x00000001
#define BITMASK_PVMF_SOURCE_INTENT_GETMETADATA   0x00000002
#define BITMASK_PVMF_SOURCE_INTENT_PREVIEW       0x00000004
#define BITMASK_PVMF_SOURCE_INTENT_THUMBNAILS    0x00000008

class PVMFSourceContextDataCommon : public PVInterface
{
    public:
        PVMFSourceContextDataCommon()
        {
            iRefCounter = 0;
            iFileHandle = NULL;
            iPreviewMode = false;
            iIntent = BITMASK_PVMF_SOURCE_INTENT_PLAY;
            iContentAccessFactory = NULL;
            iRecognizerDataStreamFactory = NULL;
        };

        PVMFSourceContextDataCommon(const PVMFSourceContextDataCommon& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataCommon& operator=(const PVMFSourceContextDataCommon& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }
        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_COMMON_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }
        int32 iRefCounter;

        //Optional file handle.
        OsclFileHandle* iFileHandle;

        //Optional field to indicate if the source that is being
        //passed in will be played back in a preview mode.
        bool iPreviewMode;

        //Optional field to indicate if the source that is being
        //passed in will be used for play back or just for metadata retrieval
        uint32 iIntent;

        //HTTP proxy name, either ip or dns, for DRM License Acquisition purposes
        OSCL_wHeapString<OsclMemAllocator> iDRMLicenseProxyName;

        //HTTP proxy port, for DRM for DRM License Acquisition purposes
        int32 iDRMLicenseProxyPort;

        //external datastream for usecases where the input file is controlled by the app
        PVMFCPMPluginAccessInterfaceFactory* iContentAccessFactory;

        //external datastream for usecases where input file to be recognized is controlled by the app
        PVMFCPMPluginAccessInterfaceFactory* iRecognizerDataStreamFactory;

    private:
        void MyCopy(const PVMFSourceContextDataCommon& aSrc)
        {
            iFileHandle             = aSrc.iFileHandle;
            iPreviewMode            = aSrc.iPreviewMode;
            iIntent                 = aSrc.iIntent;
            iDRMLicenseProxyName    = aSrc.iDRMLicenseProxyName;
            iDRMLicenseProxyPort    = aSrc.iDRMLicenseProxyPort;
            iContentAccessFactory   = aSrc.iContentAccessFactory;
            iRecognizerDataStreamFactory = aSrc.iRecognizerDataStreamFactory;
        };
};

class PVMFSourceContextDataStreaming : public PVInterface
{
    public:
        //default constructor
        PVMFSourceContextDataStreaming()
        {
            iRefCounter = 0;
            iProxyPort = 0;
        };

        PVMFSourceContextDataStreaming(const PVMFSourceContextDataStreaming& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataStreaming& operator=(const PVMFSourceContextDataStreaming& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }
        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_STREAMING_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }
        int32 iRefCounter;

        //Optional logging url.
        //When present, streaming stats will be sent to this URL.
        //Typically applies to MS HTTP Streaming sessions
        OSCL_wHeapString<OsclMemAllocator> iStreamStatsLoggingURL;

        //HTTP proxy name, either ip or dns
        OSCL_wHeapString<OsclMemAllocator> iProxyName;

        //HTTP proxy port
        int32 iProxyPort;

        // Optional UserID and UserAuthentication (e.g. password) string
        // used for HTTP basic/digest authentication
        OSCL_HeapString<OsclMemAllocator> iUserID;
        OSCL_HeapString<OsclMemAllocator> iUserPasswd;

    private:
        void MyCopy(const PVMFSourceContextDataStreaming& aSrc)
        {
            iStreamStatsLoggingURL  = aSrc.iStreamStatsLoggingURL;
            iProxyName              = aSrc.iProxyName;
            iProxyPort              = aSrc.iProxyPort;
            iUserID                 = aSrc.iUserID;
            iUserPasswd             = aSrc.iUserPasswd;
        };
};

//Source data for HTTP Progressive download (format type PVMF_DATA_SOURCE_HTTP_URL)
class PVMFSourceContextDataDownloadHTTP : public PVInterface
{
    public:
        PVMFSourceContextDataDownloadHTTP()
        {
            iRefCounter = 0;
            bIsNewSession = true;
            iMaxFileSize = 0;
        };

        PVMFSourceContextDataDownloadHTTP(const PVMFSourceContextDataDownloadHTTP& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataDownloadHTTP& operator=(const PVMFSourceContextDataDownloadHTTP& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }
        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_HTTP_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }
        int32 iRefCounter;

        bool    bIsNewSession;              //true if the downloading a new file
        //false if keep downloading a partial downloading file
        OSCL_wHeapString<OsclMemAllocator> iConfigFileName;     //download config file
        OSCL_wHeapString<OsclMemAllocator> iDownloadFileName;   //local file name of the downloaded clip
        uint32  iMaxFileSize;               //the max size of the file.
        OSCL_HeapString<OsclMemAllocator> iProxyName;           //HTTP proxy name, either ip or dns
        int32   iProxyPort;                 //HTTP proxy port

        typedef enum        // For Download only
        {
            ENoPlayback         = 0,
            EAfterDownload,
            EAsap,
            ENoSaveToFile,
            EReserve
        } TPVPlaybackControl;
        TPVPlaybackControl  iPlaybackControl;

        // Optional UserID and UserAuthentication (e.g. password) string
        // used for HTTP basic/digest authentication
        OSCL_HeapString<OsclMemAllocator> iUserID;
        OSCL_HeapString<OsclMemAllocator> iUserPasswd;

    private:
        void MyCopy(const PVMFSourceContextDataDownloadHTTP& aSrc)
        {
            bIsNewSession       = aSrc.bIsNewSession;
            iConfigFileName     = aSrc.iConfigFileName;
            iDownloadFileName   = aSrc.iDownloadFileName;
            iMaxFileSize        = aSrc.iMaxFileSize;
            iProxyName          = aSrc.iProxyName;
            iProxyPort          = aSrc.iProxyPort;
            iUserID             = aSrc.iUserID;
            iUserPasswd         = aSrc.iUserPasswd;
        };
};

class CPVXInfo;

//Source data for Fasttrack download (format type PVMF_DATA_SOURCE_PVX_FILE)
class PVMFSourceContextDataDownloadPVX : public PVInterface
{
    public:
        PVMFSourceContextDataDownloadPVX()
        {
            iRefCounter = 0;
            bIsNewSession = true;
            iMaxFileSize = 0;
        }

        PVMFSourceContextDataDownloadPVX(const PVMFSourceContextDataDownloadPVX& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataDownloadPVX& operator=(const PVMFSourceContextDataDownloadPVX& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }
        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_PVX_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }
        int32 iRefCounter;

        bool    bIsNewSession;              //true if the downloading a new file
        //false if keep downloading a partial downloading file
        OSCL_wHeapString<OsclMemAllocator> iConfigFileName;     //download config file
        OSCL_wHeapString<OsclMemAllocator> iDownloadFileName;   //local file name of the downloaded clip
        uint32  iMaxFileSize;               //the max size of the file.
        OSCL_HeapString<OsclMemAllocator> iProxyName;           //HTTP proxy name, either ip or dns
        int32   iProxyPort;                 //HTTP proxy port

        CPVXInfo *iPvxInfo;                 //class which contains all the info in the .pvx file except the URL

    private:
        void MyCopy(const PVMFSourceContextDataDownloadPVX& aSrc)
        {
            bIsNewSession = aSrc.bIsNewSession;
            iConfigFileName = aSrc.iConfigFileName;
            iDownloadFileName = aSrc.iDownloadFileName;
            iMaxFileSize = aSrc.iMaxFileSize;
            iProxyName = aSrc.iProxyName;
            iProxyPort = aSrc.iProxyPort;
            iPvxInfo = aSrc.iPvxInfo;
        };
};


//Source Context Data for PVR
class PVMFPVRControl;

class PVMFSourceContextDataPVR : public PVInterface
{
    public:
        //default constructor
        PVMFSourceContextDataPVR()
        {
            iRefCounter = 0;
            iPVMFPVRControl = NULL;
            iLiveBufferSizeInSeconds = 0;
        };

        PVMFSourceContextDataPVR(const PVMFSourceContextDataPVR& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            iPVMFPVRControl = NULL;
            iLiveBufferSizeInSeconds = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataPVR& operator=(const PVMFSourceContextDataPVR& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        void SetPVRControl(PVMFPVRControl* aPVMFPVRControl)
        {
            iPVMFPVRControl = aPVMFPVRControl;
        }

        PVMFPVRControl* GetPVRControl()
        {
            return iPVMFPVRControl;
        }


//  void SetLiveBufferSizeInSeconds(uint32 aLiveBufferSizeInSeconds)
//  {
//      iLiveBufferSizeInSeconds = aLiveBufferSizeInSeconds;
//  }

//  uint32 LiveBufferSizeInSeconds()
//  {
//      return iLiveBufferSizeInSeconds;
//  }

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }

        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_PVR_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }

    private:
        void MyCopy(const PVMFSourceContextDataPVR& aSrc)
        {
            // \todo: check this copy constructor
            iPVMFPVRControl = aSrc.iPVMFPVRControl;
            iLiveBufferSizeInSeconds = aSrc.iLiveBufferSizeInSeconds;
        };

        // reference counter
        int32 iRefCounter;


        // This class doesn't own PVMFPVRControl
        PVMFPVRControl* iPVMFPVRControl;

        // temp buffer size in seconds
        uint32 iLiveBufferSizeInSeconds;
};


class PVMFPacketSource;

class PVMFSourceContextDataPacketSource : public PVInterface
{
    public:
        //default constructor
        PVMFSourceContextDataPacketSource()
        {
            iRefCounter = 0;
            iPacketSourcePlugin = NULL;
        };

        PVMFSourceContextDataPacketSource(const PVMFSourceContextDataPacketSource& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextDataPacketSource& operator=(const PVMFSourceContextDataPacketSource& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        void SetPacketSourcePlugin(PVMFPacketSource* aPacketSourcePlugin)
        {
            iPacketSourcePlugin = aPacketSourcePlugin;
        }

        PVMFPacketSource* GetPacketSourcePlugin()
        {
            return iPacketSourcePlugin;
        }

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }

        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_PACKETSOURCE_UUID))
            {
                iface = this;
                return true;
            }
            else
            {
                iface = NULL;
                return false;
            }
        }

    private:
        void MyCopy(const PVMFSourceContextDataPacketSource& aSrc)
        {
            // \todo: check this copy constructor
            iPacketSourcePlugin = aSrc.iPacketSourcePlugin;
        };

        // reference counter
        int32 iRefCounter;

        // This class doesn't own PVMFPVRControl
        PVMFPacketSource* iPacketSourcePlugin;
};

class PVMFSourceContextData : public PVInterface
{
    public:
        PVMFSourceContextData()
        {
            iRefCounter = 0;
            iCommonDataContextValid = false;
            iStreamingDataContextValid = false;
            iDownloadHTTPDataContextValid = false;
            iDownloadPVXDataContextValid = false;
            iPVRDataContextValid = false;
            iPacketSourceDataContextValid = false;
        };

        PVMFSourceContextData(const PVMFSourceContextData& aSrc) : PVInterface(aSrc)
        {
            iRefCounter = 0;
            MyCopy(aSrc);
        };

        PVMFSourceContextData& operator=(const PVMFSourceContextData& aSrc)
        {
            if (&aSrc != this)
            {
                MyCopy(aSrc);
            }
            return *this;
        };

        /* From PVInterface */
        void addRef()
        {
            iRefCounter++;
        }
        void removeRef()
        {
            iRefCounter--;
        }
        bool queryInterface(const PVUuid& uuid, PVInterface*& iface)
        {
            if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_UUID))
            {
                iface = this;
                return true;
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_COMMON_UUID))
            {
                if (iCommonDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataCommon;
                    return true;
                }
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_STREAMING_UUID))
            {
                if (iStreamingDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataStreaming;
                    return true;
                }
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_HTTP_UUID))
            {
                if (iDownloadHTTPDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataDownloadHTTP;
                    return true;
                }
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_DOWNLOAD_PVX_UUID))
            {
                if (iDownloadPVXDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataDownloadPVX;
                    return true;
                }
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_PVR_UUID))
            {
                if (iPVRDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataPVR;
                    return true;
                }
            }
            else if (uuid == PVUuid(PVMF_SOURCE_CONTEXT_DATA_PACKETSOURCE_UUID))
            {
                if (iPacketSourceDataContextValid == true)
                {
                    iface = &iPVMFSourceContextDataPacketSource;
                    return true;
                }
            }

            iface = NULL;
            return false;
        }

        void EnableCommonSourceContext()
        {
            iCommonDataContextValid = true;
        }
        void EnableStreamingSourceContext()
        {
            iStreamingDataContextValid = true;
        }
        void EnableDownloadHTTPSourceContext()
        {
            iDownloadHTTPDataContextValid = true;
        }
        void EnableDownloadPVXSourceContext()
        {
            iDownloadPVXDataContextValid = true;
        }
        void EnablePVRSourceContext()
        {
            iPVRDataContextValid = true;
        }
        void EnablePacketSourceSourceContext()
        {
            iPacketSourceDataContextValid = true;
        }
        void DisableCommonSourceContext()
        {
            iCommonDataContextValid = false;
        }
        void DisableStreamingSourceContext()
        {
            iStreamingDataContextValid = false;
        }
        void DisableeDownloadHTTPSourceContext()
        {
            iDownloadHTTPDataContextValid = false;
        }
        void DisableDownloadPVXSourceContext()
        {
            iDownloadPVXDataContextValid = false;
        }
        void DisablePVRSourceContext()
        {
            iPVRDataContextValid = false;
        }
        void DisablePacketSourceSourceContext()
        {
            iPacketSourceDataContextValid = false;
        }
        PVMFSourceContextDataCommon* CommonData()
        {
            return iCommonDataContextValid ? &iPVMFSourceContextDataCommon : NULL;
        }
        PVMFSourceContextDataStreaming* StreamingData()
        {
            return iStreamingDataContextValid ? &iPVMFSourceContextDataStreaming : NULL;
        }
        PVMFSourceContextDataDownloadHTTP* DownloadHTTPData()
        {
            return iDownloadHTTPDataContextValid ? &iPVMFSourceContextDataDownloadHTTP : NULL;
        }
        PVMFSourceContextDataDownloadPVX* DownloadPVXData()
        {
            return iDownloadPVXDataContextValid ? &iPVMFSourceContextDataDownloadPVX : NULL;
        }
        PVMFSourceContextDataPVR* PVRData()
        {
            return iPVRDataContextValid ? &iPVMFSourceContextDataPVR : NULL;
        }
        PVMFSourceContextDataPacketSource* PacketSourceData()
        {
            return iPacketSourceDataContextValid ? &iPVMFSourceContextDataPacketSource : NULL;
        }

    private:
        int32 iRefCounter;
        bool iCommonDataContextValid;
        bool iStreamingDataContextValid;
        bool iDownloadHTTPDataContextValid;
        bool iDownloadPVXDataContextValid;
        bool iPVRDataContextValid;
        bool iPacketSourceDataContextValid;

        PVMFSourceContextDataCommon iPVMFSourceContextDataCommon;
        PVMFSourceContextDataStreaming iPVMFSourceContextDataStreaming;
        PVMFSourceContextDataDownloadHTTP iPVMFSourceContextDataDownloadHTTP;
        PVMFSourceContextDataDownloadPVX iPVMFSourceContextDataDownloadPVX;
        PVMFSourceContextDataPVR iPVMFSourceContextDataPVR;
        PVMFSourceContextDataPacketSource iPVMFSourceContextDataPacketSource;

        void MyCopy(const PVMFSourceContextData& aSrc)
        {
            iCommonDataContextValid = aSrc.iCommonDataContextValid;
            iStreamingDataContextValid = aSrc.iStreamingDataContextValid;
            iDownloadHTTPDataContextValid = aSrc.iDownloadHTTPDataContextValid;
            iDownloadPVXDataContextValid = aSrc.iDownloadPVXDataContextValid;
            iPVRDataContextValid = aSrc.iPVRDataContextValid;
            iPacketSourceDataContextValid = aSrc.iPacketSourceDataContextValid;

            iPVMFSourceContextDataCommon = aSrc.iPVMFSourceContextDataCommon;
            iPVMFSourceContextDataStreaming = aSrc.iPVMFSourceContextDataStreaming;
            iPVMFSourceContextDataDownloadHTTP = aSrc.iPVMFSourceContextDataDownloadHTTP;
            iPVMFSourceContextDataDownloadPVX = aSrc.iPVMFSourceContextDataDownloadPVX;
            iPVMFSourceContextDataPVR = aSrc.iPVMFSourceContextDataPVR;
            iPVMFSourceContextDataPacketSource = aSrc.iPVMFSourceContextDataPacketSource;
        };
};

#endif //PVMF_SOURCE_CONTEXT_DATA_H_INCLUDED