// ForwardMgrDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ForwardMgr.h"
#include "ForwardMgrDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void FAR PASCAL CForwardMgrDlg::lineCallback(DWORD hDevice,DWORD dwMsg,DWORD dwCallbackInstance,
											 DWORD dwParam1,DWORD dwParam2,DWORD dwParam3)
{
	switch(dwMsg)
	{
		case LINE_DEVSPECIFIC:
		{
			break;
		}
		case LINE_REPLY:
		{
			CString		strError;

			switch(dwParam2)
			{
				case 0:								strError	= TEXT("");								break;
				case LINEERR_INVALLINEHANDLE:		strError	= TEXT("LINEERR_INVALLINEHANDLE");		break;
				case LINEERR_NOMEM:					strError	= TEXT("LINEERR_NOMEM");				break;
				case LINEERR_OPERATIONUNAVAIL:		strError	= TEXT("LINEERR_OPERATIONUNAVAIL");		break;
				case LINEERR_OPERATIONFAILED:		strError	= TEXT("LINEERR_OPERATIONFAILED");		break;
				case LINEERR_RESOURCEUNAVAIL:		strError	= TEXT("LINEERR_RESOURCEUNAVAIL");		break;
				case LINEERR_INVALPOINTER:			strError	= TEXT("LINEERR_INVALPOINTER");			break;
				case LINEERR_INVALPARAM:			strError	= TEXT("LINEERR_INVALPARAM");			break;
				case LINEERR_UNINITIALIZED:			strError	= TEXT("LINEERR_UNINITIALIZED");		break;
				default:							strError.Format(TEXT("Error: %x"),dwParam2);		break;
			}

			if(strError.GetLength() > 0)
				AfxMessageBox(strError);

			break;
		}
	}
}


// CForwardMgrDlg dialog

CForwardMgrDlg::CForwardMgrDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CForwardMgrDlg::IDD, pParent)
	, m_strAllCallsNumber(_T(""))
	, m_strNoAnswerNumber(_T(""))
	, m_strUnAvailNumber(_T(""))
	, m_strBusyNumber(_T(""))
{
	m_hIcon				= AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_hLineApp			= NULL;
	m_dwDevices			= 0;
	m_dwCellularId		= 0;
	m_dwExtVersion		= 0;
	m_dwAPIVersion		= 0;
	m_dwLowAPIVersion	= 0;
	m_dwAddressId		= 0;
	m_hCellularLine		= NULL;
}

void CForwardMgrDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_ALL_CALLS, m_wndAllCalls);
	DDX_Control(pDX, IDC_NOANSWER, m_wndNoAnswer);
	DDX_Control(pDX, IDC_UNAVAIL, m_wndUnAvail);
	DDX_Control(pDX, IDC_BUSY, m_wndBusy);
	DDX_Text(pDX, IDC_ALLCALLS_NUMBER, m_strAllCallsNumber);
	DDX_Text(pDX, IDC_NOANSWER_NUMBER, m_strNoAnswerNumber);
	DDX_Text(pDX, IDC_UNAVAIL_NUMBER, m_strUnAvailNumber);
	DDX_Text(pDX, IDC_BUSY_NUMBER, m_strBusyNumber);
	DDX_Control(pDX, IDC_AFTERSECONDS, m_wndSeconds);
}

BEGIN_MESSAGE_MAP(CForwardMgrDlg, CDialog)
	ON_WM_SIZE()
	ON_WM_DESTROY()

	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_ALL_CALLS, &CForwardMgrDlg::OnBnClickedAllCalls)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_NOANSWER, &CForwardMgrDlg::OnBnClickedNoanswer)
END_MESSAGE_MAP()


// CForwardMgrDlg message handlers

BOOL CForwardMgrDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	AddSecondsToComboBox(&m_wndSeconds);

	if(0 == InitializeTAPI())
	{
		m_dwCellularId	= GetCellularLineId();
	}

	if(0xFFFFFFFF != m_dwCellularId)
	{
		m_hCellularLine	= OpenTAPILine(m_dwCellularId);

		if(m_hCellularLine)
		{
			CString	strAddress(TEXT("9746495065"));

			LONG lError = lineGetAddressID(m_hCellularLine,&m_dwAddressId,LINEADDRESSMODE_DIALABLEADDR,
										   strAddress,strAddress.GetLength());

			if(lError == 0)
			{
				SetTimer(ID_TIMER_GETINFO,100,NULL);
			}
		}
	}
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CForwardMgrDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType,cx,cy);
}

void CForwardMgrDlg::OnDestroy()
{
	ShutdownTAPI();

	CDialog::OnDestroy();
}

long CForwardMgrDlg::InitializeTAPI()
{
	LINEINITIALIZEEXPARAMS	sLineParam;

	memset(&sLineParam,0,sizeof(LINEINITIALIZEEXPARAMS));

	sLineParam.dwTotalSize	= sizeof(LINEINITIALIZEEXPARAMS);
	sLineParam.dwOptions	= LINEINITIALIZEEXOPTION_USEHIDDENWINDOW; 

	m_dwLowAPIVersion		= TAPI_CURRENT_VERSION;

	long	lReturn	= lineInitializeEx(&m_hLineApp,
									   theApp.m_hInstance,
									   lineCallback,
									   TAPI_FRIENDLY_NAME,
									   &m_dwDevices,
									   &m_dwLowAPIVersion,
									   &sLineParam);

	return lReturn;
}

void CForwardMgrDlg::ShutdownTAPI()
{
	if(m_hCellularLine)
	{
		lineClose(m_hCellularLine);
	}

	if(m_hLineApp)
	{
		lineShutdown(m_hLineApp);
	}

	m_hLineApp		= NULL;
	m_hCellularLine	= NULL;
}

DWORD CForwardMgrDlg::GetCellularLineId()
{
	DWORD				dwReturn		= 0xFFFFFFFF;
	long				lResult			= 0;
	LINEEXTENSIONID		sLineExt		= {0};
	LPLINEDEVCAPS		lpLineDevCaps	= NULL;	
	BOOL				bContinue		= TRUE;

	for(DWORD dwLine=0; dwLine<m_dwDevices && bContinue; ++dwLine)
	{
		lResult		= lineNegotiateAPIVersion(m_hLineApp,dwLine,m_dwLowAPIVersion,TAPI_CURRENT_VERSION,&m_dwAPIVersion,&sLineExt);

		if(0 == lResult)
		{
			lpLineDevCaps	= (LPLINEDEVCAPS)LocalAlloc(LPTR,sizeof(LINEDEVCAPS));
			lResult			= LINEERR_STRUCTURETOOSMALL;

			lpLineDevCaps->dwTotalSize	= sizeof(LINEDEVCAPS);
			lpLineDevCaps->dwNeededSize	= sizeof(LINEDEVCAPS);

			while(LINEERR_STRUCTURETOOSMALL == lResult)
			{
				lResult	= lineGetDevCaps(m_hLineApp,dwLine,TAPI_CURRENT_VERSION,0,lpLineDevCaps);

				if(LINEERR_STRUCTURETOOSMALL == lResult || lpLineDevCaps->dwTotalSize < lpLineDevCaps->dwNeededSize)
				{
					lpLineDevCaps	= (LPLINEDEVCAPS)LocalReAlloc(lpLineDevCaps,lpLineDevCaps->dwNeededSize,LMEM_MOVEABLE);
					lResult			= LINEERR_STRUCTURETOOSMALL;

					lpLineDevCaps->dwTotalSize	= lpLineDevCaps->dwNeededSize;
				}
			}

			if(0 == lResult)
			{
				TCHAR szName[512];

				memcpy((PVOID)szName,(PVOID)((BYTE*)lpLineDevCaps + lpLineDevCaps ->dwLineNameOffset), 
					    lpLineDevCaps->dwLineNameSize);

				szName[lpLineDevCaps->dwLineNameSize]	= 0;

				if(_tcscmp(szName,CELLTSP_LINENAME_STRING) == 0)
				{
					dwReturn	= dwLine;
					bContinue	= FALSE;
				}
			}

			LocalFree((HLOCAL)lpLineDevCaps);
		}
	}

	return dwReturn;
}

HLINE CForwardMgrDlg::OpenTAPILine(DWORD dwLineId)
{
	DWORD	dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
	HLINE	hLine		= NULL;
	long	lReturn		= lineOpen(m_hLineApp,m_dwCellularId,&hLine,
								   TAPI_CURRENT_VERSION,0,(DWORD)this,
								   LINECALLPRIVILEGE_OWNER,dwMediaMode,0);

	lReturn				= lineNegotiateExtVersion(m_hLineApp,m_dwCellularId,m_dwAPIVersion,EXT_API_LOW_VERSION,EXT_API_HIGH_VERSION,&m_dwExtVersion);

	return hLine;
}

BOOL CForwardMgrDlg::GetAddressStatus(DWORD dwAddress,PFORWARDINFOLIST pList)
{
	PCALLFORWARDING_INFO	pInfo	= NULL;
	LPLINEADDRESSSTATUS		pStatus	= (LPLINEADDRESSSTATUS)LocalAlloc(LPTR,sizeof(LPLINEADDRESSSTATUS)); 

	pStatus->dwTotalSize	= sizeof(LINEGENERALINFO);
	
	LONG				lReturn	= LINEERR_STRUCTURETOOSMALL;

	while(LINEERR_STRUCTURETOOSMALL == lReturn)
	{
		lReturn	= lineGetAddressStatus(m_hCellularLine,dwAddress,pStatus);

		if(LINEERR_STRUCTURETOOSMALL == lReturn || pStatus->dwTotalSize < pStatus->dwNeededSize)
		{
			pStatus	= (LPLINEADDRESSSTATUS)LocalReAlloc(pStatus,pStatus->dwNeededSize,LMEM_MOVEABLE);
			lReturn	= LINEERR_STRUCTURETOOSMALL;

			pStatus->dwTotalSize	= pStatus->dwNeededSize;
		}
	}

	int	nForwardCount			= 0;

	if(0 == lReturn)
	{
		LPLINEFORWARD	pForward				= (LPLINEFORWARD)((BYTE*)pStatus + pStatus->dwForwardOffset);
		LPLINEFORWARD	pForwardTemp			= NULL;
		TCHAR			szAddress[MAX_PATH]		= {0};

		nForwardCount			= (int)(pStatus->dwForwardNumEntries);

		for(int nForward=0; nForward<nForwardCount; ++nForward)
		{
			pForwardTemp		= &(pForward[nForward]);

			DWORD	dwOffset	= pForwardTemp->dwDestAddressOffset;
			DWORD	dwSize		= pForwardTemp->dwDestAddressSize;
			DWORD	dwMode		= pForwardTemp->dwForwardMode;
			CString	strMode		= TEXT("");
			CString	strMessage	= TEXT("");

			for(int i = 0; i <(signed)(dwSize/2); ++i)
			{
				szAddress[i]	= (char)(*((unsigned short *)(pStatus) + i + dwOffset/2));
				szAddress[i+1]	= NULL;
			}

			pInfo				= new CALLFORWARDING_INFO;
			pInfo->dwMode		= dwMode;
			pInfo->nSeconds		= pStatus->dwNumRingsNoAnswer;
			pInfo->strNumber	= szAddress;

			pList->Add(pInfo);
		}
	}

	LocalFree(pStatus);

	return (nForwardCount > 0);
}

void CForwardMgrDlg::ForwardModeToString(DWORD dwMode,CString& strMode)
{
	switch(dwMode)
	{
		case LINEFORWARDMODE_BUSY:				strMode	= TEXT("Forward all calls on busy");						break;
		case LINEFORWARDMODE_BUSYEXTERNAL:		strMode	= TEXT("Forward all external calls on busy");				break;
		case LINEFORWARDMODE_BUSYINTERNAL:		strMode	= TEXT("Forward all internal calls on busy");				break;
		case LINEFORWARDMODE_BUSYNA:			strMode	= TEXT("Forward all calls on busy/no answer");				break;
		case LINEFORWARDMODE_BUSYNAEXTERNAL:	strMode	= TEXT("Forward all external calls on busy/no answer");		break;
		case LINEFORWARDMODE_BUSYNAINTERNAL:	strMode	= TEXT("Forward all internal calls on busy/no answer");		break;
		case LINEFORWARDMODE_BUSYNASPECIFIC:	strMode	= TEXT("Forward on busy/no answer all calls (selective)");	break;
		case LINEFORWARDMODE_BUSYSPECIFIC:		strMode	= TEXT("Forward on busy all calls (specific)");				break;
		case LINEFORWARDMODE_NOANSW:			strMode	= TEXT("Forward all calls on no answer");					break;
		case LINEFORWARDMODE_NOANSWEXTERNAL:	strMode	= TEXT("Forward all external calls on no answer");			break;
		case LINEFORWARDMODE_NOANSWINTERNAL:	strMode	= TEXT("Forward all internal calls on no answer");			break;
		case LINEFORWARDMODE_NOANSWSPECIFIC:	strMode	= TEXT("Forward on no answer all calls (specific)");		break;
		case LINEFORWARDMODE_UNAVAIL:			strMode	= TEXT("Calls are unavailable forwarded");					break;
		case LINEFORWARDMODE_UNCOND:			strMode	= TEXT("Forward all calls unconditionally");				break;
		case LINEFORWARDMODE_UNCONDEXTERNAL:	strMode	= TEXT("Forward all external calls unconditionally");		break;
		case LINEFORWARDMODE_UNCONDINTERNAL:	strMode	= TEXT("Forward all internal calls unconditionally");		break;
		case LINEFORWARDMODE_UNCONDSPECIFIC:	strMode	= TEXT("Unconditionally forward all calls (specific)");		break;