/******************************************************************************
Filename   : rvmegacotermdigitmap.c
Description: Structures and functions to save digitmap information
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:1.9.01$
$Author: D.Elbert$
******************************************************************************/
#include "rvalloc.h"
#include "rvstring.h"
#include "rvwildcard.h"
#include "rvmap.h"
#include "rvmutex.h"

#include "rvmegacoobjects.h"
#include "rvmdm.h"
#include "rvmegacotermmgr.h"
#include "rvmegacoterm.h"
#include "rvmegacoerrors.h"
#include "rvmegacotermevent.h"

#define flipCurrentTimer(x)	 ((x)->digitMapCurTimer=((x)->digitMapCurTimer+1)%2)


#define RvMegacoDigitMapConstructCopy		rvMegacoDigitMapConstructCopy
#define RvMegacoDigitMapDestruct		    rvMegacoDigitMapDestruct

rvDefineMap(RvIString,RvMegacoDigitMap)

void rvMegacoDigitMapDBConstruct(RvMegacoDigitMapDB* db,RvAlloc* alloc) {
	rvMapConstruct(RvIString,RvMegacoDigitMap)(&db->maps,alloc);
	rvMutexConstruct(&db->mutex);
}

void rvMegacoDigitMapDBDestruct(RvMegacoDigitMapDB* db) {
	rvMapDestruct(&db->maps);
	rvMutexDestruct(&db->mutex);
}

void rvMegacoDigitMapDBCopy(RvMegacoDigitMapDB* dest,const RvMegacoDigitMapDB* src) {
	rvMapCopy(&dest->maps,&src->maps);		
}

static RvMegacoDigitMap* findLocalDigitMap(RvMegacoDigitMapDB* db,const RvString* id) {
	return (RvMegacoDigitMap*)rvMapGetValue(RvIString,RvMegacoDigitMap)(&db->maps,id);	
}

/* Get a local digitmap */
static const RvMegacoDigitMap* getLocalDigitMap(RvMegacoDigitMapDB* db,const RvString* id) {
	RvMegacoDigitMap* map;
	rvMutexLock(&db->mutex);
	map = findLocalDigitMap(db,id);
	rvMutexUnlock(&db->mutex);
	return map;
}

/* Will define or overwrite a local digitmap */
static void setLocalDigitMap(RvMegacoDigitMapDB* db,const RvString* id,const RvMegacoDigitMap* newMap) {
	RvMegacoDigitMap* map;
	rvMutexLock(&db->mutex);
	map = findLocalDigitMap(db,id);
	if(map==NULL) {
		rvMapSetValue(RvIString,RvMegacoDigitMap)(&db->maps,id,newMap);
	}
	else {
		rvMegacoDigitMapCopy(map,newMap);
	}
	rvMutexUnlock(&db->mutex);
	return;
}

static void deleteLocalDigitMap(RvMegacoDigitMapDB* db,const RvString* id) {
	rvMutexLock(&db->mutex);
	rvMapRemove(RvIString,RvMegacoDigitMap)(&db->maps,id);
	rvMutexUnlock(&db->mutex);
	return;
}

/* Look for the digtmap,first in the termination and then in the root termination */
RvBool setCurrentDigitMap(RvMegacoTerm* x,const RvString* id) {
	const RvMegacoDigitMap* map = getLocalDigitMap(&x->storedDigitMaps,id);
	if(map==NULL) {
		RvMegacoTerm* rootTerm = rvMegacoTermMgrGetRootTermination(x->context->termMgr);	
		map = getLocalDigitMap(&rootTerm->storedDigitMaps,id);
	}
	if(map!=NULL) {
		rvMegacoDigitMapCopy(&x->digitMap,map);
		return rvTrue;
	}
	return rvFalse;
}



/* Process the digitmap descriptor */
void rvMegacoTermProcessDigitMap(RvMegacoTerm * x,const RvMegacoDigitMapDescriptor * digitMapDescr,RvMegacoCommandReply * commReply) {
	RvBool isNameSet,isDigitMapSet;
	const RvMegacoDigitMap* map;

	if(!rvMegacoDigitMapDescriptorIsSet(digitMapDescr))
		return ; /* Nothing to process */

	isNameSet = (strlen(rvMegacoDigitMapDescriptorGetName(digitMapDescr))!=0);
	map = rvMegacoDigitMapDescriptorGetDigitMap(digitMapDescr);
	isDigitMapSet = rvMegacoDigitMapGetSize(map);

	/* Both set: define or redefine a digitmap */
	if(isNameSet && isDigitMapSet) 
		setLocalDigitMap(&x->storedDigitMaps,&digitMapDescr->name,map);

	/* Only name set: find and install map */
	else if(isNameSet) {
		deleteLocalDigitMap(&x->storedDigitMaps,&digitMapDescr->name);
	}

	return;
}

/* Timers */
static void digitMapTimerProcess(RvTimer* t, void* term) {
	RvMegacoTerm * x = (RvMegacoTerm *)term;

	/* Verify that is the correct timer,otherwise 
	   ignore */
	rvMutexLock(&x->mutex);
	if( rvTimerGetId(t) == rvTimerGetId(&x->digitMapTimer[x->digitMapCurTimer]) ) {
		rvMegacoTermDigitMapTimerProcess(x);
	}
	rvMutexUnlock(&x->mutex);
}

static void digitMapTimerStop(RvMegacoTerm* x) {
	rvMutexLock(&x->mutex);
	rvTimerStop(&x->digitMapTimer[x->digitMapCurTimer]);
	flipCurrentTimer(x);
	rvMutexUnlock(&x->mutex);
}

void rvMegacoTermDigitMapTimerRestart(RvMegacoTerm* x,RvMilliseconds time) {
	rvMutexLock(&x->mutex);
	rvTimerStop(&x->digitMapTimer[x->digitMapCurTimer]);
	flipCurrentTimer(x);
	rvTimerReset(&x->digitMapTimer[x->digitMapCurTimer],time);
	rvMutexUnlock(&x->mutex);
}

static void digitMapTimerStart(RvMegacoTerm* x,RvMilliseconds time) {
	rvMutexLock(&x->mutex);
	rvTimerReset(&x->digitMapTimer[x->digitMapCurTimer],time);
	rvMutexUnlock(&x->mutex);
}

void rvMegacoTermDigitMapTimerConstruct(RvMegacoTerm* x) {
	x->digitMapCurTimer = 0;
	rvTimerConstruct(&x->digitMapTimer[0],0,digitMapTimerProcess,x);
	rvTimerConstruct(&x->digitMapTimer[1],0,digitMapTimerProcess,x);
}

void rvMegacoTermDigitMapTimerDestruct(RvMegacoTerm* x) {
	rvTimerDestruct(&x->digitMapTimer[0]);
	rvTimerDestruct(&x->digitMapTimer[1]);
}

void rvMegacoTermDeactivateDigitMap(RvMegacoTerm * x) {
	/* Shouldn't usually be true,check for sanity*/
	if( x->digitMapActive == rvTrue) {
		digitMapTimerStop(x);
		x->digitMapActive = rvFalse;
	}
}

static void activateDigitMap(RvMegacoTerm * x) {
	int time = rvMegacoDigitMapGetStartTimeout(&x->digitMap)*1000;
	digitMapTimerStart(x,time);
	/* Set the flag */
	x->digitMapActive = rvTrue;
}

/* Install an active digitMap */
RvBool rvMegacoTermProcessDigitMapParameter(RvMegacoTerm * x,const RvMegacoRequestedEvent* reqEvent,
											RvMegacoCommandReply * commReply) {
	RvBool isNameSet,isDigitMapSet;
	const RvMegacoDigitMap* map;
	const RvMegacoDigitMapDescriptor * digitMapDescr;
	const RvMegacoPackageItem* name;
	RvMdmError error;

	rvMdmErrorConstruct_(&error);

	digitMapDescr = rvMegacoRequestedEventGetEmbDigitMap(reqEvent);
	name = rvMegacoRequestedEventGetName(reqEvent);

	if(!rvMegacoDigitMapDescriptorIsSet(digitMapDescr))
		return rvTrue; /* Nothing to process */

	rvMegacoTermDeactivateDigitMap(x);

	/* Initialize DigitMap state variables */
	rvStringResize(&x->dialString,0);
	/* If first timer expires with no digits, match is partial */
	x->digitMapStat = RV_MEGACODIGITMAP_PARTIALMATCH;
	x->digitMapMedia = NULL;
	x->digitMapReqEvent = reqEvent;

	/* Set the digitMap information */
	x->digitMapEC = rvMdmTermMgrGetDigitMapPkgInfo_(x->context->termMgr->mdmTermMgr,
													rvMegacoPackageItemGetPackage(name));
	if(x->digitMapEC==NULL) {
		rvMegacoTermSendErrorMsg(x,&error,RV_MEGACOERROR_NO_DIGITMAP,
									 "Media Gateway does not have a digit map",commReply);
		return rvFalse;
	}

	isNameSet = (strlen(rvMegacoDigitMapDescriptorGetName(digitMapDescr))!=0);
	map = rvMegacoDigitMapDescriptorGetDigitMap(digitMapDescr);
	isDigitMapSet = rvMegacoDigitMapGetSize(map);

	/* Assume that name and map are not both set. First try map, then name */
	if( isDigitMapSet ) {
		rvMegacoDigitMapCopy(&x->digitMap,rvMegacoDigitMapDescriptorGetDigitMap(digitMapDescr));		
	}

	/* Only name set: find and install map */
	else if(isNameSet) {
		if( !setCurrentDigitMap(x,&digitMapDescr->name) ) {
			rvMegacoTermSendErrorMsg(x,&error,RV_MEGACOERROR_NO_DIGITMAP,
									 "Media Gateway does not have a digit map",commReply);
			return rvFalse;
		}
	}

	activateDigitMap(x);

	return rvTrue;
}