//------------------------------------------------------------------------------------
//  Copyright (c) 2002 Avaya Global SME Solutions 
//------------------------------------------------------------------------------------
//  Project name: TAPI 3 Test Harness
//  Module file : TapiEvent.cpp
//  Compiler    : Visual C++ 6.0
//------------------------------------------------------------------------------------
//  Description : Implementation of the CTapiEvent class hierarchy. In this module 
//                polimorphism is used to implement different types of events and to 
//                implement their different presentations by overloading virtual method 
//                Dump.
//------------------------------------------------------------------------------------

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

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

// CTapiObject Class
CTapiObject::CTapiObject(IDispatch* p)
{
	m_level = 0;
	m_pIEvent = NULL;

	if (p != NULL)
	{
		m_pIEvent = p;
		m_pIEvent->AddRef();
	}
}

CTapiObject::~CTapiObject()
{
	if (m_pIEvent != NULL)
		m_pIEvent->Release();
}

// Construction/Destruction
CTapiEvent::CTapiEvent(IDispatch* p) : CTapiObject(p)
{
}

CTapiEvent::~CTapiEvent()
{
}

// Construction/Destruction
CCallHubEvent::CCallHubEvent(IDispatch *p) : CTapiEvent(p)
{
}

CCallHubEvent::~CCallHubEvent()
{
}

inline const TAPI_EVENT CCallHubEvent::GetEventType() 
{ 
	return TE_CALLHUB; 
}

inline const CString CCallHubEvent::GetASCIIEventType() 
{ 
	return _T("TE_CALLHUB"); 
}

IDispatch* CCallHubEvent::GetIDispatch() 
{
	if (m_pIEvent) 
        m_pIEvent->AddRef();

	return m_pIEvent; 
}

void CCallHubEvent::Dump(int index)
{
	HRESULT hr;
    CString dialAddr;
    ITCallInfo* ppCall;

	ITCallHubEvent* pCallHubEvent;
	hr = m_pIEvent->QueryInterface(IID_ITCallHubEvent, (LPVOID*)&pCallHubEvent);
	if (hr == S_OK)
	{
		CALLHUB_EVENT chEvent;
		CString sChEvent;

		pCallHubEvent->get_Event(&chEvent);
		CTAPIConn::GetASCIICallHubEvent(chEvent, sChEvent);
		PRINT(index++, m_level+1, sChEvent.GetBuffer(0));

        hr = pCallHubEvent->get_Call(&ppCall);
        if (hr == S_OK)
        {            
            CString cStr;

            CTAPIConn::GetAddressName(ppCall, cStr);
            m_AddrStr = _T("Address: ") + cStr;
            PRINT(index++, m_level+1, m_AddrStr.GetBuffer(0)); 

            ppCall->Release();
        }

		pCallHubEvent->Release();
	}
}

// Construction/Destruction
CCallStateEvent::CCallStateEvent(IDispatch *p) : CTapiEvent(p)
{
}

CCallStateEvent::~CCallStateEvent()
{
}

inline const TAPI_EVENT CCallStateEvent::GetEventType() 
{ 
	return TE_CALLSTATE; 
}

inline const CString CCallStateEvent::GetASCIIEventType() 
{ 
	return _T("TE_CALLSTATE"); 
}

IDispatch* CCallStateEvent::GetIDispatch() 
{
	if (m_pIEvent) 
        m_pIEvent->AddRef();

    return m_pIEvent; 
}

void CCallStateEvent::Dump(int index)
{
	HRESULT hr;
	ITCallStateEvent* pCallStateEvent;
    ITCallInfo* pCallInfo;

	hr = m_pIEvent->QueryInterface(IID_ITCallStateEvent, (LPVOID*)&pCallStateEvent);
	if (hr == S_OK)
	{
		CALL_STATE State;
		CALL_STATE_EVENT_CAUSE Cause;
		CString sCallState, sCallStateEventCause, s;
		
		pCallStateEvent->get_State(&State);
		pCallStateEvent->get_Cause(&Cause);
		CTAPIConn::GetASCIICallState(State, sCallState);
		CTAPIConn::GetASCIICallStateEventCause(Cause, sCallStateEventCause);

		s = _T("State: ")+sCallState;
		PRINT(index++, m_level+1, s.GetBuffer(0));
		s = _T("Cause: ")+sCallStateEventCause;
		PRINT(index++, m_level+1, s.GetBuffer(0));

        hr = pCallStateEvent->get_Call(&pCallInfo);
        if (hr == S_OK)
        {
            CString cStr;

            CTAPIConn::GetAddressName(pCallInfo, cStr);
            m_AddrStr = _T("Address: ") + cStr;
            PRINT(index++, m_level+1, m_AddrStr.GetBuffer(0)); 

            pCallInfo->Release();
        }

		pCallStateEvent->Release();
	}
}

// Construction/Destruction
CCallNotificationEvent::CCallNotificationEvent(IDispatch *p) : CTapiEvent(p)
{
	HRESULT hr;
	ITCallNotificationEvent* pCallNotificationEvent;
    ITCallInfo* pCall;
    CString cStr, sCallState, s;
    CALL_STATE State;

    if ( m_pIEvent!= NULL)
    {
	    hr = m_pIEvent->QueryInterface(IID_ITCallNotificationEvent, (LPVOID*)&pCallNotificationEvent);
	    if (hr == S_OK)
	    {
            // get a call
            pCallNotificationEvent->get_Call( &pCall );

            CTAPIConn::GetAddressName(pCall, cStr);
            m_AddrStr = _T("Address: ") + cStr;

            pCall->get_CallState(&State);
            CTAPIConn::GetASCIICallState(State, sCallState);
		    m_StateStr = _T("State: ") + sCallState;

            pCall->Release();
		    pCallNotificationEvent->Release();
	    }
    }
}

CCallNotificationEvent::~CCallNotificationEvent()
{
}

inline const TAPI_EVENT CCallNotificationEvent::GetEventType() 
{ 
	return TE_CALLNOTIFICATION; 
}

inline const CString CCallNotificationEvent::GetASCIIEventType() 
{ 
	return _T("TE_CALLNOTIFICATION"); 
}

IDispatch* CCallNotificationEvent::GetIDispatch() 
{
	if (m_pIEvent) 
        m_pIEvent->AddRef();

    return m_pIEvent; 
}

void CCallNotificationEvent::Dump(int index)
{
    PRINT(index++, m_level+1, m_AddrStr.GetBuffer(0));  
    PRINT(index++, m_level+1, m_StateStr.GetBuffer(0));  
}

// CCallInfoChangeEvent Class
CCallInfoChangeEvent::CCallInfoChangeEvent(IDispatch *p) : CTapiEvent(p)
{
    ITCallInfoChangeEvent* pCallInfoChangeEvent;
    ITCallInfo* pCall;
    CString cStr, sCallState;
    HRESULT hr;
    CALL_STATE State;

    if (m_pIEvent != NULL)
    {
        hr = m_pIEvent->QueryInterface(IID_ITCallInfoChangeEvent, (LPVOID*)&pCallInfoChangeEvent);

        if ( hr == S_OK )
        {
            // get a call
            pCallInfoChangeEvent->get_Call( &pCall );

            CTAPIConn::GetAddressName(pCall, cStr);
            m_AddrStr = _T("Address: ") + cStr;

            pCall->get_CallState(&State);
            CTAPIConn::GetASCIICallState(State, sCallState);
		    m_StateStr = _T("State: ") + sCallState;
        
            pCall->Release();
            pCallInfoChangeEvent->Release();
        }
        else
        {
            PRINT_INIT(-1, 0, "Failed to obtain ITCallInfoChangeEvent Interface, hr=%x", hr);
        }
    }
}

CCallInfoChangeEvent::~CCallInfoChangeEvent()
{
}

inline const TAPI_EVENT CCallInfoChangeEvent::GetEventType() 
{ 
	return TE_CALLSTATE; 
}

inline const CString CCallInfoChangeEvent::GetASCIIEventType() 
{ 
	return _T("TE_CALLSTATE"); 
}

IDispatch* CCallInfoChangeEvent::GetIDispatch() 
{
	if (m_pIEvent) 
        m_pIEvent->AddRef();

	return m_pIEvent; 
}

void CCallInfoChangeEvent::Dump(int index)
{
    PRINT(index++, m_level+1, m_AddrStr.GetBuffer(0));  
    PRINT(index++, m_level+1, m_StateStr.GetBuffer(0));  
}