/* ------------------------------------------------------------------
 * 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 PVRTSP_CLIENT_ENGINE_NODE_H
#define PVRTSP_CLIENT_ENGINE_NODE_H


#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif

#ifndef OSCL_UTF8CONV_H
#include "oscl_utf8conv.h"
#endif

#ifndef OSCL_ERROR_CODES_H_INCLUDED
#include "oscl_error_codes.h"
#endif

#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
#include "oscl_scheduler_ao.h"
#endif

#ifndef OSCL_SOCKET_TYPES_H_INCLUDED
#include "oscl_socket_types.h"
#endif

#ifndef OSCL_SOCKET_H_INCLUDED
#include "oscl_socket.h"
#endif

#ifndef OSCL_DNS_H_INCLUDED
#include "oscl_dns.h"
#endif

#ifndef OSCL_STRING_CONTAINERS_H_INCLUDED
#include "oscl_string_containers.h"
#endif

#ifndef PVMF_MEDIA_CLOCK_H_INCLUDED
#include "pvmf_media_clock.h"
#endif

#ifndef OSCL_TIMER_H_INCLUDED
#include "oscl_timer.h"
#endif

#ifndef PVMF_FORMAT_TYPE_H_INCLUDED
#include "pvmf_format_type.h"
#endif

#ifndef PVMF_NODE_INTERFACE_H_INCLUDED
#include "pvmf_node_interface.h"
#endif

#ifndef PVMF_NODE_UTILS_H_INCLUDED
#include "pvmf_node_utils.h"
#endif

#ifndef OSCL_PRIQUEUE_H_INCLUDED
#include "oscl_priqueue.h"
#endif

#ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
#include "pvmf_simple_media_buffer.h"
#endif

#ifndef OSCL_MEM_MEMPOOL_H_INCLUDED
#include "oscl_mem_mempool.h"
#endif

#ifndef PVLOGGER_H_INCLUDED
#include "pvlogger.h"
#endif

#ifndef PVRTSP_ENGINE_NODE_EXTENSION_INTERFACE_H_INCLUDED
#include "pvrtspenginenodeextensioninterface.h"
#endif

#ifndef RTSP_PAR_COM_MESSAGE_DS_H_
#include "rtsp_par_com_message.h"
#endif

#ifndef RTSP_PARSER_H_
#include "rtsp_parser.h"
#endif

#ifndef SDP_PARSER_H
#include "sdp_parser.h"
#endif

#ifndef PVMF_RTSP_PORT_H_INCLUDED
#include "pvrtsp_client_engine_port.h"
#endif

#ifndef OSCL_FILEIO_H_INCLUDED
#include "oscl_file_io.h"
#endif

#ifndef PVMF_STREAMING_REAL_INTERFACES_INCLUDED
#include "pvmf_streaming_real_interfaces.h"
#endif

#ifndef PAYLOAD_PARSER_H_INCLUDED
#include "payload_parser.h"
#endif

#ifndef PVMF_SM_CONFIG_H_INCLUDED
#include "pvmf_sm_config.h"
#endif

//Default vector reserve size
#define PVMF_RTSP_ENGINE_NODE_COMMAND_VECTOR_RESERVE 10

//Starting value for command IDs
#define PVMF_RTSP_ENGINE_NODE_COMMAND_ID_START 6000

#define MAX_TOTAL_TRACKS 4 /* maximum number of channels per session */

//The RTSP state enumeration
typedef enum
{
    STATE_INIT,
    STATE_READY,
    STATE_PLAYING,
    //STATE_RECORDING
} SessionState;

typedef struct _DataChannelInfo
{
    uint8 *hexSID;

    bool   ssrc_is_set;
    uint32 ssrc;

    bool   seqbase_is_set;
    uint32 seq;

    bool   rtptime_is_set;
    uint32 rtptime;

    int32  offset;
    uint32 timescale;
    uint32 rtcp_interval;
} DataChannelInfo;

//memory allocator type for this node.
typedef OsclMemAllocator PVRTSPEngineNodeAllocator;

class SessionInfo
{
    public:
        //bool sdpFlag;             //Used to make sure that we read into the mediainfo array after it has been assigned
        //SDP_ERROR_CODE sdpErrorCode;            //Saves the value returned from the sdp parser

        OSCL_HeapString<PVRTSPEngineNodeAllocator> iSessionURL;
        OSCL_HeapString<PVRTSPEngineNodeAllocator> iContentBaseURL;//Per session control URL from content base field

        OSCL_HeapString<PVRTSPEngineNodeAllocator> iServerName; //could be either DNS or ip address

        OSCL_HeapString<PVRTSPEngineNodeAllocator> iProxyName;  //could be either DNS or ip address
        uint32  iProxyPort;

        OsclNetworkAddress iSrvAdd;

        bool bExternalSDP;          //true if got SDP through external(NOT DESCRIBE) methods

        RtspRangeType   iReqPlayRange;
        RtspRangeType   iActPlayRange;

        OsclRefCounterMemFrag   pSDPBuf;

        OsclSharedPtr<SDPInfo>  iSDPinfo;
        //SDP_Parser *iSDPparser;       //Pointer to the SDP_Parser class object
        Oscl_Vector<StreamInfo, PVRTSPEngineNodeAllocator> iSelectedStream;

        //Form the track to channel association table. This table is used while
        //interacting with the media buffer. This table is needed to convert from an index
        //based on the number of tracks in the SDP to an index into the number of tracks
        //actually selected. For eg, the SDP might have 5 media tracks, but the number of tracks
        //that get selected could be 2. If the first track that gets selected corresponds to the third
        //track in the SDP list, then the mapping would be 2 -> 0. Similarly, if the second track that
        //gets selected is the fifth in the SDP list, the mapping would be 4 -> 1.
        //All indices begin from 0.
        /*
        for(int ii = 0; ii < numberOfChannels; ii++)
        {
            int sdp_track_id = pSessionInfo->trackSelectionList->getTrackIndex(ii);
            pSessionInfo->channel_tbl[sdp_track_id] = ii;
        }
        */
        int number_of_channels;                 //Used for interaction with the media buffer class
        int channel_tbl[MAX_TOTAL_TRACKS];      //Index from SDP track IDs to tracks actually selected

        OSCL_HeapString<PVRTSPEngineNodeAllocator> iSID;    //alphanumeric session ID

        //OsclMemoryFragment pImgBuf;

        bool serverReplyFlag;           //Used for communication between the PVStream modules (network module and the task scheduler)
        bool getStateFlag;              //Used to ensure that the PE's main loop has been called
        bool pvServerIsSetFlag;             //Used to indicate if we are streaming from PVServer or not
        bool tSIDIsSetFlag;             //Used to send session id from second SETUP request
        uint32 iServerVersionNumber;    // Version number of PVSS
        int32 prerollDuration;                  //Saves the jitter buffer size

        int32 fwp_counter;              //Id of the first returned firewall packet
        int32 rtt;                              //Saves the round trip time for firewall exchange
        uint32 roundTripDelay;                   //Saves the round trip delay for a DESCRIBE request
        uint64 clientServerDelay;                //Saves the client server delay during a DESCRIBE request

        bool pipeLineFlag;                      //Used to indicate a pipe lined request

        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iUserAgent;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iUserNetwork;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iDeviceInfo;

        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iUserID;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iAuthentication;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iExpiration;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iApplicationSpecificString;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iVerification;
        OSCL_HeapString<PVRTSPEngineNodeAllocator>  iSignature;

        enum PVRTSPStreamingType iStreamingType;

        bool                                       iSessionCompleted;
        void UpdateSessionCompletionStatus(bool aSessionCompleted)
        {
            iSessionCompleted = aSessionCompleted;
        }

    public:
        SessionInfo():
                iProxyPort(0),
                bExternalSDP(false),
                pvServerIsSetFlag(false),
                iServerVersionNumber(0),
                roundTripDelay(0),
                iSessionCompleted(false)
        {
            iUserAgent += _STRLIT_CHAR("PVPlayer ");
            iReqPlayRange.format = RtspRangeType::INVALID_RANGE;
        };

} ;

class RTSPNodeMemDestructDealloc : public OsclDestructDealloc
{
    public:
        virtual void destruct_and_dealloc(OsclAny *ptr)
        {
            OSCL_FREE(ptr);
        }
};

typedef PVMFGenericNodeCommand<PVRTSPEngineNodeAllocator> PVRTSPEngineCommandBase;

enum TPVMFRtspNodeCommand //TPVMFGenericNodeCommand
{
    PVMF_RTSP_NODE_ERROR_RECOVERY = PVMF_GENERIC_NODE_COMMAND_LAST + 1
    , PVMF_RTSP_NODE_CANCELALLRESET
};
class PVRTSPEngineCommand: public PVRTSPEngineCommandBase
{
    public:

        void Construct(PVMFSessionId s, int32 cmd, int32 arg1, int32 arg2, int32& arg3, \
                       const OsclAny*aContext)
        {
            PVRTSPEngineCommandBase::Construct(s, cmd, aContext);
            iParam1 = (OsclAny*)arg1;
            iParam2 = (OsclAny*)arg2;
            iParam3 = (OsclAny*) & arg3;
        }
        void Parse(int32&arg1, int32&arg2, int32*&arg3)
        {
            arg1 = (int32)iParam1;
            arg2 = (int32)iParam2;
            arg3 = (int32*)iParam3;
        }
        virtual bool hipri()
        {
            if (iCmd == PVMF_RTSP_NODE_ERROR_RECOVERY)
                return true;

            return PVRTSPEngineCommandBase::hipri();
        }

        /*
        PVMFSessionId iCmdSid;
        int32 iCmdId;
        TPVMFGenericNodeCommand iCmdType;
        OsclAny* iContext;
        PVMFPortInterface* iPort;
        OsclAny* iData1;
        OsclAny* iData2;
        OsclAny* iData3;
        */
    private:
        //PVRTSPEngineCommand(const PVRTSPEngineCommand& aCmd);
};

//Command queue type
typedef PVMFNodeCommandQueue<PVRTSPEngineCommand, PVRTSPEngineNodeAllocator> PVRTSPEngineNodeCmdQ;

class PVRTSPGenericMessageCompareLess
{
    public:
        /**
        * The algorithm used in OsclPriorityQueue needs a compare function
        * that returns true when A's priority is less than B's
        * @return true if A's priority is less than B's, else false
            */
        int compare(RTSPGenericMessage* a, RTSPGenericMessage* b) const
        {
            return (PVRTSPGenericMessageCompareLess::GetPriority(*a) > PVRTSPGenericMessageCompareLess::GetPriority(*b));
        }

        /**
        * Returns the priority of each command
        * @return A 0-based priority number. A lower number indicates lower priority.
        */
        static int GetPriority(RTSPGenericMessage &aCmd)
        {//for cseq numbers, the low numbers come first. so higher priority
            return aCmd.cseq;
        }
};

class GetPostCorrelationObject
{
    public:
        // factory method
        static GetPostCorrelationObject *create(OSCL_TCHAR* aFileName = NULL);
        // destructor
        ~GetPostCorrelationObject();

        // get post correlation value
        uint8 get() const
        {
            return iGetPostCorrelation;
        }
        // increase get post correlation value by 1 within [1, 255]
        bool update();

    private:
        // constructor
        GetPostCorrelationObject()
        {
            ;
        }
        bool construct(OSCL_TCHAR* aFileName);
        void closeFile();
        bool writeToFile();

    private:
        uint8 iGetPostCorrelation;
        bool iFileCreated; // check for the file creation

        // File IO stuff
        Oscl_FileServer iFs;
        Oscl_File iGetPostCorrelationFile;
};

class PVRTSPEngineNode
        : public PVInterface,
        public PVMFNodeInterface,
        public OsclTimerObject,
        public OsclSocketObserver,
        public OsclDNSObserver,
        public OsclTimerObserver,
        public OsclMemPoolFixedChunkAllocatorObserver
{
    public:
        OSCL_IMPORT_REF PVRTSPEngineNode(int32 aPriority);
        OSCL_IMPORT_REF virtual ~PVRTSPEngineNode();

        //************ begin PVMFNodeInterface

        OSCL_IMPORT_REF virtual  PVMFStatus ThreadLogon();
        OSCL_IMPORT_REF virtual  PVMFStatus ThreadLogoff();

        /**
        GetCapability can be invoked only when after a node is initialized
        **/
        OSCL_IMPORT_REF virtual  PVMFStatus GetCapability(PVMFNodeCapability& aNodeCapability);

        /**
         * Returns a list of ports currently available in the node that meet the filter criteria
         * We can add fancier iterators and filters as needed.
         * For now we return all the available ports.  If no ports are present, NULL is returned
         **/
        OSCL_IMPORT_REF virtual  PVMFPortIter* GetPorts(const PVMFPortFilter* aFilter = NULL);

        /**
         * This API is to allow for extensibility of the PVMF Node interface.
         * It allows a caller to ask for all UUIDs associated with a particular MIME type.
         * If interfaces of the requested MIME type are found within the system, they are added
         * to the UUIDs array.
         *
         * Also added to the UUIDs array will be all interfaces which have the requested MIME
         * type as a base MIME type.  This functionality can be turned off.
         *
         * @param aMimeType The MIME type of the desired interfaces
         * @param aUuids A vector to hold the discovered UUIDs
         * @param aExactUuidsOnly Turns on/off the retrival of UUIDs with aMimeType as a base type
         * @param aContext Optional opaque data to be passed back to user with the command response
         * @returns A unique command id for asynchronous completion
         */
        OSCL_IMPORT_REF virtual PVMFCommandId QueryUUID(PVMFSessionId aSession
                , const PvmfMimeString& aMimeType
                , Oscl_Vector<PVUuid, PVRTSPEngineNodeAllocator>& aUuids
                , bool aExactUuidsOnly = false
                                         , const OsclAny* aContext = NULL);

        /**
         * This API is to allow for extensibility of the PVMF Node interface.
         * It allows a caller to ask for an instance of a particular interface object to be returned.
         * The mechanism is analogous to the COM IUnknown method.  The interfaces are identified with
         * an interface ID that is a UUID as in DCE and a pointer to the interface object is
         * returned if it is supported.  Otherwise the returned pointer is NULL.
         *
         * @param aUuid The UUID of the desired interface
         * @param aInterfacePtr The output pointer to the desired interface
         * @param aContext Optional opaque data to be passed back to user with the command response
         * @returns A unique command id for asynchronous completion
         */
        OSCL_IMPORT_REF virtual PVMFCommandId QueryInterface(PVMFSessionId aSession
                , const PVUuid& aUuid
                , PVInterface*& aInterfacePtr
                , const OsclAny* aContext = NULL);

        /**
         * Requests the node to return a port meeting certain criteria for format types and buffering
         * capabilities.  The node may return a reference to an already created unused port or it may dynamically
         * create one if it has the capability to do so.  Since there might be some port specific initializations
         * that might need to be done for ports created on demand, it will be most flexible to have this as an
         * asynchronous API.
         * A reference to the port interface is returned with the the command completion.  It is passed as an auto ptr
         * carrying opaque data that needs to be cast to PVMFPortInterface*
         * @exception PVMFErrNotSupported leaves if this is not supported.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId RequestPort(PVMFSessionId aSession
                , int32 aPortTag
                , const PvmfMimeString* aPortConfig = NULL
                                                      , const OsclAny* aContext = NULL);

        /**
         * Releases a port back to the owning node.
         * @exception PVMFErrArgument leaves if this node is not the owner.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId ReleasePort(PVMFSessionId aSession
                , PVMFPortInterface& aPort
                , const OsclAny* aContext = NULL);

        //Describe,
        OSCL_IMPORT_REF virtual PVMFCommandId Init(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);

        OSCL_IMPORT_REF virtual PVMFCommandId Prepare(PVMFSessionId aSession,
                const OsclAny* aContext = NULL);

        //Setup, Firewall pkts exchange, Play
        /**
         * Causes the node to start servicing all connected ports.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId Start(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);

        //Pause
        /**
         * Causes the node to pause servicing all connected ports without
         * discarding un-processed data.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId Pause(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);

        //Teardown
        OSCL_IMPORT_REF virtual PVMFCommandId Stop(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);

        /**
         * Resets the node.  The node should relinquish all resources that is has acquired as part of the
         * initialization process and should be ready to be deleted when this completes.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId Reset(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);

        /**
         * Causes the node to stop servicing all connected ports as
         * soon as current data is processed.
         **/
        OSCL_IMPORT_REF virtual PVMFCommandId Flush(PVMFSessionId aSession
                , const OsclAny* aContext = NULL);


        /**
         * Cancel all pending requests. The current request being processed, if any, will also be aborted.
         *
         * @param aContextData Optional opaque data that will be passed back to the user with the command response
         * @returns A unique command id for asynchronous completion
         */
        OSCL_IMPORT_REF virtual PVMFCommandId CancelAllCommands(PVMFSessionId aSession
                , const OsclAny* aContextData = NULL);

        /**
         * Cancels pending command with the specified ID.
         *
         * @param aCmdId Command Id of the command to be cancelled
         * @param aContextData Optional opaque data that will be passed back to the user with the command response
         * @returns A unique command id for asynchronous completion
         */
        OSCL_IMPORT_REF virtual PVMFCommandId CancelCommand(PVMFSessionId aSession
                , PVMFCommandId aCmdId
                , const OsclAny* aContextData = NULL);

        /**
         * Ports call this API to report activity to the node.
         *
         * @param aActivity Information regarding the activity.
         */
        OSCL_IMPORT_REF void HandlePortActivity(const PVMFPortActivity& aActivity);

        //************ end PVMFNodeInterface

        //************ begin PVRTSPEngineNodeExtensionInterface
        OSCL_IMPORT_REF virtual void addRef();
        OSCL_IMPORT_REF virtual void removeRef(void);
        OSCL_IMPORT_REF virtual bool queryInterface(const PVUuid& uuid, PVInterface*& iface);

        OSCL_IMPORT_REF virtual PVMFStatus SetStreamingType(PVRTSPStreamingType aType = PVRTSP_3GPP_UDP);

        OSCL_IMPORT_REF virtual PVMFStatus SetSessionURL(OSCL_wString& aURL);

        OSCL_IMPORT_REF virtual PVMFStatus SetRtspProxy(OSCL_String& aRtspProxyName, uint32 aRtspProxyPort);
        OSCL_IMPORT_REF virtual PVMFStatus GetRtspProxy(OSCL_String& aRtspProxyName, uint32& aRtspProxyPort);

        OSCL_IMPORT_REF virtual PVMFStatus GetSDP(OsclRefCounterMemFrag& aSDPBuf);
        OSCL_IMPORT_REF virtual PVMFStatus SetSDPInfo(OsclSharedPtr<SDPInfo>& aSDPinfo, Oscl_Vector<StreamInfo, PVRTSPEngineNodeAllocator> &aSelectedStream);
        OSCL_IMPORT_REF virtual PVMFStatus GetServerInfo(PVRTSPEngineNodeServerInfo& aServerInfo);
        OSCL_IMPORT_REF virtual PVMFStatus GetStreamInfo(Oscl_Vector<StreamInfo, PVRTSPEngineNodeAllocator> &aSelectedStream);

        OSCL_IMPORT_REF virtual PVMFStatus GetUserAgent(OSCL_wString& aUserAgent);

        OSCL_IMPORT_REF virtual PVMFStatus SetClientParameters(OSCL_wString& aUserAgent,
                OSCL_wString&  aUserNetwork,
                OSCL_wString&  aDeviceInfo);

        OSCL_IMPORT_REF virtual bool IsRdtTransport();
        OSCL_IMPORT_REF virtual void SetPortRdtStreamId(PVMFPortInterface* pPort,
                int iRdtStreamId);

        OSCL_IMPORT_REF virtual void SetRealChallengeCalculator(IRealChallengeGen* pChallengeCalc);
        OSCL_IMPORT_REF virtual void SetRdtParser(IPayloadParser* pRdtParser);

        OSCL_IMPORT_REF virtual PVMFStatus SetAuthenticationParameters(OSCL_wString& aUserID,
                OSCL_wString& aAuthentication,
                OSCL_wString& aExpiration,
                OSCL_wString& aApplicationSpecificString,
                OSCL_wString& aVerification,
                OSCL_wString& aSignature);

        OSCL_IMPORT_REF virtual PVMFStatus SetRequestPlayRange(const RtspRangeType& aRange);
        OSCL_IMPORT_REF virtual PVMFStatus GetActualPlayRange(RtspRangeType& aRange);

        OSCL_IMPORT_REF virtual PVMFStatus SetKeepAliveMethod_timeout(int32 aTimeout = 0);
        OSCL_IMPORT_REF virtual PVMFStatus SetKeepAliveMethod_use_SET_PARAMETER(bool aUseSetParameter = false);
        OSCL_IMPORT_REF virtual PVMFStatus SetKeepAliveMethod_keep_alive_in_play(bool aKeepAliveInPlay = false);

        OSCL_IMPORT_REF virtual PVMFStatus GetKeepAliveMethod(int32 &aTimeout, bool &aUseSetParameter, bool &aKeepAliveInPlay);


        OSCL_IMPORT_REF virtual PVMFStatus GetRTSPTimeOut(int32 &aTimeout);
        OSCL_IMPORT_REF virtual PVMFStatus SetRTSPTimeOut(int32 aTimeout);

        //************ end PVRTSPEngineNodeExtensionInterface

        //************ begin OsclTimerObserver
        OSCL_IMPORT_REF virtual void TimeoutOccurred(int32 timerID, int32 timeoutInfo);

        //************ begin OsclSocketObserver
        OSCL_IMPORT_REF virtual void HandleSocketEvent(int32 aId, TPVSocketFxn aFxn, TPVSocketEvent aEvent, int32 aError);
        //************ end OsclSocketObserver

        //************ begin OsclDNSObserver
        OSCL_IMPORT_REF virtual void HandleDNSEvent(int32 aId, TPVDNSFxn aFxn, TPVDNSEvent aEvent, int32 aError);
        //************ end OsclDNSObserver

        //************ begin OsclMemPoolFixedChunkAllocatorObserver
        void freechunkavailable(OsclAny*);
        //************ end OsclMemPoolFixedChunkAllocatorObserver

        void UpdateSessionCompletionStatus(bool aSessionCompleted)
        {
            iSessionInfo.iSessionCompleted = aSessionCompleted;
        }

        bool IsSessionCompleted() const
        {
            return iSessionInfo.iSessionCompleted;
        }

        typedef struct _SocketEvent
        {
            int32           iSockId;
            TPVSocketFxn    iSockFxn;
            TPVSocketEvent  iSockEvent;
            int32           iSockError;
        } SocketEvent;

        enum PVRTSPEngineState
        {
            //for async request
            PVRTSP_ENGINE_NODE_STATE_IDLE,
            PVRTSP_ENGINE_NODE_STATE_DNS_RESOLVING,

            PVRTSP_ENGINE_NODE_STATE_CONNECT,
            PVRTSP_ENGINE_NODE_STATE_CONNECTING,

            PVRTSP_ENGINE_NODE_STATE_HTTP_CLOAKING_SETUP,

            PVRTSP_ENGINE_NODE_STATE_SEND_OPTIONS,
            PVRTSP_ENGINE_NODE_STATE_SEND_DESCRIBE,
            PVRTSP_ENGINE_NODE_STATE_OPTIONS_WAITING,
            PVRTSP_ENGINE_NODE_STATE_DESCRIBE_WAITING,

            PVRTSP_ENGINE_NODE_STATE_DESCRIBE_DONE,
            PVRTSP_ENGINE_NODE_STATE_PROCESS_REST_SETUP,

            PVRTSP_ENGINE_NODE_STATE_SETUP_DONE,
            PVRTSP_ENGINE_NODE_STATE_WAIT_PLAY,

            PVRTSP_ENGINE_NODE_STATE_PLAY_DONE,
            PVRTSP_ENGINE_NODE_STATE_WAIT_PAUSE,
            PVRTSP_ENGINE_NODE_STATE_PAUSE_DONE,

            PVRTSP_ENGINE_NODE_STATE_WAIT_STOP,

            PVRTSP_ENGINE_NODE_STATE_WAIT_CALLBACK,

            PVRTSP_ENGINE_NODE_STATE_INVALID
        } iState;

    private:
        OsclSharedPtr<PVMFMediaDataImpl> AllocateMediaData(int32& errCode);
        Oscl_Vector<SocketEvent, PVRTSPEngineNodeAllocator> iSocketEventQueue;

        PVRTSPEngineNodeAllocator iAlloc;

        PVMFCommandId iCurrentCmdId;

        OsclSocketServ  *iSockServ;

//note: this class is for internal use only, but must be public to avoid ADS v1.2 compile error.
    public:
        //To keep track of current socket op
        class SocketState
        {
            public:
                SocketState()
                        : iPending(false)
                        , iCanceled(false)
                {}
                bool iPending;
                bool iCanceled;
                void Reset()
                {
                    iPending = iCanceled = false;
                }
        };

    private:

        //Container for a TCP socket that can connect, send, & recv.
        class SocketContainer
        {
            public:
                SocketContainer(): iSocket(NULL)
                {}
                OsclTCPSocket* iSocket;
                SocketState iConnectState;
                SocketState iSendState;
                SocketState iRecvState;
                SocketState iShutdownState;
                void Reset(OsclTCPSocket* aSock)
                {
                    iSocket = aSock;
                    iConnectState.Reset();
                    iSendState.Reset();
                    iRecvState.Reset();
                    iShutdownState.Reset();
                }
                bool IsBusy()
                {
                    return iSocket
                           && (iConnectState.iPending
                               || iSendState.iPending
                               || iRecvState.iPending
                               || iShutdownState.iPending);
                }
        };
        class DnsContainer
        {
            public:
                DnsContainer(): iDns(NULL)
                {}
                OsclDNS* iDns;
                SocketState iState;
                bool IsBusy()
                {
                    return (iDns
                            && iState.iPending);
                }
        };
        void SetSendPending(SocketContainer&);
        void SetRecvPending(SocketContainer&);

        SocketContainer iSendSocket, iRecvSocket;
        DnsContainer iDNS;

        //To keep track of socket reset sequence.
        enum TSocketCleanupState
        {
            ESocketCleanup_Idle
            , ESocketCleanup_CancelCurrentOp
            , ESocketCleanup_WaitOnCancel
            , ESocketCleanup_Shutdown
            , ESocketCleanup_WaitOnShutdown
            , ESocketCleanup_Delete
        };
        TSocketCleanupState iSocketCleanupState;

        //only for http cloaking, string to store the text to send until send completes
        OSCL_HeapString<PVRTSPEngineNodeAllocator> iRecvChannelMsg, iSendChannelMsg;

        RTSPParser *iRTSPParser;
        RTSPParser::ParserState iRTSPParserState;
        RTSPIncomingMessage iIncomingMsg;
        uint32 iOutgoingSeq;

        bool bNoRecvPending;//an Recv() is pending on RTSP socket
        bool bNoSendPending;//a Send() is pending on RTSP socket

        PVMFPortInterface* iTheBusyPort;
        //OsclMemoryFragment entityBody;            //Used to register with RTSP parser
        //OsclMemoryFragment embeddedDataMemory;    //Used to save embedded binary data

        SessionInfo iSessionInfo;

        PVLogger* iLogger;

        //uint8 iBufEmbedded[2048];
        //RTSPEntityBody iEmbeddedData;
        PVMFSharedMediaDataPtr  iEmbeddedDataPtr;
        // Reference counter for extension
        uint32 iExtensionRefCount;
        uint32 iNumRedirectTrials;

        //socket server will callback even if Cancel() is called
        //most likely this is the case for OsclDNS as well
        //But this is NOT the case for OsclTimer
        uint32  iNumHostCallback, iNumConnectCallback, iNumSendCallback, iNumRecvCallback;
        int BASE_REQUEST_ID;
        static const int REQ_SEND_SOCKET_ID;
        static const int REQ_RECV_SOCKET_ID;
        int REQ_TIMER_WATCHDOG_ID, REQ_TIMER_KEEPALIVE_ID;
        int REQ_DNS_LOOKUP_ID;


        const int DEFAULT_RTSP_PORT, DEFAULT_HTTP_PORT;

        //these three are in milliseconds
        const int TIMEOUT_CONNECT_AND_DNS_LOOKUP, TIMEOUT_SEND, TIMEOUT_RECV;
        const int TIMEOUT_SHUTDOWN;

        //these two are in seconds
        int TIMEOUT_WATCHDOG;
        const int TIMEOUT_WATCHDOG_TEARDOWN;
        int TIMEOUT_KEEPALIVE;
        const int RECOMMENDED_RTP_BLOCK_SIZE;

        int setupTrackIndex;
        bool bRepositioning;

        class PVRTSPErrorContext
        {
            public:
                SocketEvent     iErrSockEvent;
                PVRTSPEngineState   iErrState;
        };


        //temp string compose buffer for internal use RTSP_MAX_FULL_REQUEST_SIZE
        OsclMemoryFragment  iRTSPEngTmpBuf;
        OsclMemoryFragment  iEntityMemFrag;
        //OsclRefCounterMemFrag iEntityMemFrag;

        // Queue of commands for cancel
        PVRTSPEngineNodeCmdQ iCancelCmdQueue;
        // Queue of commands user requested
        PVRTSPEngineNodeCmdQ iPendingCmdQueue;

        //Queue for cmds which are running.
        //normally this node will not start processing one command
        //until the prior one is finished.  However, a hi priority
        //command such as Cancel must be able to interrupt a command
        //in progress.
        PVRTSPEngineNodeCmdQ iRunningCmdQueue;
        PVMFPortVector<PVMFRTSPPort, PVRTSPEngineNodeAllocator> iPortVector;
        /**
         * Queue holding port activity. Only incoming and outgoing msg activity are
         * put on the queue.  For each port, there should only be at most one activity
         * of each type on the queue.
         */
        Oscl_Vector<PVMFPortActivity, PVRTSPEngineNodeAllocator> iPortActivityQueue;
        PVMFNodeCapability iCapability;

        //OsclPriorityQueue<PVRTSPEngineCommand,PVRTSPEngineNodeAllocator,Oscl_Vector<PVRTSPEngineCommand,PVRTSPEngineNodeAllocator>,PVRTSPEngineCommandCompareLess> iPendingCmdQueue;
//  Oscl_Vector<PVRTSPEngineAsyncEvent, PVRTSPEngineNodeAllocator> iPendingEvents;

//  OsclPriorityQueue<RTSPIncomingMessage,PVRTSPEngineNodeAllocator,Oscl_Vector<RTSPIncomingMessage,PVRTSPEngineNodeAllocator>,PVRTSPGenericMessageCompareLess> iIncomingMsgQueue;
        OsclPriorityQueue<RTSPOutgoingMessage*, PVRTSPEngineNodeAllocator, Oscl_Vector<RTSPOutgoingMessage*, PVRTSPEngineNodeAllocator>, PVRTSPGenericMessageCompareLess> iOutgoingMsgQueue;
        RTSPOutgoingMessage* iSrvResponse;
        bool    bSrvRespPending;

        OsclTimer<PVRTSPEngineNodeAllocator>    *iWatchdogTimer;

        int32 iCurrentErrorCode;
        PVUuid iEventUUID;

        bool    bKeepAliveInPlay;
        RTSPMethod  iKeepAliveMethod;

        bool    bAddXStrHeader;

        OsclMemPoolResizableAllocator *iMediaDataResizableAlloc;
        PVMFSimpleMediaBufferCombinedAlloc *iMediaDataImplAlloc;

        /* Round trip delay calculation */
        PVMFTimebase_Tickcount iRoundTripClockTimeBase;

        int32   iErrorRecoveryAttempt;

        //uint8 iGetPostCorrelation;
        GetPostCorrelationObject *iGetPostCorrelationObject;
    private:
        PVRTSPEngineNode();
        PVRTSPEngineNode&  operator = (const PVRTSPEngineNode&);
        PVRTSPEngineNode(const PVRTSPEngineNode&);

        //OsclActiveObject
        virtual void Run();
        virtual OsclLeaveCode RunError(OsclLeaveCode aError);

        PVMFStatus sendSocketOutgoingMsg(SocketContainer &aSock, RTSPOutgoingMessage &aMsg);
        PVMFStatus sendSocketOutgoingMsg(SocketContainer &aSock, const uint8* aSendBuf, uint32 aSendLen);

        void ChangeExternalState(TPVMFNodeInterfaceState aNewState);

        // Handle command and data events
        PVMFCommandId AddCmdToQueue(PVRTSPEngineCommand& aCmd);

        bool ProcessCommand(PVRTSPEngineCommand& aCmd);
        bool rtspParserLoop(void);

        PVMFStatus DispatchCommand(PVRTSPEngineCommand& aCmd);
        void MoveCmdToCancelQueue(PVRTSPEngineCommand& aCmd);

        PVMFStatus DoInitNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoPrepareNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoStartNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoPauseNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoStopNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoResetNode(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoQueryUuid(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoQueryInterface(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoCancelCommand(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoCancelAllCommands(PVRTSPEngineCommand &aCmd);
        PVMFStatus DoFlush(PVRTSPEngineCommand &aCmd);

        PVMFStatus DoErrorRecovery(PVRTSPEngineCommand &aCmd);

        PVMFStatus DoRequestPort(PVRTSPEngineCommand &aCmd, PVMFRTSPPort* &aPort);
        PVMFStatus DoAddPort(int32 id, bool isMedia, int32 tag, PVMFRTSPPort* &aPort);
        PVMFStatus DoReleasePort(PVRTSPEngineCommand &aCmd);

        bool FlushPending();
        bool ProcessPortActivity();
        void QueuePortActivity(const PVMFPortActivity &aActivity);
        PVMFStatus ProcessOutgoingMsg(PVMFPortInterface* aPort);

        PVMFStatus SendRtspDescribe(PVRTSPEngineCommand &aCmd);
        PVMFStatus SendRtspSetup(PVRTSPEngineCommand &aCmd);
        PVMFStatus SendRtspPlay(PVRTSPEngineCommand &aCmd);
        PVMFStatus SendRtspPause(PVRTSPEngineCommand &aCmd);
        PVMFStatus SendRtspTeardown(PVRTSPEngineCommand &aCmd);

        void CommandComplete(PVRTSPEngineNodeCmdQ&,
                             PVRTSPEngineCommand&,
                             PVMFStatus, OsclAny* aData = NULL,
                             PVUuid* aEventUUID = NULL,
                             int32* aEventCode = NULL);

        bool parseURL(const OSCL_wString& aURL);
        bool parseURL(const char* aURL);


        void ChangeInternalState(PVRTSPEngineState aNewTask);
        PVMFStatus composeOptionsRequest(RTSPOutgoingMessage&);
        PVMFStatus composeDescribeRequest(RTSPOutgoingMessage&);
        PVMFStatus composeSetupRequest(RTSPOutgoingMessage &iMsg, StreamInfo &aSelected);
        PVMFStatus composePlayRequest(RTSPOutgoingMessage &iMsg);
        PVMFStatus composeStopRequest(RTSPOutgoingMessage &iMsg);
        PVMFStatus composePauseRequest(RTSPOutgoingMessage &iMsg);
        PVMFStatus composeKeepAliveRequest(RTSPOutgoingMessage &aMsg);

        PVMFStatus composeGetRequest(RTSPOutgoingMessage &iMsg);
        PVMFStatus composePostRequest(RTSPOutgoingMessage &iMsg);

        PVMFStatus processIncomingMessage(RTSPIncomingMessage &iIncomingMsg);
        PVMFStatus processServerRequest(RTSPIncomingMessage &aMsg);
        PVMFStatus processEntityBody(RTSPIncomingMessage &aMsg, OsclMemoryFragment &aEntityMemFrag);

        PVMFStatus processCommonResponse(RTSPIncomingMessage &aMsg);

        //should merge togather and move to jitter buffer
        PVMFStatus composeSessionURL(RTSPOutgoingMessage &aMsg);
        PVMFStatus composeMediaURL(int aTrackID, StrPtrLen &aMediaURI);

        //PVMFStatus processSDP(OsclMemoryFragment &aSDPBuf, SDPInfo &aSDPinfo);

        void ReportErrorEvent(PVMFEventType aEventType,
                              OsclAny* aEventData = NULL,
                              PVUuid* aEventUUID = NULL,
                              int32* aEventCode = NULL);
        void ReportInfoEvent(PVMFEventType aEventType,
                             OsclAny* aEventData = NULL,
                             PVUuid* aEventUUID = NULL,
                             int32* aEventCode = NULL);

        void MapRTSPCodeToEventCode(RTSPStatusCode aStatusCode,
                                    int32& aEventCode);
        //allocate aReqBufSize memory for iEmbeddedData
        bool PrepareEmbeddedDataMemory(uint32 aReqBufSize, OsclMemoryFragment &);
        bool DispatchEmbeddedData(uint32 aChannelID);
        // private members added for real support
        bool ibIsRealRDT;

        // realchallenge1 string returned by OPTIONS request
        OSCL_HeapString<OsclMemAllocator> iRealChallenge1;

        // realchallenge2 string to be sent in SETUP request
        OSCL_HeapString<OsclMemAllocator> iRealChallenge2;

        IRealChallengeGen* ipRealChallengeGen;
        IPayloadParser* ipRdtParser;

        // allocator for outgoing media frag groups
        PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>* ipFragGroupAllocator;
        OsclMemPoolFixedChunkAllocator* ipFragGroupMemPool;

        /////


        bool DispatchEmbeddedRdtData();
        bool ibBlockedOnFragGroups;
        //bool simpleHttpParser(const uint8 *aBuf, int32 &aLen, bool &aIsStatus200);

        PVMFStatus resetSocket(bool aImmediate = false);
        void clearOutgoingMsgQueue(void);
        void partialResetSessionInfo(void);

        bool clearEventQueue(void);

        void ResetSessionInfo(void);
        PVRTSPEngineNodeExtensionInterface* iExtensionInterface;
};

#endif //PVRTSP_CLIENT_ENGINE_NODE_H