/*

Miranda IM: the free IM client for Microsoft* Windows*

Copyright 2000-2009 Miranda ICQ/IM project, 
all portions of this codebase are copyrighted to the people
listed in contributors.txt.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include "..\..\core\commonheaders.h"

int LoadProtoChains(void);
int LoadProtoOptions( void );

HANDLE hAccListChanged;
static HANDLE hAckEvent, hTypeEvent;
static BOOL bModuleInitialized = FALSE;

typedef struct
{
	const char* name;
	int id;
}
	TServiceListItem;

static int CompareServiceItems( const TServiceListItem* p1, const TServiceListItem* p2 )
{	return strcmp( p1->name, p2->name );
}

static LIST<TServiceListItem> serviceItems( 10, CompareServiceItems );

//------------------------------------------------------------------------------------

static int CompareProtos( const PROTOCOLDESCRIPTOR* p1, const PROTOCOLDESCRIPTOR* p2 )
{	return strcmp( p1->szName, p2->szName );
}

static LIST<PROTOCOLDESCRIPTOR> protos( 10, CompareProtos );

static INT_PTR Proto_BroadcastAck(WPARAM wParam, LPARAM lParam)
{

	ACKDATA *ack = (ACKDATA*)lParam;
	if (ack && ack->type == ACKTYPE_AVATAR && ack->hProcess) {
		PROTO_AVATAR_INFORMATION* ai = (PROTO_AVATAR_INFORMATION*)ack->hProcess;
		if (ai->cbSize == sizeof(PROTO_AVATAR_INFORMATION)) {
			PROTO_AVATAR_INFORMATIONW aiw = { sizeof(aiw), ai->hContact, ai->format };
			MultiByteToWideChar(CP_ACP, 0, ai->filename, -1, aiw.filename, SIZEOF(aiw.filename));

			ack->hProcess = &aiw;
		}	
	}


	return NotifyEventHooks(hAckEvent, wParam, lParam);
}

INT_PTR __fastcall MyCallProtoService( const char *szModule, const char *szService, WPARAM wParam, LPARAM lParam );
void FreeFilesMatrix( TCHAR ***files );

PROTOCOLDESCRIPTOR* __fastcall Proto_IsProtocolLoaded( const char* szProtoName )
{
	if ( szProtoName ) {
		PROTOCOLDESCRIPTOR tmp;
		tmp.szName = ( char* )szProtoName;
		return protos.find( &tmp );
	}
	return NULL;
}

INT_PTR srvProto_IsLoaded(WPARAM, LPARAM lParam)
{
	return (INT_PTR)Proto_GetAccount(( char* )lParam );
}

INT_PTR Proto_EnumProtocols(WPARAM wParam, LPARAM lParam)
{
	*( int* )wParam = protos.getCount();
	*( PROTOCOLDESCRIPTOR*** )lParam = protos.getArray();
	return 0;
}

static PROTO_INTERFACE* defInitProto( const char* szModuleName, const TCHAR* )
{
	return AddDefaultAccount( szModuleName );
}

static INT_PTR Proto_RegisterModule(WPARAM, LPARAM lParam)
{
	PROTOCOLDESCRIPTOR* pd = ( PROTOCOLDESCRIPTOR* )lParam, *p;
	if ( pd->cbSize != sizeof( PROTOCOLDESCRIPTOR ) && pd->cbSize != PROTOCOLDESCRIPTOR_V3_SIZE )
		return 1;

	p = ( PROTOCOLDESCRIPTOR* )mir_alloc( sizeof( PROTOCOLDESCRIPTOR ));
	if ( !p )
		return 2;

	if ( pd->cbSize == PROTOCOLDESCRIPTOR_V3_SIZE ) {
		memset( p, 0, sizeof( PROTOCOLDESCRIPTOR ));
		p->cbSize = PROTOCOLDESCRIPTOR_V3_SIZE;
		p->type = pd->type;
		if ( p->type == PROTOTYPE_PROTOCOL ) {
			// let's create a new container
			PROTO_INTERFACE* ppi = AddDefaultAccount( pd->szName );
			if ( ppi ) {
				PROTOACCOUNT* pa = Proto_GetAccount( pd->szName );
				if ( pa == NULL ) {
					pa = (PROTOACCOUNT*)mir_calloc( sizeof( PROTOACCOUNT ));
					pa->cbSize = sizeof(PROTOACCOUNT);
					pa->type = PROTOTYPE_PROTOCOL;
					pa->szModuleName = mir_strdup( pd->szName );
					pa->szProtoName = mir_strdup( pd->szName );
					pa->tszAccountName = mir_a2t( pd->szName );
					pa->bIsVisible = pa->bIsEnabled = TRUE;
					pa->iOrder = accounts.getCount();
					accounts.insert( pa );
				}
				pa->bOldProto = TRUE;
				pa->ppro = ppi;
				p->fnInit = defInitProto;
				p->fnUninit = FreeDefaultAccount;
			}
		}
	}
	else *p = *pd;
	p->szName = mir_strdup( pd->szName );
	protos.insert( p );
	return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
// Basic core services

static INT_PTR Proto_RecvFile(WPARAM, LPARAM lParam)
{
	CCSDATA* ccs = ( CCSDATA* )lParam;
	PROTORECVEVENT* pre = ( PROTORECVEVENT* )ccs->lParam;
	char* szFile = pre->szMessage + sizeof( DWORD );
	char* szDescr = szFile + strlen( szFile ) + 1;

	// Suppress the standard event filter
	if ( pre->lParam != NULL )
		*( DWORD* )pre->szMessage = 0;

	DBEVENTINFO dbei = { 0 };
	dbei.cbSize = sizeof( dbei );
	dbei.szModule = ( char* )CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)ccs->hContact, 0);
	dbei.timestamp = pre->timestamp;
	dbei.flags = ( pre->flags & PREF_CREATEREAD ) ? DBEF_READ : 0;
	dbei.flags |= ( pre->flags & PREF_UTF ) ? DBEF_UTF : 0;
	dbei.eventType = EVENTTYPE_FILE;
	dbei.cbBlob = (DWORD)(sizeof( DWORD ) + strlen( szFile ) + strlen( szDescr ) + 2);
	dbei.pBlob = ( PBYTE )pre->szMessage;
	HANDLE hdbe = ( HANDLE )CallService( MS_DB_EVENT_ADD, ( WPARAM )ccs->hContact, ( LPARAM )&dbei );

	if ( pre->lParam != NULL )
		PushFileEvent( ccs->hContact, hdbe, pre->lParam );
	return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////

static void sttRecvCreateBlob( DBEVENTINFO& dbei, int fileCount, char** pszFiles, char* szDescr )
{
	dbei.cbBlob = sizeof( DWORD );
	{
		for ( int i=0; i < fileCount; i++ )
			dbei.cbBlob += lstrlenA( pszFiles[i] ) + 1;
	}
	
	dbei.cbBlob += lstrlenA( szDescr ) + 1;

	if (( dbei.pBlob = ( BYTE* )mir_alloc( dbei.cbBlob )) == 0 )
		return;

	*( DWORD* )dbei.pBlob = 0;
	BYTE* p = dbei.pBlob + sizeof( DWORD );
	for ( int i=0; i < fileCount; i++ ) {
		strcpy(( char* )p, pszFiles[i] );
		p += lstrlenA( pszFiles[i] ) + 1;
	}
	strcpy(( char* )p, ( szDescr == NULL ) ? "" : szDescr );
}

static INT_PTR Proto_RecvFileT(WPARAM, LPARAM lParam)
{
	CCSDATA* ccs = ( CCSDATA* )lParam;
	PROTORECVFILET* pre = ( PROTORECVFILET* )ccs->lParam;
	if ( pre->fileCount == 0 )
		return 0;

	DBEVENTINFO dbei = { 0 };
	dbei.cbSize = sizeof( dbei );
	dbei.szModule = ( char* )CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)ccs->hContact, 0);
	dbei.timestamp = pre->timestamp;
	dbei.flags = ( pre->flags & PREF_CREATEREAD ) ? DBEF_READ : 0;
	dbei.eventType = EVENTTYPE_FILE;

	char** pszFiles = ( char** )alloca( pre->fileCount * sizeof(char*));
	{
		for ( int i=0; i < pre->fileCount; i++ )
			pszFiles[i] = Utf8EncodeT( pre->ptszFiles[i] );
	}
	char* szDescr = Utf8EncodeT( pre->tszDescription );
	dbei.flags |= DBEF_UTF;
	sttRecvCreateBlob( dbei, pre->fileCount, pszFiles, szDescr );
	{
		for ( int i=0; i < pre->fileCount; i++ )
			mir_free( pszFiles[i] );
	}
	mir_free( szDescr );

	HANDLE hdbe = ( HANDLE )CallService( MS_DB_EVENT_ADD, ( WPARAM )ccs->hContact, ( LPARAM )&dbei );

	PushFileEvent( ccs->hContact, hdbe, pre->lParam );
	mir_free( dbei.pBlob );
	return 0;
}

static INT_PTR Proto_RecvMessage(WPARAM, LPARAM lParam)
{
	CCSDATA *ccs = ( CCSDATA* )lParam;
	PROTORECVEVENT *pre = ( PROTORECVEVENT* )ccs->lParam;

    if (pre->szMessage == NULL) return NULL;

	DBEVENTINFO dbei = { 0 };
	dbei.cbSize = sizeof( dbei );
	dbei.szModule = ( char* )CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)ccs->hContact, 0);
	dbei.timestamp = pre->timestamp;
	dbei.eventType = EVENTTYPE_MESSAGE;
	dbei.cbBlob = (DWORD)strlen( pre->szMessage ) + 1;
	if ( pre->flags & PREF_CREATEREAD )
		dbei.flags |= DBEF_READ;
	if ( pre->flags & PREF_UTF )
		dbei.flags |= DBEF_UTF;
	if ( pre->flags & PREF_UNICODE )
		dbei.cbBlob += sizeof( wchar_t )*((DWORD)wcslen(( wchar_t* )&pre->szMessage[dbei.cbBlob+1] )+1 );

	dbei.pBlob = ( PBYTE ) pre->szMessage;
	return CallService( MS_DB_EVENT_ADD, ( WPARAM ) ccs->hContact, ( LPARAM )&dbei );
}

/////////////////////////////////////////////////////////////////////////////////////////
// User Typing Notification services

static int Proto_ValidTypingContact(HANDLE hContact, char *szProto)
{
	if ( !hContact || !szProto )
		return 0;

	return ( CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_4, 0) & PF4_SUPPORTTYPING ) ? 1 : 0;
}

static INT_PTR Proto_SelfIsTyping(WPARAM wParam, LPARAM lParam)
{
	if ( lParam == PROTOTYPE_SELFTYPING_OFF || lParam == PROTOTYPE_SELFTYPING_ON ) {
		char* szProto = ( char* )CallService( MS_PROTO_GETCONTACTBASEPROTO, wParam, 0 );
		if ( !szProto )
			return 0;

		if ( Proto_ValidTypingContact(( HANDLE )wParam, szProto ))
			CallProtoService( szProto, PSS_USERISTYPING, wParam, lParam );
	}

	return 0;
}

static INT_PTR Proto_ContactIsTyping(WPARAM wParam, LPARAM lParam)
{
	int type = (int)lParam;
	char *szProto = ( char* )CallService( MS_PROTO_GETCONTACTBASEPROTO, wParam, 0 );
	if ( !szProto )
		return 0;

	if ( CallService( MS_IGNORE_ISIGNORED, wParam, IGNOREEVENT_TYPINGNOTIFY ))
		return 0;

	if ( type < PROTOTYPE_CONTACTTYPING_OFF )
		return 0;

	if ( Proto_ValidTypingContact(( HANDLE )wParam, szProto ))
		NotifyEventHooks( hTypeEvent, wParam, lParam );

	return 0;
}

void Proto_SetStatus(const char* szProto, unsigned status)
{
	if (CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND) 
	{
		TCHAR* awayMsg = (TCHAR* )CallService(MS_AWAYMSG_GETSTATUSMSGW, (WPARAM) status, (LPARAM) szProto);
		if ((INT_PTR)awayMsg == CALLSERVICE_NOTFOUND) 
		{
			char* awayMsgA = (char*)CallService(MS_AWAYMSG_GETSTATUSMSG, (WPARAM) status, (LPARAM) szProto);
			if ((INT_PTR)awayMsgA != CALLSERVICE_NOTFOUND)
			{
				awayMsg = mir_a2t(awayMsgA);
				mir_free(awayMsgA);
			}
		}
		if ((INT_PTR)awayMsg != CALLSERVICE_NOTFOUND) 
		{
			CallProtoService(szProto, PS_SETAWAYMSGT, status, (LPARAM) awayMsg);
			mir_free(awayMsg);
	}	}
	CallProtoService(szProto, PS_SETSTATUS, status, 0);
}


char** __fastcall Proto_FilesMatrixA( wchar_t **files )
{
	if ( files == NULL ) return NULL;

	int count = 0;
	while ( files[ count++ ] );

	char** filesA = ( char** )mir_alloc( count * sizeof( char* ));
	for ( int i = 0; i < count; ++i )
		filesA[ i ] = mir_u2a( files[ i ] );

	return filesA;
}

static wchar_t** __fastcall Proto_FilesMatrixU( char **files )
{
	if ( files == NULL ) return NULL;

	int count = 0;
	while ( files[ count++ ] );

	wchar_t** filesU = ( wchar_t** )mir_alloc( count * sizeof( wchar_t* ));
	for ( int i = 0; i < count; ++i )
		filesU[ i ] = mir_a2u( files[ i ] );

	return filesU;
}


/////////////////////////////////////////////////////////////////////////////////////////
// 0.8.0+ - accounts

PROTOACCOUNT* __fastcall Proto_GetAccount( const char* accName )
{
	int idx;
	PROTOACCOUNT temp;
	temp.szModuleName = ( char* )accName;
	if (( idx = accounts.getIndex( &temp )) == -1 )
		return NULL;

	return accounts[idx];
}

static INT_PTR srvProto_GetAccount(WPARAM, LPARAM lParam)
{
	return ( INT_PTR )Proto_GetAccount(( char* )lParam );
}

static INT_PTR Proto_EnumAccounts(WPARAM wParam, LPARAM lParam)
{
	*( int* )wParam = accounts.getCount();
	*( PROTOACCOUNT*** )lParam = accounts.getArray();
	return 0;
}

bool __fastcall Proto_IsAccountEnabled( PROTOACCOUNT* pa )
{
	return pa && (( pa->bIsEnabled && !pa->bDynDisabled ) || pa->bOldProto );
}

static INT_PTR srvProto_IsAccountEnabled(WPARAM, LPARAM lParam)
{
	return ( INT_PTR )Proto_IsAccountEnabled(( PROTOACCOUNT* )lParam);
}

bool __fastcall Proto_IsAccountLocked( PROTOACCOUNT* pa )
{
	return pa && DBGetContactSettingByte(NULL, pa->szModuleName, "LockMainStatus", 0) != 0;
}

static INT_PTR srvProto_IsAccountLocked(WPARAM, LPARAM lParam)
{
	return ( INT_PTR )Proto_IsAccountLocked( Proto_GetAccount(( char* )lParam ));
}

/////////////////////////////////////////////////////////////////////////////////////////

INT_PTR CallProtoServiceInt( HANDLE hContact, const char *szModule, const char *szService, WPARAM wParam, LPARAM lParam )
{
	PROTOACCOUNT* pa = Proto_GetAccount( szModule );
	if ( pa && !pa->bOldProto ) {
		PROTO_INTERFACE* ppi;
		if (( ppi = pa->ppro ) == NULL )
			return CALLSERVICE_NOTFOUND;
		else {
			TServiceListItem *item = serviceItems.find(( TServiceListItem* )&szService );
			if ( item ) {
				switch( item->id ) {
					case  1: 

						if ( ppi->m_iVersion > 1 || !((( PROTOSEARCHRESULT* )lParam)->flags & PSR_UNICODE))
							return ( INT_PTR )ppi->AddToList( wParam, (PROTOSEARCHRESULT*)lParam ); 
						else {
							PROTOSEARCHRESULT *psr = ( PROTOSEARCHRESULT* )lParam;
							PROTOSEARCHRESULT *psra =( PROTOSEARCHRESULT* )mir_alloc( psr->cbSize );
							memcpy( psra, psr, psr->cbSize );
							psra->nick      = ( PROTOCHAR* )mir_u2a( psr->nick );
							psra->firstName = ( PROTOCHAR* )mir_u2a( psr->firstName );
							psra->lastName  = ( PROTOCHAR* )mir_u2a( psr->lastName );
							psra->email     = ( PROTOCHAR* )mir_u2a( psr->email );
							
							INT_PTR res = ( INT_PTR )ppi->AddToList( wParam, psra );
							
							mir_free( psra->nick );
							mir_free( psra->firstName );
							mir_free( psra->lastName );
							mir_free( psra->email );
							mir_free( psra );
							
							return res;
						}

					case  2: return ( INT_PTR )ppi->AddToListByEvent( LOWORD(wParam), HIWORD(wParam), (HANDLE)lParam ); 
					case  3: return ( INT_PTR )ppi->Authorize(( HANDLE )wParam ); 
					case  4:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->AuthDeny(( HANDLE )wParam,  StrConvT(( char* )lParam )); 
						else
							return ( INT_PTR )ppi->AuthDeny(( HANDLE )wParam, ( PROTOCHAR* )lParam ); 
					case  5: return ( INT_PTR )ppi->AuthRecv( hContact, ( PROTORECVEVENT* )lParam ); 
					case  6:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->AuthRequest( hContact,  StrConvT(( char* )lParam )); 
						else
							return ( INT_PTR )ppi->AuthRequest( hContact, ( PROTOCHAR* )lParam ); 
					case  7: return ( INT_PTR )ppi->ChangeInfo( wParam, ( void* )lParam ); 
					case  8:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->FileAllow( hContact, ( HANDLE )wParam,  StrConvT(( char* )lParam )); 
						else
							return ( INT_PTR )ppi->FileAllow( hContact, ( HANDLE )wParam, ( PROTOCHAR* )lParam ); 
					case  9: return ( INT_PTR )ppi->FileCancel( hContact, ( HANDLE )wParam ); 
					case  10:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->FileDeny( hContact, ( HANDLE )wParam,  StrConvT(( char* )lParam )); 
						else
							return ( INT_PTR )ppi->FileDeny( hContact, ( HANDLE )wParam, ( PROTOCHAR* )lParam ); 
					case 11: {
						PROTOFILERESUME* pfr = ( PROTOFILERESUME* )lParam;

						if ( ppi->m_iVersion > 1 ) {
							PROTOCHAR* szFname = mir_a2t(( char* )pfr->szFilename );
							INT_PTR res = ( INT_PTR )ppi->FileResume(( HANDLE )wParam, &pfr->action, 
								( const PROTOCHAR** )&szFname);
							mir_free(( PROTOCHAR* )pfr->szFilename ); 
							pfr->szFilename = ( PROTOCHAR* )mir_t2a( szFname ); mir_free( szFname ); 
						}
						else

							return ( INT_PTR )ppi->FileResume(( HANDLE )wParam, &pfr->action, 
								( const PROTOCHAR** )&pfr->szFilename );
					}
					case 12: return ( INT_PTR )ppi->GetCaps( wParam, (HANDLE)lParam );
					case 13: return ( INT_PTR )ppi->GetIcon( wParam );
					case 14: return ( INT_PTR )ppi->GetInfo( hContact, wParam );;
					case 15: 
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchBasic( StrConvT(( char* )lParam ));
						else
							return ( INT_PTR )ppi->SearchBasic(( TCHAR* )lParam ); 
					case 16: 
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchByEmail( StrConvT(( char* )lParam ));
						else
							return ( INT_PTR )ppi->SearchByEmail(( TCHAR* )lParam ); 
					case 17: {
						PROTOSEARCHBYNAME* psbn = ( PROTOSEARCHBYNAME* )lParam;
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchByName( StrConvT(( char* )psbn->pszNick ), 
								StrConvT(( char* )psbn->pszFirstName ), StrConvT(( char* )psbn->pszLastName ));
						else
							return ( INT_PTR )ppi->SearchByName( psbn->pszNick, psbn->pszFirstName, psbn->pszLastName ); 
					}
					case 18: return ( INT_PTR )ppi->SearchAdvanced(( HWND )lParam ); 
					case 19: return ( INT_PTR )ppi->CreateExtendedSearchUI (( HWND )lParam ); 
					case 20: return ( INT_PTR )ppi->RecvContacts( hContact, ( PROTORECVEVENT* )lParam ); 
					case 21: return ( INT_PTR )ppi->RecvFile( hContact, ( PROTOFILEEVENT* )lParam ); 
					case 22: return ( INT_PTR )ppi->RecvMsg( hContact, ( PROTORECVEVENT* )lParam ); 
					case 23: return ( INT_PTR )ppi->RecvUrl( hContact, ( PROTORECVEVENT* )lParam ); 
					case 24: return ( INT_PTR )ppi->SendContacts( hContact, LOWORD( wParam ), HIWORD( wParam ), 
								 ( HANDLE* )lParam ); 
					case 25:

						if ( ppi->m_iVersion > 1 ) {
							TCHAR** files = Proto_FilesMatrixU(( char** )lParam );
							INT_PTR res = ( INT_PTR )ppi->SendFile( hContact, StrConvT(( char* )wParam ), ( TCHAR** )files ); 
							if ( res == 0 ) FreeFilesMatrix( &files );
							return res;
						}
						else

							return ( INT_PTR )ppi->SendFile( hContact, ( TCHAR* )wParam, ( TCHAR** )lParam );
					case 26: return ( INT_PTR )ppi->SendMsg( hContact, wParam, ( const char* )lParam ); 
					case 27: return ( INT_PTR )ppi->SendUrl( hContact, wParam, ( const char* )lParam ); 
					case 28: return ( INT_PTR )ppi->SetApparentMode( hContact, wParam ); 
					case 29: return ( INT_PTR )ppi->SetStatus( wParam ); 
					case 30: return ( INT_PTR )ppi->GetAwayMsg( hContact ); 
					case 31: return ( INT_PTR )ppi->RecvAwayMsg( hContact, wParam, ( PROTORECVEVENT* )lParam ); 
					case 32: return ( INT_PTR )ppi->SendAwayMsg( hContact, ( HANDLE )wParam, ( const char* )lParam ); 
					case 33: 
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SetAwayMsg( wParam, StrConvT(( char* )lParam ));
						else
							return ( INT_PTR )ppi->SetAwayMsg( wParam, ( TCHAR* )lParam ); 
					case 34: return ( INT_PTR )ppi->UserIsTyping(( HANDLE )wParam, lParam ); 
					case 35: lstrcpynA(( char* )lParam, ppi->m_szModuleName, wParam ); return 0; 
					case 36: return ppi->m_iStatus; 
					

					case 100:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SetAwayMsg( wParam, ( TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->SetAwayMsg( wParam, StrConvA(( TCHAR* )lParam )); 
					case 102:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SendFile( hContact, ( TCHAR* )wParam, ( TCHAR** )lParam );
						else {
							char** files = Proto_FilesMatrixA(( TCHAR** )lParam );
							INT_PTR res = ( INT_PTR )ppi->SendFile( hContact, StrConvA(( TCHAR* )wParam ), ( TCHAR** )files ); 
							if ( res == 0 ) FreeFilesMatrix(( TCHAR*** )&files );
							return res;
						}
					case 103:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->FileAllow( hContact, ( HANDLE )wParam, ( TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->FileAllow( hContact, ( HANDLE )wParam, StrConvA(( TCHAR* )lParam )); 
					case 104:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->FileDeny( hContact, ( HANDLE )wParam, ( TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->FileDeny( hContact, ( HANDLE )wParam, StrConvA(( TCHAR* )lParam )); 
					case 105: {
						PROTOFILERESUME* pfr = ( PROTOFILERESUME* )lParam;
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->FileResume(( HANDLE )wParam, &pfr->action, 
								( const PROTOCHAR** )&pfr->szFilename );
						else {
							char* szFname = mir_t2a( pfr->szFilename );
							INT_PTR res = ( INT_PTR )ppi->FileResume(( HANDLE )wParam, &pfr->action, 
								( const PROTOCHAR** )&szFname);
							mir_free( szFname );
					}	}
					case 106:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->AuthRequest( hContact, ( const TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->AuthRequest( hContact, StrConvA(( const TCHAR* )lParam )); 
					case 107:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->AuthDeny(( HANDLE )wParam, ( const TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->AuthDeny(( HANDLE )wParam, StrConvA(( const TCHAR* )lParam )); 
					case 108:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchBasic(( const TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->SearchBasic(StrConvA(( const TCHAR* )lParam )); 
					case 109: {
						PROTOSEARCHBYNAME* psbn = ( PROTOSEARCHBYNAME* )lParam;
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchByName( psbn->pszNick, psbn->pszFirstName, psbn->pszLastName ); 
						else
							return ( INT_PTR )ppi->SearchByName( StrConvA(( TCHAR* )psbn->pszNick ), 
								StrConvA(( TCHAR* )psbn->pszFirstName ), StrConvA(( TCHAR* )psbn->pszLastName ));
					}
					case 110:
						if ( ppi->m_iVersion > 1 )
							return ( INT_PTR )ppi->SearchByEmail(( const TCHAR* )lParam );
						else
							return ( INT_PTR )ppi->SearchByEmail(StrConvA(( const TCHAR* )lParam )); 

	}	}	}	}


	if ( !strcmp( szService, PS_ADDTOLIST )) {
		PROTOSEARCHRESULT *psr = ( PROTOSEARCHRESULT* )lParam;
		if ( !( psr->flags & PSR_UNICODE )) {
			PROTOSEARCHRESULT *psra =( PROTOSEARCHRESULT* )mir_alloc( psr->cbSize );
			memcpy( psra, psr, psr->cbSize );
			psra->nick      = ( PROTOCHAR* )mir_u2a( psr->nick );
			psra->firstName = ( PROTOCHAR* )mir_u2a( psr->firstName );
			psra->lastName  = ( PROTOCHAR* )mir_u2a( psr->lastName );
			psra->email     = ( PROTOCHAR* )mir_u2a( psr->email );
		
			INT_PTR res = MyCallProtoService( szModule, szService, wParam, ( LPARAM )psra );
		
			mir_free( psra->nick );
			mir_free( psra->firstName );
			mir_free( psra->lastName );
			mir_free( psra->email );
			mir_free( psra );
			return res;
		}		
	}


	INT_PTR res = MyCallProtoService( szModule, szService, wParam, lParam );


	if ( res == CALLSERVICE_NOTFOUND && pa && pa->bOldProto && pa->ppro && strchr( szService, 'W' )) {
		TServiceListItem *item = serviceItems.find(( TServiceListItem* )&szService );
		if ( !item ) return res;

		switch( item->id ) {
			case 100:
				return ( INT_PTR )pa->ppro->SetAwayMsg( wParam, ( TCHAR* )lParam );
			case 102: {
				CCSDATA *ccs = ( CCSDATA* )lParam;
				return ( INT_PTR )pa->ppro->SendFile( ccs->hContact, ( TCHAR* )ccs->wParam, ( TCHAR** )ccs->lParam );
			}
			case 103: {
				CCSDATA *ccs = ( CCSDATA* )lParam;
				return ( INT_PTR )pa->ppro->FileAllow( ccs->hContact, ( HANDLE )ccs->wParam, ( TCHAR* )ccs->lParam );
			}
			case 104: {
				CCSDATA *ccs = ( CCSDATA* )lParam;
				return ( INT_PTR )pa->ppro->FileDeny( ccs->hContact, ( HANDLE )ccs->wParam, ( TCHAR* )ccs->lParam );
			}
			case 105: {
				PROTOFILERESUME* pfr = ( PROTOFILERESUME* )lParam;
				return ( INT_PTR )pa->ppro->FileResume(( HANDLE )wParam, &pfr->action, &pfr->szFilename );
			}
			case 106: {
				CCSDATA *ccs = ( CCSDATA* )lParam;
				return ( INT_PTR )pa->ppro->AuthRequest( ccs->hContact, ( const TCHAR* )ccs->lParam );
			}
			case 107:
				return ( INT_PTR )pa->ppro->AuthDeny(( HANDLE )wParam, ( const TCHAR* )lParam );
			case 108:
				return ( INT_PTR )pa->ppro->SearchBasic(( const TCHAR* )lParam );
			case 109: {
				PROTOSEARCHBYNAME* psbn = ( PROTOSEARCHBYNAME* )lParam;
				return ( INT_PTR )pa->ppro->SearchByName( psbn->pszNick, psbn->pszFirstName, psbn->pszLastName ); 
			}
			case 110:
				return ( INT_PTR )pa->ppro->SearchByEmail(( const TCHAR* )lParam );
	}	}


	return res;
}

/////////////////////////////////////////////////////////////////////////////////////////

INT_PTR CallContactService( HANDLE hContact, const char *szProtoService, WPARAM wParam, LPARAM lParam )
{
	int i;
	DBVARIANT dbv;
	INT_PTR ret;
	PROTOACCOUNT* pa;
	CCSDATA ccs = { hContact, szProtoService, wParam, lParam };

	for ( i = 0;; i++ ) {
		char str[10];
		_itoa( i, str, 10 );
		if ( DBGetContactSettingString( hContact, "_Filter", str, &dbv ))
			break;

		if (( ret = CallProtoServiceInt( hContact, dbv.pszVal, szProtoService, i+1, ( LPARAM)&ccs )) != CALLSERVICE_NOTFOUND ) {
			//chain was started, exit
			mir_free( dbv.pszVal );
			return ret;
		}
		mir_free( dbv.pszVal );
	}
	if ( DBGetContactSettingString( hContact, "Protocol", "p", &dbv ))
		return 1;

	pa = Proto_GetAccount( dbv.pszVal );
	if ( pa == NULL || pa->ppro == NULL )
		ret = 1;
	else {
		if ( pa->bOldProto )
			ret = CallProtoServiceInt( hContact, dbv.pszVal, szProtoService, (WPARAM)(-1), ( LPARAM)&ccs );
		else
			ret = CallProtoServiceInt( hContact, dbv.pszVal, szProtoService, wParam, lParam );
		if ( ret == CALLSERVICE_NOTFOUND )
			ret = 1;
	}

	mir_free( dbv.pszVal );
	return ret;
}

/////////////////////////////////////////////////////////////////////////////////////////

static void InsertServiceListItem( int id, const char* szName )
{
	TServiceListItem* p = ( TServiceListItem* )mir_alloc( sizeof( TServiceListItem ));
	p->id = id;
	p->name = szName;
	serviceItems.insert( p );
}

int LoadProtocolsModule(void)
{
	bModuleInitialized = TRUE;

	if ( LoadProtoChains() )
		return 1;

	InsertServiceListItem(  1, PS_ADDTOLIST );
	InsertServiceListItem(  2, PS_ADDTOLISTBYEVENT );
	InsertServiceListItem(  3, PS_AUTHALLOW );
	InsertServiceListItem(  4, PS_AUTHDENY );
	InsertServiceListItem(  5, PSR_AUTH );
	InsertServiceListItem(  6, PSS_AUTHREQUEST );
	InsertServiceListItem(  7, PS_CHANGEINFO );
	InsertServiceListItem(  8, PSS_FILEALLOW );
	InsertServiceListItem(  9, PSS_FILECANCEL );
	InsertServiceListItem( 10, PSS_FILEDENY );
	InsertServiceListItem( 11, PS_FILERESUME );
	InsertServiceListItem( 12, PS_GETCAPS );
	InsertServiceListItem( 13, PS_LOADICON );
	InsertServiceListItem( 14, PSS_GETINFO );
	InsertServiceListItem( 15, PS_BASICSEARCH );
	InsertServiceListItem( 16, PS_SEARCHBYEMAIL );
	InsertServiceListItem( 17, PS_SEARCHBYNAME );
	InsertServiceListItem( 18, PS_SEARCHBYADVANCED );
	InsertServiceListItem( 19, PS_CREATEADVSEARCHUI );
	InsertServiceListItem( 20, PSR_CONTACTS );
	InsertServiceListItem( 21, PSR_FILE );
	InsertServiceListItem( 22, PSR_MESSAGE );
	InsertServiceListItem( 23, PSR_URL );
	InsertServiceListItem( 24, PSS_CONTACTS );
	InsertServiceListItem( 25, PSS_FILE );
	InsertServiceListItem( 26, PSS_MESSAGE );
	InsertServiceListItem( 27, PSS_URL );
	InsertServiceListItem( 28, PSS_SETAPPARENTMODE );
	InsertServiceListItem( 29, PS_SETSTATUS );
	InsertServiceListItem( 30, PSS_GETAWAYMSG );
	InsertServiceListItem( 31, PSR_AWAYMSG );
	InsertServiceListItem( 32, PSS_AWAYMSG );
	InsertServiceListItem( 33, PS_SETAWAYMSG );
	InsertServiceListItem( 34, PSS_USERISTYPING );
	InsertServiceListItem( 35, PS_GETNAME );
	InsertServiceListItem( 36, PS_GETSTATUS );


	InsertServiceListItem( 100, PS_SETAWAYMSGW );
	InsertServiceListItem( 102, PSS_FILEW );
	InsertServiceListItem( 103, PSS_FILEALLOWW );
	InsertServiceListItem( 104, PSS_FILEDENYW );
	InsertServiceListItem( 105, PS_FILERESUMEW );
	InsertServiceListItem( 106, PSS_AUTHREQUESTW );
	InsertServiceListItem( 107, PS_AUTHDENYW );
	InsertServiceListItem( 108, PS_BASICSEARCHW );
	InsertServiceListItem( 109, PS_SEARCHBYNAMEW );
	InsertServiceListItem( 110, PS_SEARCHBYEMAILW );


	hAckEvent = CreateHookableEvent(ME_PROTO_ACK);
	hTypeEvent = CreateHookableEvent(ME_PROTO_CONTACTISTYPING);
	hAccListChanged = CreateHookableEvent(ME_PROTO_ACCLISTCHANGED);

	CreateServiceFunction( MS_PROTO_BROADCASTACK,     Proto_BroadcastAck     );
	CreateServiceFunction( MS_PROTO_ISPROTOCOLLOADED, srvProto_IsLoaded      );
	CreateServiceFunction( MS_PROTO_ENUMPROTOS,       Proto_EnumProtocols    );
	CreateServiceFunction( MS_PROTO_REGISTERMODULE,   Proto_RegisterModule   );
	CreateServiceFunction( MS_PROTO_SELFISTYPING,     Proto_SelfIsTyping     );
	CreateServiceFunction( MS_PROTO_CONTACTISTYPING,  Proto_ContactIsTyping  );

	CreateServiceFunction( MS_PROTO_RECVFILE,         Proto_RecvFile         );
	CreateServiceFunction( MS_PROTO_RECVFILET,        Proto_RecvFileT        );
	CreateServiceFunction( MS_PROTO_RECVMSG,          Proto_RecvMessage      );

	CreateServiceFunction( "Proto/EnumProtocols",     Proto_EnumAccounts     );
	CreateServiceFunction( MS_PROTO_ENUMACCOUNTS,     Proto_EnumAccounts     );
	CreateServiceFunction( MS_PROTO_GETACCOUNT,       srvProto_GetAccount    );

	CreateServiceFunction( MS_PROTO_ISACCOUNTENABLED, srvProto_IsAccountEnabled );
	CreateServiceFunction( MS_PROTO_ISACCOUNTLOCKED,  srvProto_IsAccountLocked );

	return LoadProtoOptions();
}

void UnloadProtocolsModule()
{
	int i;

	if ( !bModuleInitialized ) return;

	if ( hAckEvent ) {
		DestroyHookableEvent(hAckEvent);
		hAckEvent = NULL;
	}
	if ( hAccListChanged ) {
		DestroyHookableEvent(hAccListChanged);
		hAccListChanged = NULL;
	}

	if ( protos.getCount() ) {
		for ( i=0; i < protos.getCount(); i++ ) {
			mir_free( protos[i]->szName);
			mir_free( protos[i] );
		}
		protos.destroy();
	}

	for ( i=0; i < serviceItems.getCount(); i++ )
		mir_free( serviceItems[i] );
	serviceItems.destroy();
}

/////////////////////////////////////////////////////////////////////////////////////////

pfnUninitProto GetProtocolDestructor( char* szProto )
{
	int idx;	
	PROTOCOLDESCRIPTOR temp;
	temp.szName = szProto;
	if (( idx = protos.getIndex( &temp )) != -1 )
		return protos[idx]->fnUninit;

	return NULL;
}