/*
* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Name          : TransactionInfo.h
* Part of       : TransactionUser
* Version       : SIP/6.0
*
*/




/**
 @internalComponent
*/

#ifndef TRANSACTIONINFO_H
#define TRANSACTIONINFO_H

// INCLUDES
#include "TransactionBase.h"
#include <e32base.h>

// FORWARD DECLARATIONS
class RStringF;
class CURIContainer;
class CSIPToHeader;
class CSIPFromHeader;
class CSIPViaHeader;
class CSIPMessage;
class CSIPCallIDHeader;
class CSIPRecordRouteHeader;
class CSIPContactHeader;

class CUserAgent;
class MTransactionHeaders;

// CLASS DECLARATION

/**
 * This class contains information identifying a transaction (=certain headers
 * from the SIP request that initiated the transaction), together with the
 * addresses of the CUserAgent and CTransaction objects created for handling
 * that transaction.
 */
class CTransactionInfo : public CBase
	{
public: // Constructor and destructor

	/**
	 * Creates a new object.	 
	 * @param aType Identifies the transaction type
     * @param aIapId IAP-id
	 * @return value New CTransactionInfo object, ownership is transferred.
	 */	
	static CTransactionInfo* NewL(CTransactionBase::TTransactionType aType,
                                  TUint32 aIapId);

	/**
	 * Destructor. Deletes the owned resources, except does NOT delete UA or
	 * transaction.	 
	 * @see FreeContents
	 */
	~CTransactionInfo();

public: // New functions

	/**
	 * Deletes the stored UA and/or transaction.	 
	 * @see ~CTransactionStore
	 */
	void FreeContents();

	/**
	 * Checks whether all the required headers for transaction matching and
	 * constructing a SIP response are present.	 
	 * @return ETrue if required headers exist, EFalse otherwise
	 */
	TBool RequiredHeadersPresent() const;

	/**
	 * Compares the stored iTransactionType to aType.	 
	 * @param aType TransactionType which is compared
	 * @return ETrue if types are same, EFalse otherwise
	 */
	TBool CompareType(CTransactionBase::TTransactionType aType) const;

	/**
	 * Compares the aMethod to the iMethod for determining if the SIP message
	 * with the aMethod belongs to the same transaction.
	 *
	 * If the SIP message that created the transaction was a request, iMethod
	 * is the request method, otherwise it is the method from CSeq.	 
	 * @param aMethod If the SIP message is request, this is the request
	 *	method. Otherwise, this is the method from CSeq.
	 * @return value ETrue if the methods can belong to same transaction
	 */	
	TBool CompareMethod(RStringF aMethod) const;

	/**
	 * Compares the Request-URI and request method to the stored values.	 
	 * @see CompareMethod
	 * @param aReqURI Request-URI
	 * @param aMethod Request method
	 * @param aSearchCanceledUas ETrue: search is done to find an UAS to be
	 *	canceled. EFalse: search is done to find a transaction to receive an
	 *	incoming SIP message.
	 * @return value ETrue: If both aReqURI and aMethod match the stored values
	 *	EFalse: otherwise
	 */
	TBool CompareRequestLine(const CURIContainer& aReqUri,
							 RStringF aMethod,
							 TBool aSearchCanceledUas) const;

	/**
	 * Compares the SIP headers of aReq to the stored headers, and determines
	 * if the transactions match.
	 * @param aReq SIP request
	 * @return ETrue if match, EFalse otherwise
	 */
	TBool CompareHeaders(CSIPRequest& aReq) const;

	/**
	 * Obtains a MTransactionReceiver that should handle events received from
	 * the network. Returns transaction, if it exists, or UA if transaction does
	 * not exist.
	 * @return MTransactionReceiver Pointer to the receiver interface.
	 *								Ownership isn't transferred.
	 */
	MTransactionReceiver* Receiver();

    /**
	 * Returns the UA.
	 * @return Pointer to UA instance. Can be NULL. Ownership isn't transferred.
	 */
	CUserAgent* UserAgent();

	/**
	 * Sets the stored UA.
	 * @post iUserAgent == aUserAgent
	 * @param aUserAgent UA instance, can be NULL. Ownership is transferred.
	 */
	void SetUserAgent(CUserAgent* aUserAgent);

	/**
	 * Sets the stored transaction.
	 * @post iTransaction == aTransaction
	 * @return Pointer to transaction. Can be NULL. Ownership isn't transferred.
	 */
	void SetTransaction(CTransactionBase* aTransaction);

    /**
	 * Obtain the TransactionId	 
	 * @return TransactionId
	 */
	TTransactionId TransactionId() const;

    /**
	 * Set new value for TransactionId	 
	 * @param aTransactionId TransactionId
	 */
	void SetTransactionId(TTransactionId aTransactionId);

    /**
	 * Obtain the IAP-id.	 
	 * @return IAP-id
	 */
    TUint32 IapId() const;

	/**
	 * Returns the topmost of the stored Via headers. Caller must not modify
	 * the Via header.	 
	 * @pre iViaHeaders.Count() > 0	 
	 * @return Topmost Via header
	 */
	CSIPViaHeader& TopVia() const;

	/**
	 * Copies and stores the transaction related headers from the SIP message.
	 * The possibly existing old headers are removed from CTransactionInfo,
	 * regardless whether the same header is present in the aMsg, so that
	 * CTransactionInfo won't contain headers from more than one different SIP
	 * message.	 
	 * @param aMsg SIP message from where the headers are copied, can be NULL.
	 *  Ownership isn't transferred. If aMsg is NULL, nothing is done.
	 */
	void UpdateMessageHeadersL(CSIPMessage* aMsg);

	/**
	 * Updates the To tag.
	 * @pre iTo != NULL, iTo->HasTag() == EFalse	 
	 * @param aTag To tag	 
	 */	
	void UpdateToTagL(RStringF aTag);

	void StoreRecordRouteHeadersL(CSIPRequest& aReq);
	void FreeRecordRouteHeaders();

	void StoreContactHeadersL(CSIPRequest& aReq);
	void FreeContactHeaders();

    /**
	 * Checks a request with the aFrom, aCallID, aCSeqNbr and aCSeqMethod is a
     * merged request by comparing these values to CTransactionInfo's similar
     * values.	 
	 * @param aUserAgent UA initiating the search
     * @param aFrom From header of a received request
     * @param aCallID Call-ID header of a received request
     * @param aCSeqNbr CSeq sequence number of a received request
     * @param aCSeqMethod CSeq method of a received request
	 * @return ETrue if the request is a merged request, EFalse otherwise.
	 */
	TBool IsMergedRequest(const CUserAgent& aUserAgent,
						  CSIPFromHeader& aFrom,
						  CSIPCallIDHeader& aCallID,
						  TUint aCSeqNbr,
						  RStringF aCSeqMethod) const;

    MTransactionHeaders* TransactionHeadersL();

	/**
	 * Copies To, From, Call-ID and CSeq headers from CTransactionInfo into the
	 * SIP message. If some headers already exist in the aMsg, they are not
	 * replaced.	 
	 * @param aMsg SIP message to which the headers are copied	 
	 */
	void CopyToFromCallIDCSeqToMsgL(CSIPMessage& aMsg) const;

	/**
	 * Copies the stored Via headers into the SIP message.	 
	 * @param aMsg SIP message into which where the Vias are copied	 
	 */
	void CopyViaHeadersToMsgL(CSIPMessage& aMsg) const;

	void CopyRequestUriToRequestL(CSIPRequest& aReq) const;

	/**
	 * Creates a SIP request from the stored headers.	 
	 * @return SIP request, or NULL if there is not enough information to
	 *	create it. Ownership is transferred.
	 */
	CSIPRequest* BuildRequestFromStoredInfoL() const;

    /**
	 * Returns the request method.	 
	 * @return Request method
	 */
	RStringF RequestMethod() const;

	TSglQueLink	iLink;

private: // New functions, for internal use

	/**
	 * Constructor	 
	 * @param aType Identifies the transaction type
     * @param aIapId IAP-id	 
	 */	
	CTransactionInfo(CTransactionBase::TTransactionType aType, TUint32 aIapId);

	/**
	 * Clears the SIP message related members
	 */
	void ClearMessageHeaders();

	/**
	 * Checks if the method has been stored.	 
	 * @param ETrue method has been stored, EFalse otherwise
	 */
	TBool MethodExists() const;	

	/**
	 * Copies and stores the Via headers from aMsg, maintaining their order.	 
	 * @param aMsg SIP message
	 */
	void CopyViaHeadersFromMsgL(CSIPMessage& aMsg);
	
private: // Data

	TTransactionId			iTransactionId;
	CTransactionBase::TTransactionType iTransactionType;

    // IAP-id
    TUint32                 iIapId;

	// UA, owned. NULL if iTransaction has been detached from UA.    
	CUserAgent*				iUserAgent;

	// Transaction, can be NULL. Not owned.
	CTransactionBase*		iTransaction;

	// Request-URI, owned.
	CURIContainer*			iRequestURI;
	
	// To header, can be NULL. Owned.
	CSIPToHeader*			iTo;
	// From header, can be NULL. Owned.
	CSIPFromHeader*			iFrom;
	// Call-ID header, can be NULL. Owned.
	CSIPCallIDHeader*		iCallID;

	// Method from Request line (=same as CSeq method), can be NULL
	RStringF				iMethod;

	// CSeq sequence number
	TUint                   iCSeq;

	// All Via headers of the SIP request are copied here.	
	RPointerArray<CSIPViaHeader> iViaHeaders;

	// Record-route headers, owned.
	// Stored only for incoming requests outside of a dialog.
	RPointerArray<CSIPRecordRouteHeader> iRecordRoute;

	// Contact headers, owned.
	// Stored only for incoming requests outside of a dialog.
	RPointerArray<CSIPContactHeader> iContact;	


#ifdef CPPUNIT_TEST	
	friend class CTransactionStore_Test;
	friend class CNormalUAC_ResolveAddress_Test;
	friend class CNormalUAC_WaitResponse_Test;
	friend class CTransactionUser_Test;
	friend class CUserAgentServer_Test;
	friend class CTransactionInfo_Test;
#endif
	};

#endif // end of TRANSACTIONINFO_H

// End of File