//--------------------------------------------------------------------------------------
//  Copyright (c) 2002 Avaya Global SME Solutions 
//--------------------------------------------------------------------------------------
//  Project name: TAPI 3 Test Harness
//  Module file : Tapi3Dlg.cpp
//  Compiler    : Visual C++ 6.0
//--------------------------------------------------------------------------------------
//  Description : In this module behaviour of dialog is defined. This module handles button  
//                clicks, enabling/disabling buttons, receiving TAPI3 events, printing 
//                event messages, handles double click in message list box in terms of 
//                expanding TAPI 3 event information or suming up that info. In this module Call 
//                object pointers are extracted from received TAPI3 events, ...
//--------------------------------------------------------------------------------------

#include "stdafx.h"
#include "Tapi3app.h"
#include "Tapi3Dlg.h"
#include "TapiEvent.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include <afxwin.h>

const DWORD MAXTERMINALS = 5;

// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

	enum { IDD = IDD_ABOUTBOX };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:

    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()

// CTapi3Dlg dialog
CTapi3Dlg::CTapi3Dlg(CWnd* pParent /*=NULL*/)
	: CDialog(CTapi3Dlg::IDD, pParent)
{
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	m_bTAPIInit = false;
	m_pTEngine = NULL;
    m_pCall = NULL;
    m_pCallersBasicCall = NULL;
    m_pCallInfo = NULL;
    m_pCallOnHold = NULL;
    m_pCalledOnHold = NULL;
    m_pTransferConsultCall = NULL;

    m_lastCalled.Empty();
    m_lastOnHold.Empty();
    m_pLastParked.Empty();
}

void CTapi3Dlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CTapi3Dlg)
	DDX_Control(pDX, IDC_EXTN_CALL, m_ExtnCall);
	DDX_Control(pDX, IDC_EXTN_LIST, m_ExtnList);
	DDX_Control(pDX, IDC_MSGBOX, m_MsgBox);
	DDX_Control(pDX, IDC_MSG_INIT, m_MsgBoxInit);

	//}}AFX_DATA_MAP
}

void CTapi3Dlg::SetItemDataPtr(int index, void* p)
{
	m_MsgBox.SetItemDataPtr(index, p);
}

int CTapi3Dlg::PrintMsg(int index, int level, char* Msg)
{
	// Debug function
	CString indent;
	for (int l = 0;  l < level; l++)
	{
		indent += _T("  -->");
	}
	indent += CString(Msg);
	int i = m_MsgBox.InsertString(index, indent);
	m_MsgBox.SetTopIndex(m_MsgBox.GetCount()-1);
	return i;
}

int CTapi3Dlg::PrintMsgInit(int index, int level, char* Msg)
{
	// Debug function
	CString indent;
	for (int l = 0;  l < level; l++)
	{
		indent += _T("  -->");
	}
	indent += CString(Msg);
	int i = m_MsgBoxInit.InsertString(index, indent);
	m_MsgBox.SetTopIndex(m_MsgBoxInit.GetCount()-1);
	return i;
}

void CTapi3Dlg::PopulateExtnCombo()
{
	CTAPIAddr* pAddr;
	for(int i=0; i < CTAPIAddr::GetAddrCount(); i++)
	{
		pAddr = CTAPIAddr::GetAddrAt(i);
		if (pAddr)
		{
			// Only interested in line supporting audio
			if (pAddr->GetSupportedMedia() | TAPIMEDIATYPE_AUDIO > 0)
			{                
				m_ExtnList.AddString(pAddr->GetDialableAddr());                
				m_ExtnCall.AddString(pAddr->GetDialableAddr());                
			}
		}
	}
	m_ExtnList.SetCurSel(0);
    m_ExtnCall.SetCurSel(0);

    OnSelchangeExtnCall(); 
}

void CTapi3Dlg::ClearExtCombo()
{
    m_ExtnList.ResetContent();
    m_ExtnCall.ResetContent();
}

void CTapi3Dlg::HandleCallStateEvent(ITCallStateEvent* pCallStateEvent)
{
    ITCallInfo* pCallInfo;
    ITBasicCallControl* pCall;
    HRESULT hr;

    CALL_STATE cs;

    pCallStateEvent->get_State( &cs ); 

    
    // get a call
    pCallStateEvent->get_Call( &pCallInfo );

    hr = pCallInfo->QueryInterface( IID_ITBasicCallControl, (void**)&pCall);

	if (hr != S_OK)
	{
		PRINT_INIT(-1, 0, "Failed to obtain IID_ITBasicCallControl Interface, hr=%x", hr);
	}

    pCallInfo->Release();
    // 

    switch(cs)        
    {        
        case CS_OFFERING:        
            // enable Aswering the call
            GetDlgItem(ID_CALLCONTROL_ANSWERCALL)->EnableWindow(true);
            GetDlgItem(ID_CALLCONTROL_DROPCALL)->EnableWindow(true);
            SaveAddressOfCalled(pCallStateEvent);            

            break;        
        case CS_DISCONNECTED:
        {
            DISCONNECTION_TYPE discType = GetDisconnectionType(pCallStateEvent);
                        
            //if ( discType != DT_CONSULTATION)
            ReleaseTheCall(pCall);

            if (discType == DT_CONFERENCE)
            {
                GetDlgItem(IDM_ADDTOCONF)->EnableWindow(false);
                GetDlgItem(IDM_REMOVEFROMCONF)->EnableWindow(false);
                GetDlgItem(ID_CALLCONTROL_DROPCALL)->EnableWindow(false); 
            }

            break;     
        }
        case CS_CONNECTED:              

            // When you do swap hold twice and hang up with the extension that was 
            // connected, call which was on hold will be automatically re-connected
            // (m_pCallOnHold)
            if ( m_pCall == NULL && pCall == m_pCallOnHold && m_pCallOnHold != NULL)
            {
                m_pCall = m_pCalledOnHold;
				TRACE("Call (%X) ++\n",(int)m_pCall);
                m_pCall->AddRef();

                m_pCallersBasicCall = pCall;
                
                // no more anything on hold
                m_pCallOnHold->Release();
                m_pCallOnHold = NULL;
                m_pCalledOnHold->Release();
                m_pCalledOnHold = NULL;

                m_lastCalled = m_lastOnHold;
            }

            if ( m_pCall == NULL && m_pCallersBasicCall != NULL && pCall != m_pCallersBasicCall)
            {
                m_pCall = pCall;
				TRACE("Call (%X) ++\n",(int)m_pCall);
                m_pCall->AddRef();
            }

            if ( m_pCallersBasicCall == NULL && m_pCall != NULL && pCall != m_pCall )
            {
                m_pCallersBasicCall = pCall;
				TRACE("Call (%X) ++\n",(int)m_pCallersBasicCall);
                m_pCallersBasicCall->AddRef();
            }

            GetDlgItem(ID_CALLCONTROL_ANSWERCALL)->EnableWindow(false); 

            if (m_pCall != NULL || m_pCallersBasicCall != NULL) 
            {
                GetDlgItem(ID_CALLCONTROL_HOLDCALL)->EnableWindow(true);
                GetDlgItem(IDM_PARK_CALL)->EnableWindow(true);                
                GetDlgItem(ID_CALLCONTROL_UNHOLDCALL)->EnableWindow(false);                
                GetDlgItem(IDM_BLIND_TRANSFER)->EnableWindow(true);
                GetDlgItem(ID_CALLCONTROL_DROPCALL)->EnableWindow(true);

                if(!GetDlgItem(IDM_TRANSFER_FINISH)->IsWindowEnabled())
                    GetDlgItem(IDM_CALLTRANSFER)->EnableWindow(true);                            
            }

            if (m_pCall != NULL && m_pCallersBasicCall != NULL && m_pCallOnHold != NULL)
                GetDlgItem(IDM_SWAP_HOLD)->EnableWindow(true);    

            break;        
        case CS_HOLD:
            GetDlgItem(ID_CALLCONTROL_HOLDCALL)->EnableWindow(false);
            GetDlgItem(ID_CALLCONTROL_UNHOLDCALL)->EnableWindow(true);
            break;
        case CS_INPROGRESS:
            GetCallersBasicCall(pCallStateEvent);
            break;
        default:        
            break;        
    }  
    
    pCall->Release();
}

void CTapi3Dlg::SaveAddressOfCalled(ITCallStateEvent* pCallStateEvent)
{
    HRESULT hr;
    ITCallInfo* pCallInfo;

    hr = pCallStateEvent->get_Call(&pCallInfo);
    if (hr == S_OK)
    {
        CTAPIConn::GetDialableAddress(pCallInfo, m_lastCalled);

        pCallInfo->Release();
    }
}

DISCONNECTION_TYPE CTapi3Dlg::GetDisconnectionType(ITCallStateEvent* pCallStateEvent)
{
    HRESULT hr;
    ITCallInfo* pCallInfo;
    CString m_lastDisconnected;
    DISCONNECTION_TYPE rType = DT_NORMAL;

    hr = pCallStateEvent->get_Call(&pCallInfo);
    if (hr == S_OK)
    {
        CTAPIConn::GetDialableAddress(pCallInfo, m_lastDisconnected);

        if (m_pTEngine)
        {
            rType = m_pTEngine->Disconnected( m_lastDisconnected );

            if (rType == DT_TRANSFERING )
            {
                m_pTEngine->FinishTransfer(false);                            
                GetDlgItem(IDM_TRANSFER_FINISH)->EnableWindow(false);     
                GetDlgItem(IDM_CALLCONFERENCE)->EnableWindow(false);      
                GetDlgItem(IDM_ADDTOCONF)->EnableWindow(false);                 
                GetDlgItem(IDM_REMOVEFROMCONF)->EnableWindow(false);                                    
            }
        }

        pCallInfo->Release();
    }

    return rType;
}

void CTapi3Dlg::GetCallersBasicCall(ITCallStateEvent* pCallStateEvent)
{
    HRESULT hr;
    ITBasicCallControl* pCall;

	if (m_pCallInfo)
	{
		TRACE("GetCallersBasicCall CallInfo(%X) --\n",(int)m_pCallInfo);
		m_pCallInfo->Release();
		m_pCallInfo = NULL;
	}
    hr = pCallStateEvent->get_Call(&m_pCallInfo);
	TRACE("GetCallersBasicCall CallInfo(%X) ++\n",(int)m_pCallInfo);

    if (hr == S_OK)
    {
        CString sAddr;
        CTAPIConn::GetDialableAddress(m_pCallInfo, sAddr); 

        // initialize TelephonyEngine with caller's address
        if(m_pTEngine)
            m_pTEngine->Init(sAddr, sAddr, "");

    }

    if (hr == S_OK)
    {
        hr = m_pCallInfo->QueryInterface(IID_ITBasicCallControl, (void**)&pCall);                
		TRACE("GetCallersBasicCall Call (%X) ++\n",(int)pCall);

	    if (hr != S_OK)
	    {
		    PRINT_INIT(-1, 0, "Failed to obtain IID_ITBasicCallControl Interface, hr=%x", hr);
	    }
        else
        {
            if (m_pTransferConsultCall != pCall)
			{
				if (m_pCallersBasicCall)
				{
					TRACE("GetCallersBasicCall Call (%X) --\n",(int)m_pCallersBasicCall);
					m_pCallersBasicCall->Release();
				}

				m_pCallersBasicCall = pCall;
			}
			else
			{
				TRACE("GetCallersBasicCall Call (%X) --\n",(int)pCall);
				pCall->Release();
			}
        }
    }
}

void CTapi3Dlg::HandleCallNotificationEvent(ITCallNotificationEvent* pCallNotificationEvent)
{
    CALL_NOTIFICATION_EVENT cne;
    HRESULT hr;
    ITCallInfo* pCallInfo;

    // check to see if we own the call
    pCallNotificationEvent->get_Event( &cne );

    if (cne != CNE_OWNER)
    {
        return;
    }
    
    // get a call
    pCallNotificationEvent->get_Call( &pCallInfo );

	if (m_pCall != NULL)
	{
		TRACE("HandleCallNotificationEvent Call (%X) --\n",(int)m_pCall);
		m_pCall->Release();
		m_pCall = NULL;
		PRINT_INIT(-1, 0, "m_pCall not NULL");
	}

    hr = pCallInfo->QueryInterface( IID_ITBasicCallControl, (void**)&m_pCall);
	TRACE("HandleCallNotificationEvent Call (%X) ++\n",(int)m_pCall);

	if (hr != S_OK)
	{
		PRINT_INIT(-1, 0, "Failed to obtain IID_ITBasicCallControl Interface, hr=%x", hr);
	}

    pCallInfo->Release();

    return;
}

void CTapi3Dlg::ReleaseTheCall(ITBasicCallControl* pCall)
{
    bool isRealDisc = false;

    if (m_pCall != NULL && m_pCall == pCall)
    {
		TRACE("ReleaseTheCall Call (%X) --\n",(int)m_pCall);
        m_pCall->Release();