// Copyright (c) 2005-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          : DialogsStore.cpp
// Part of       : SIPDialogs
// Version       : SIP/4.0 
//




#include "DialogsStore.h"
#include "TransactionItemStore.h"
#include "DeleteMgr.h"
#include "sipmessage.h"
#include "SipStackServerDefs.h"
#include "sipfromheader.h"
#include "siptoheader.h"
#include "sipcallidheader.h"
#include "sipcseqheader.h"
#include "sipaddress.h"
#include "sipuri.h"
#include "sipresponse.h"
#include "siprequest.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "TSIPTransportParams.h"


// -----------------------------------------------------------------------------
// CDialogsStore::NewL
// -----------------------------------------------------------------------------
//
CDialogsStore* CDialogsStore::NewL()
	{
	CDialogsStore* self = new (ELeave) CDialogsStore;
	return self;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::CDialogsStore
// -----------------------------------------------------------------------------
//
CDialogsStore::CDialogsStore()
 : iList(CSipDialogItem::Offset())
	{
	iTagParamName = SIPStrings::StringF(SipStrConsts::ETag);
	}

// -----------------------------------------------------------------------------
// CDialogsStore::~CDialogsStore
// -----------------------------------------------------------------------------
//
CDialogsStore::~CDialogsStore()
	{
	CSipDialogItem* listItem = iList.First();

	while (iList.IsFirst(listItem) && !iList.IsEmpty())
		{
		iList.Remove(*listItem);
        delete listItem;
		listItem = iList.First();
		}

	}

// -----------------------------------------------------------------------------
// CDialogsStore::AddDialogItem
// -----------------------------------------------------------------------------
//
void CDialogsStore::AddDialogItem(CSipDialogItem* aDialogItem)
	{
	iList.AddLast(*aDialogItem);
	}

// -----------------------------------------------------------------------------
// CDialogsStore::DialogItemsCount
// -----------------------------------------------------------------------------
//
TInt CDialogsStore::DialogItemsCount()
	{
	TSglQueIter<CSipDialogItem> listIter(iList);
	TInt counter = 0;
	for (CSipDialogItem* listItem = listIter++; listItem; listItem = listIter++)
	    {
	    counter++;
	    }
	return counter;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::Remove
// -----------------------------------------------------------------------------
//
TInt CDialogsStore::Remove (CSipDialogItem* aDialogItem)
	{
	TInt err = aDialogItem->DeleteMgr().AddDeleteRequest(aDialogItem);
	if (!err)
        {
		iList.Remove(*aDialogItem);
        }
	return err;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::RemoveAllWith
// -----------------------------------------------------------------------------
//
TInt CDialogsStore::RemoveAllWith (const MDialogOwner* aDialogOwner)
    {
	TInt err = KErrNotFound;
	TSglQueIter<CSipDialogItem> listIter(iList);
	for (CSipDialogItem* listItem = listIter++; listItem; listItem = listIter++)
		{
		if (listItem->DialogOwner() == aDialogOwner)  
            {
            iList.Remove(*listItem);
            delete listItem;
			err = KErrNone;
			}
		}
	return err;
    }

// -----------------------------------------------------------------------------
// CDialogsStore::RemoveAllEarlyDialogsWith
// -----------------------------------------------------------------------------
//
TInt CDialogsStore::RemoveAllEarlyDialogsWith (TTransactionId aTransactionId)
	{
	TInt err = KErrNotFound;
	TSglQueIter<CSipDialogItem> listIter(iList);
	for (CSipDialogItem* item = listIter++; item; item = listIter++)
		{
		if (item->HasTransactionItem(aTransactionId) && item->IsEarly())
			{
			err = Remove(item);
			}
		}
	return err;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::DeleteItemsWithThisIapId
// -----------------------------------------------------------------------------
//
void CDialogsStore::DeleteItemsWithThisIapId(TUint32 aIapId)
	{
	TSglQueIter<CSipDialogItem> listIter(iList);
	for (CSipDialogItem* listItem = listIter++; listItem; listItem = listIter++)
		{
		if (listItem->IapId() == aIapId)
			{
			iList.Remove(*listItem);
			delete listItem;
			}
		}
	}

// -----------------------------------------------------------------------------
// CDialogsStore::FindDialogItem
// -----------------------------------------------------------------------------
//
CSipDialogItem* CDialogsStore::FindDialogItem(const TDialogId& aDialogId)
	{
	TSglQueIter<CSipDialogItem> iter(iList);
	for (CSipDialogItem* item = iter++; item; item = iter++)
		{
		if (item->DialogId() == aDialogId)
		    {
		    return item;
		    }
		}
	return NULL;
	}


// -----------------------------------------------------------------------------
// CDialogsStore::FindDialogItem
// -----------------------------------------------------------------------------
//
CSipDialogItem* CDialogsStore::FindDialogItem(const TDialogId& aDialogId,
                                              const MDialogOwner* aDialogOwner)
	{
	TSglQueIter<CSipDialogItem> iter(iList);
	for (CSipDialogItem* item = iter++; item; item = iter++)
		{
		if (item->DialogId() == aDialogId &&
		    item->DialogOwner() == aDialogOwner)
		    {
		    return item;
		    }
		}
	return NULL;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::FindDialogItemByTransaction
// -----------------------------------------------------------------------------
//
CSipDialogItem* CDialogsStore::FindDialogItemByTransaction(
    const TTransactionId& aTransactionId)
    {
	TSglQueIter<CSipDialogItem> iter(iList);
	for (CSipDialogItem* item = iter++; item; item = iter++)
		{
		if (item->HasTransactionItem(aTransactionId))
		    {
		    return item;
		    }
		}
	return NULL;
    }

// -----------------------------------------------------------------------------
// CDialogsStore::FindDialogItemForPass
// -----------------------------------------------------------------------------
//
CSipDialogItem* 
CDialogsStore::FindDialogItemForPass (TTransactionId aTransactionId, 
									  CSIPResponse* aResponse)
	{
	CSIPToHeader* to = aResponse->To();
	if (to)
		{
		TSglQueIter<CSipDialogItem> listIter(iList);
		for (CSipDialogItem* item = listIter++; item; item = listIter++)
			{
			if (item->RemoteTagSet() &&
				item->RemoteTag() == to->ParamValue(iTagParamName) &&
                item->HasTransactionItem(aTransactionId))
                {
                return item;
                }
			}
		}
	return 0;	
	}

// -----------------------------------------------------------------------------
// CDialogsStore::DialogItemForRequest
// -----------------------------------------------------------------------------
//
CSipDialogItem* CDialogsStore::DialogItemForRequest(CSIPRequest* aRequest)
	{
	if (!aRequest)
        {
		return NULL;
        }

	TSglQueIter<CSipDialogItem> listIter(iList);
	for (CSipDialogItem* item = listIter++; item; item = listIter++)
		{
		if (item->Match(*aRequest))
		    {
		    return item;
		    }
		}
	return NULL;
	}

// -----------------------------------------------------------------------------
// CDialogsStore::FindDialogItemByCallId
// -----------------------------------------------------------------------------
//
CSipDialogItem* CDialogsStore::FindDialogItemByCallId(CSIPMessage* aMessage)
	{
	if (aMessage)
        {
	    TSglQueIter<CSipDialogItem> listIter(iList);
	    CSIPCallIDHeader* callId = aMessage->CallID();
	
    	for (CSipDialogItem* item = listIter++; item; item = listIter++)
	    	{
	    	if (*callId == *item->CallId())
                {
                return item;
                }
	    	}
        }
    return 0;
    }

// -----------------------------------------------------------------------------
// CDialogsStore::NewDialogId
// -----------------------------------------------------------------------------
//
TDialogId CDialogsStore::NewDialogId()
	{
	if (iDialogIdCounter < KMaxDialogId)
		{
		iDialogIdCounter++;
		}
	else
		{
		iDialogIdCounter = KMinDialogId;
		}	
	return iDialogIdCounter;
	}


// -----------------------------------------------------------------------------
// CDialogsStore::TransactionEnded
// -----------------------------------------------------------------------------
//
void CDialogsStore::TransactionEnded (TTransactionId aTransactionId,
                                      TInt aReason)
	{
	TSglQueIter<CSipDialogItem> iter(iList);
	for (CSipDialogItem* dialog = iter; dialog; dialog = iter++)
		{
		if (dialog->TransactionItems().HasItem(aTransactionId))
			{
			dialog->EndTransaction(aTransactionId,aReason);
			}
		}
	}