/*
 *+------------------------------------------------------------------------+
 *| IBM Confidential
 *| OCO Source Materials
 *| BI and PM: viewer
 *| (C) Copyright IBM Corp. 2001, 2009
 *|
 *| US Government Users Restricted Rights - Use, duplication or
 *| disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 *|
 *+------------------------------------------------------------------------+
 */

/**
CCDManager -- Report Viewer class which manages Context Data supplied by RSVP in JSON format
*/

// Constructor
function CCDManager(cv) {
	this.m_cd = null;
	this.m_md = null;
	this.m_oCV = null;
};


// Set functions
CCDManager.prototype.SetContextData = function(CD) {
	if (this.m_cd)
	{
		this.m_cd = null;
	}

	this.m_cd = CD;
};

CCDManager.prototype.SetMetadata = function(MD) {
	if (this.m_md)
	{
		this.m_md = null;
	}

	this.m_md = MD;
};

CCDManager.prototype.AddContextData = function(CD) {
	if (!this.m_cd) {
		this.m_cd = CD;
	} else {
		// Add additional context data
		for (var i in CD) {
			this.m_cd[i] = CD[i];
		}
	}
};

CCDManager.prototype.AddMetadata = function(MD) {
	if (!this.m_md) {
		this.m_md = MD;
	} else {
		// Add additional metadata
		for (var j in MD) {
			this.m_md[j] = MD[j];
		}
	}
};


CCDManager.prototype.SetCognosViewer = function(viewer) {
	if (viewer) {
		this.m_oCV = viewer;
	}
};

CCDManager.prototype.ProcessGetCDRequest = function(xmlResponse) {
	if (xmlResponse) {
		var allBlocks = xmlResponse.getElementsByTagName("Block");
		for (var i = 0; i < allBlocks.length; i++)	{
			var sContext = "";
			var blockNode = allBlocks[i].firstChild;
			while(blockNode)
			{
				sContext += blockNode.nodeValue;
				blockNode = blockNode.nextSibling;
			}

			var cd = eval('('+ sContext +')');
			this.AddContextData(cd);
		}

		if (typeof g_firefoxPluginHelper != "undefined" && g_firefoxPluginHelper != null)
		{
			g_firefoxPluginHelper.addDebugLogsFromResponseXML(xmlResponse);
		}
	}
};

CCDManager.prototype.FetchContextData = function(ctxids) {
	var missingCtxids = [];
	for (var i = 0; i < ctxids.length; ++i ) {
		if (ctxids[i] != "" && !this.ContextIdExists(ctxids[i])) {
			missingCtxids.push(ctxids[i]);
		}
	}
	var xmlResponse = null;
	if (missingCtxids.length) {
		if (this.m_oCV) {
			xmlResponse = this.getContextData(missingCtxids);
			if (xmlResponse) {
				this.ProcessGetCDRequest(xmlResponse);
			}
		}
	}
};

CCDManager.prototype.getContextData = function(ctxids)
{
	var oCV = this.m_oCV;
	if (oCV.m_oServerRequest.m_request != null || oCV.getStatus() == "working" || oCV.getStatus() == "stillWorking")
	{
		return null;
	}

	var form = document["formWarpRequest" + oCV.getId()];
	var conversation = oCV.getConversation();

	var tracking = oCV.getTracking();
	if (!tracking && form && form["m_tracking"] && form["m_tracking"].value) {
		tracking = form["m_tracking"].value;
	}

	var params = ["b_action=cognosViewer"];
	if (conversation) {
		params.push("ui.action=getContext");
		params.push("ui.conversation=" + conversation);
	} else {
		params.push("ui.object=" + form["ui.object"].value);
		params.push("ui.action=getObjectContext");
	}
	params.push("cv.responseFormat=asynchDetailContext");
	params.push("context.format=initializer");
	params.push("context.type=reportService");
	params.push("context.selection=" + ctxids.join(','));
	params.push("cv.catchLogOnFault=true");
	params.push("cv.id=" + oCV.getId());
	if (oCV.envParams["ui.routingServerGroup"] != null)
	{
		params.push("ui.routingServerGroup=" + oCV.envParams["ui.routingServerGroup"]);
	}

	if (tracking) {
		params.push("m_tracking=" + tracking);
	}


	//TODO: This is a new function call added (perhaps temporarily) to support things like:
	//		1. Synchronous XmlHttp calls
	//		2. Modified callbacks.
	// This should eventually all go through: CCognosViewerRequest
	var httpRequest = new XmlHttpObject();
	httpRequest.sendHtmlRequest("POST", oCV.getGateway(), params.join('&'), false);
	var response = httpRequest.getResponseXml();

	oCV["LAST_ACTION"] = "getContextData";
	oCV["LAST_ACTION_PARAMS"] = {"param1": ctxids};

	if (response)
	{
		if (processAuthenticationFault(response))
		{
			return null;
		}
		else if (tracking == "" &&  !conversation)
		{
			// This is an initial request - get the tracking and conversation for use in subsequent requests
			var trackingElements = response.getElementsByTagName("tracking");
			if (trackingElements.length == 1)
			{
				oCV.setTracking(trackingElements[0].firstChild.nodeValue);
			}
			var conversationElements = response.getElementsByTagName("conversation");
			if (conversationElements.length ==1 && conversationElements[0].firstChild)
			{
				oCV.setConversation(conversationElements[0].firstChild.nodeValue);
			}
		}
		clearLastAction();
	}
	else
	{
		clearLastAction();
		return null;
		// To do: Handle error condition
//		alert("Error in getContextData - HTTP Status:" + httpRequest.getStatus());
	}

	return response;
};

// Existential Tests
CCDManager.prototype.ContextIdExists = function(ctxid) {
	return (this.m_cd[ctxid]?true:false);
};

CCDManager.prototype.HasContextData = function() {
	return (this.m_cd ? true:false);
};

CCDManager.prototype.HasMetadata = function() {
	return (this.m_md ? true:false);
};


// Access Functions
// Properties Derived from Reference Data Item
CCDManager.prototype.GetDrillFlag = function(ctxid) {
	var drillFlag = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		drillFlag = this.m_md[this.m_cd[ctxid].r].drill;
	}
	return drillFlag;
};

CCDManager.prototype.GetDrillFlagForMember = function(ctxid) {
	// Return the correct drill flag for members only
	var drillFlag = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r] && this.m_cd[ctxid].m) {
		drillFlag = this.m_md[this.m_cd[ctxid].r].drill;
	}
	return drillFlag;
};

CCDManager.prototype.GetDataType = function(ctxid) {
	var dtype = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		dtype = this.m_md[this.m_cd[ctxid].r].dtype;
	}
	return dtype;
};

CCDManager.prototype.GetUsage = function(ctxid) {
	var usage = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		usage = this.m_md[this.m_cd[ctxid].r].usage;
	}
	return usage;
};

CCDManager.prototype.GetHUN = function(ctxid) {
	var hun = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		if (this.m_md[this.m_cd[ctxid].r].h) {
			hun = this.m_md[this.m_md[this.m_cd[ctxid].r].h].h;
		}
	}
	return hun;
};

CCDManager.prototype.GetQuery = function(ctxid) {
	var qry = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		qry = this.m_md[this.m_md[this.m_cd[ctxid].r].q].q;
	}
	return qry;
};

CCDManager.prototype.GetDepth = function(ctxid) {
	var depth = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r].level) {
		depth = this.m_md[this.m_cd[ctxid].r].level;
	}
	return depth;
};


//Properties Derived from Context Data
CCDManager.prototype.GetDisplayValue = function(ctxid) {
	var useVal = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_cd[ctxid]) {
		useVal = this.m_cd[ctxid].u;
	}
	return useVal;
};

CCDManager.prototype.GetPUN = function(ctxid) {
	var pun = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].p]) {
		pun = this.m_md[this.m_cd[ctxid].p].p;
	}
	return pun;
};

CCDManager.prototype.GetLUN = function(ctxid) {
	var lun = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].l]) {
		lun = this.m_md[this.m_cd[ctxid].l].l;
	}
	return lun;
};

CCDManager.prototype.GetMUN = function(ctxid) {
	var mun = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].m]) {
		mun = this.m_md[this.m_cd[ctxid].m].m;
	}
	return mun;
};

CCDManager.prototype.GetDUN = function(ctxid) {
	var dun = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].d]) {
		dun = this.m_md[this.m_cd[ctxid].d].d;
	}
	return dun;
};

CCDManager.prototype.GetQMID = function(ctxid) {
	var qmid = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].i]) {
		qmid = this.m_md[this.m_cd[ctxid].i].i;
	}
	return qmid;
};

CCDManager.prototype.GetRDIValue = function(ctxid) {
	var rdi = null;
	this.FetchContextData([ctxid]);
	if (this.ContextIdExists(ctxid) && this.m_md[this.m_cd[ctxid].r]) {
		rdi = this.m_md[this.m_cd[ctxid].r].r;
	}
	return rdi;
};

CCDManager.prototype.getContextIdForMetaData = function(lun, hun)
{
	var metaArray = new Array({"expression":lun, "type":"l"},{"expression":hun, "type":"h"});

	for(var index = 0; index < metaArray.length; ++index)
	{
		var sMetaItem = metaArray[index].expression;
		var sType = metaArray[index].type;

		if(sMetaItem == "")
		{
			continue;
		}

		var sMetaItemKey = "";
		for(metaDataItem in this.m_md)
		{
			if(this.m_md[metaDataItem][sType] == sMetaItem)
			{
				var sRefDataItem = "";
				for(refDataItem in this.m_md)
				{
					if(this.m_md[refDataItem].r && this.m_md[refDataItem][sType] == metaDataItem)
					{
						if(this.m_md[refDataItem].drill != 0)
						{
							for(ctx in this.m_cd)
							{
								if(this.m_cd[ctx].r == refDataItem && this.m_cd[ctx].m)
								{
									return ctx;
								}
							}
						}
					}
				}
			}
		}
	}

	return "";
};

// Get Context id given a MUN - these methods assume that the context ids are available.
CCDManager.prototype.GetContextIdForMUN = function(mun) {
	var mdIndex = null;
	var ctxid = null;
	// Find the mun in the metadata
	for (var i in this.m_md) {
		if (this.m_md[i].m == mun) {
			mdIndex = i;
			break;
		}
	}
	if (mdIndex != null) {
		for (var j in this.m_cd) {
			if (this.m_cd[j].m == mdIndex) {
				ctxid = j;
				break;
			}
		}
	}
	return ctxid;
};

// Get Context id given a display value
CCDManager.prototype.GetContextIdForDisplayValue = function(value) {
	var ctxid = null;
	for (var i in this.m_cd) {
		if (this.m_cd[i].u == value) {
			ctxid = i;
			break;
		}
	}
	return ctxid;
};

// Get Context id given a use value
CCDManager.prototype.GetContextIdForUseValue = function(value) {
	var mdIndex = null;
	var mdValueType = null;
	var ctxid = null;
	// Find the value in the metadata
	for (var i in this.m_md) {
		var md = this.m_md[i];
		for (var j in md) {
			if (md[j] == value) {
				mdIndex = i;
				mdValueType = j;
				break;
			}
		}
	}

	if (mdIndex != null) {
		for (var k in this.m_cd) {
			if (this.m_cd[k][mdValueType] == mdIndex) {
				ctxid = k;
				break;
			}
		}
	}
	return ctxid;
};