// reports.js
// Javascript to display report web pages.
// Called from reports.html
// usage...
// reports.html?FN=datatype&BA=showbasins&YE=year&ME=month&DE=day&HE=hour-minute-second
// or
// reports.html?FN=datatype&BA=showbasins&TE=year-month-day-hour-minute-second
// where:
// datatype is the type of data to display on the report (e.g. rain)
//  If the data type is not provided, the default data type is read from
//  reports.xml as //defaults/report/type
// showbasins is "yes" to display site data by basin.
//            is "no" to display site data without basins.
//  If showbasins is not provided, the default is read from
//  reports.xml as //defaults/showbasins
// YE,ME,DE,HE and TE define a historic date and time for data display
//  If they are not provided, the current data is displayed.

// Set page location and XSL file name
var strPathname = strRoot + "reports.html";
var strXSLname = strRoot + strXSLfolder + "reports.xsl";
var strPageTitle = "Data Reports";

// Define search command arguments
var strShowBasins;
var strDataType;
var strTimeArg,strTimeDisplay,strYear,strMonth,strDay,strHour,strMinute,strSecond;

// Set default select and sort parameters
var strSortSelect;
var strSortDataType;
var strSortOrder;
var strSortSelectDefault = "@nosort";
var strSortDataTypeDefault = "number";
var strSortOrderDefault = "ascending";
var clearStatusAfterLoadWait = 2000;	// Clear status after this delay in milliseconds

// Parameters set by report selection
var strTitle;
var bTitleDisplayed = false;
var timeout_id;
var nReloadMilliseconds = 0;

// Parameters set by data file selection
var strDateTime = "";

// XML data sets
var objXMLdata = null;
var objXMLsitedata = null;
var objXMLsites = null;
var objXMLreports = null;
var objXMLintervals = null;
var objXSLreports = null;

// Set report data type selected from list
function changeReportDataType()
{
  // Clear timer
	clearReloadTimer();

  // Get report data type index to display, return if index is 0
  var objSelect = document.getElementById("selectReportType");
  var nIndex = objSelect.selectedIndex;

  // Set report data type to display from list value
  strDataType = objSelect.options[nIndex].value;

  // Save the data type in a cookie
  set_cookie("DataType", strDataType);

  // Reset report for data type change then re-display report data
	displayReport(true);
  return;
}

// Set basin sort select sites in basins
function sortBasins()
{
  // Clear timer
	clearReloadTimer();

  // Get basin display selection, return if index is 0
  var objSelect = document.getElementById("selectBasins");
  var nIndex = objSelect.selectedIndex;

  // Set basin display from list value
  strShowBasins = objSelect.options[nIndex].value;

  // Save the data type in a cookie
  set_cookie("ShowBasins", strShowBasins);

  // Get the report node that defines what is displayed
  var strQuery = "/*/report";
  var objReportNode = objXMLsites.selectSingleNode(strQuery);
  objReportNode.setAttribute("showbasins",strShowBasins);

  // Re-display report data with new show basin state
	displayReport(false);
  return;
}

// Reverse sort order from ascending to descending
function reverseSortOrder()
{
  if(strSortOrder == "ascending")
    strSortOrder = "descending";
  else
    strSortOrder = "ascending";
}

// Set sort selection, reverse sort order if same sort,
// set sort data type, then transform report
function sortReport(sortSelect, sortDataType)
{
  // Clear timer
	clearReloadTimer();

  // If already using sorting selection then reverse sort order
  if(strSortSelect == sortSelect)
    reverseSortOrder();
  // Otherwise set sort selection
  else
    strSortSelect = sortSelect;

  // Set sort data type
  strSortDataType = sortDataType;

  // Save the sort parameters in cookies
  set_cookie("SortSelect", escape(strSortSelect));
  set_cookie("SortDataType", escape(strSortDataType));
  set_cookie("SortOrder", escape(strSortOrder));

  // Get the report node that defines what is displayed
  var strQuery = "/*/report";
  var objDisplay = objXMLsites.selectSingleNode(strQuery);

  // Re-display report data with new sort
	displayReport(false);
	return;
}

// Load the XML documents for the report display
function prepXMLreports()
{
  var strQuery;
  var objNode;
  // Get the report default data type if not defined
  if ( strDataType == "" )
  {
    strQuery = "/reports/defaults/datatype";
    objNode = objXMLreports.selectSingleNode(strQuery);
    if ( objNode ) strDataType = objNode.firstChild.nodeValue;
  }

  // Get the report default show basins if not defined
  if ( strShowBasins == "" )
  {
    strQuery = "/reports/defaults/showbasins";
    objNode = objXMLreports.selectSingleNode(strQuery);
    if ( objNode ) strShowBasins = objNode.firstChild.nodeValue;
  }

  // Get the reports tooltip and status
  strQuery = "//defaults/tooltip";
  load_tooltip(objXMLreports,strQuery);

  // Get the report reload interval if defined
  strQuery = "/reports/@reload";
  objNode = objXMLreports.selectSingleNode(strQuery);
  if ( objNode != null ) {
    nReloadMilliseconds = objNode.firstChild.nodeValue * 1000;
	}
}

// Merge XML documents for data type
function makeXMLreportnodes()
{
  // Remove report node if already defined.
  var strQuery = "/*/report";
  var objNode = objXMLsites.selectSingleNode(strQuery);
	if(objNode) {
		try {
			objXMLsites.selectSingleNode("/sites").removeChild(objNode);
		} catch(e) { 
			//alert(e);
			return;
		}
	}

  // Create a report node in the XML document
  var objReportNode = objXMLsites.documentElement.appendChild(objXMLsites.createElement("report"));

  // Make the report data type query
  var strQueryDataType = "/reports/datatypes/datatype[@type = '" + strDataType + "']";

  // Get the report title for the report data type selected
  strQuery = strQueryDataType + "/title/name";
  objNode = objXMLreports.selectSingleNode(strQuery);
  if ( objNode != null ) strTitle = objNode.firstChild.nodeValue;

  // Append the report data type intervals to report node
  strQuery = strQueryDataType + "/interval";
  objNode = objXMLreports.selectSingleNode(strQuery);
  if ( objNode )
  {
    strIntervalType = objNode.firstChild.nodeValue;
    strQuery = "/datatypeintervals/intervals[@type = '" + strIntervalType + "']";
    objNodeList = objXMLintervals.selectNodes(strQuery);
    appendDocumentNodeList(objReportNode,objNodeList);
  }

  // Set data type attribute in report node
  objReportNode.setAttribute("type",strDataType);

  // Set showbasins attribute in report node
  objReportNode.setAttribute("showbasins",strShowBasins);

  // Append site data date and time to report node
  objReportNode.setAttribute("datetime",strDateTime);

  // Set time arguments in report node
  objReportNode.setAttribute("historictime",strTimeArg);
}

// Transform and display the report data using the XSL file
// Arguments: objXML - XML DOM Document for data and report
//            objDisplay - XML Node to select type of display
//             is set to "data" to display report data
function transformData(objXML,objDisplay,strDisplay,strHtmlID)
{
  // Return if the XSL document is not loaded
  if ( objXSLreports == null ) return false;

  // Get the XSL sort objects and set the sort select, data-type, and order
  if ( strDisplay == "data" )
  {
		var objNode;
    var objSort = objXSLreports.selectNodes("//xsl:sort");
		var nodeIndex = -1;
    while ( (objNode = nextNode(objSort,++nodeIndex)) != null )
    {
      objNode.setAttribute("select",strSortSelect);
      objNode.setAttribute("data-type",strSortDataType);
      objNode.setAttribute("order",strSortOrder);
    }
  }

  // Set the display attribute
  objDisplay.setAttribute("display",strDisplay);

  // Replace the DisplayData object with the XML transformation
  var objHtml = document.getElementById(strHtmlID);
  transformNode(objXML,objXSLreports,objHtml);

  // Return display success
  return true;
}

// Transform and display the report
// Argument bDisplayTitle:
//    true displays the title and data
//    false displays the data only
function displayReport(bDisplayTitle)
{
	//  Redisplay data if defined.
	if(objXMLdata) {

		// Get the report node that defines what is displayed
		var strQuery = "/*/report";
		var objDisplay = null;

    // Display the title once
    if ( bDisplayTitle == true || bTitleDisplayed == false )
    {
	    // Set data type report node elements
	    makeXMLreportnodes();

			// Get the report node that defines what is displayed.
			objDisplay = objXMLdata.selectSingleNode(strQuery);

      // Set the window title
      document.title = strSystemTitle + " " + strTitle;

      // Display the report title
      bTitleDisplayed = transformData(objXMLdata,objDisplay,'title','DisplayTitle');

    } else {
			// Get the report node that defines what is displayed.
			objDisplay = objXMLdata.selectSingleNode(strQuery);
		}

		// Always display report data
		transformData(objXMLdata,objDisplay,'data','DisplayData');
	}

  // Check for active alarms
  checkAlarms();

	// Clear loading status after two seconds
	timeout_id = setTimeout("clearStatusAfterLoad()", clearStatusAfterLoadWait);

  return true;
}

// Set reload timer
function startReloadTimer()
{
  // Set data reload timer if current data displayed
  if ( strTimeDisplay == "" && nReloadMilliseconds > 0 )
    timeout_id = setTimeout("reloadData()", nReloadMilliseconds);
  return true;
}

function clearReloadTimer() {
  // Clear timer
	if(timeout_id != null) {
	  clearTimeout(timeout_id);
		timeout_id = null;
	}
}

// Clear the status line then reload timer
function clearStatusAfterLoad()
{
	// Clear status line
  clearStatus();

	// Reload timer
	if(nReloadMilliseconds > 0) {
		var nWait = nReloadMilliseconds - clearStatusAfterLoadWait;
		if(nWait < 0) nWait = nReloadMilliseconds;
		startReloadTimer(nWait);
	}
  return true;
}

// Reload the data on the page
function reloadData()
{
  // Clear timer
	clearReloadTimer();

	// Reload xml documents and display report.
	loadXMLreports();
}

// Reset report parameters
function resetParameters()
{
  // Clear timer
	clearReloadTimer();

	// Reset parameters to force default use.
  delete_cookie("DataType"); strDataType = "";
  delete_cookie("ShowBasins"); strShowBasins = "";
  delete_cookie("SortSelect"); strSortSelect = strSortSelectDefault;
  delete_cookie("SortDataType"); strSortDataType = strSortDataTypeDefault;
  delete_cookie("SortOrder"); strSortOrder = strSortOrderDefault;

	// Reload xml documents and display report.
	loadXMLreports();
}

// Read parameters from cookies if not defined
function readParametersFromCookies()
{
  // Get the data type from cookie, set default if not defined
  if ( strDataType == "" ) strDataType = get_cookie("DataType");
  if ( strDataType == null ) strDataType = "";

  // Get the show basins from cookie, set default if not defined
  if ( strShowBasins == "" ) strShowBasins = get_cookie("ShowBasins");
  if ( strShowBasins == null ) strShowBasins = "";

  // Get the sort parameters from cookies
  // Set to default if not defined
  strSortSelect = get_cookie("SortSelect");
  if ( strSortSelect == null )
    strSortSelect = strSortSelectDefault;
  strSortDataType = get_cookie("SortDataType");
  if ( strSortDataType != "number" && strSortDataType != "text" )
    strSortDataType = strSortDataTypeDefault;
  strSortOrder = get_cookie("SortOrder");
  if ( strSortOrder != "ascending" && strSortOrder != "descending" )
    strSortOrder = strSortOrderDefault;
}

// This function is called when the HTML page is loaded.
// Get the search command arguments and display table.
function preparePage()
{
  // Initialize command arguments
  strDataType = "";
  strShowBasins = "";
  strTimeArg = "";
  strTimeDisplay = "";
  strYear = "";
  strMonth = "";
  strDay = "";
  strHour = "";
  strMinute = "";
  strSecond = "";

  // Set default page reload timer
  nReloadMilliseconds = ((nReloadMinutes * 60) + nReloadSeconds) * 1000;

	// Define selectNodes for firefox.
	selectSingleNodeDefine();

  // Check for command arguments
  bReload = false;
  if ( location.search.length != 0)
  {
    args = location.search.substring(1);
    var args_array = args.split("&");
    for ( var cnt=0; cnt<args_array.length; cnt++)
    {
      var arg = args_array[cnt];
      var arg_array = arg.split("=");
      if(arg_array.length == 2 && arg_array[1].length > 0)
      {
        // Translate escape characters in the string argument
        strArg = arg_array[1];
        strArg = unescape(strArg);

        // Check for report data type selection
        if(arg_array[0] == "FN")
        {
          strDataType = strArg;
          set_cookie("DataType", strDataType);
          bReload = true;
        }

        // Check for basin display selection
        if(arg_array[0] == "BA")
        {
          strShowBasins = strArg;
          set_cookie("ShowBasins", strShowBasins);
          bReload = true;
        }

        // Check for time of report selection
        if(arg_array[0] == "TE")
        {
          strYear = getDateTimeYear(strArg);
          strMonth = getDateTimeMonth(strArg);
          strDay = getDateTimeDay(strArg);
          strHour = getDateTimeHour(strArg);
          strMinute = getDateTimeMinute(strArg);
          strSecond = getDateTimeSecond(strArg);
        }
        if(arg_array[0] == "YE")
          strYear = strArg;
        if(arg_array[0] == "ME")
          strMonth = strArg;
        if(arg_array[0] == "DE")
          strDay = strArg;
        if(arg_array[0] == "HE")
        {
          strHour = getTimeHour(strArg);
          strMinute = getTimeMinute(strArg);
          strSecond = getTimeSecond(strArg);
        }
      }
    }

    // Set data file path if time of report selected
    if ( strYear != "" )
    {
      endDate = new Date(strYear,eval(strMonth)-1,strDay,strHour,strMinute,strSecond);
      strTimeArg = makeDateTimeArg(endDate);
      strTimeDisplay = makeDateTimeDisplay(endDate);
    }
  }

  // Reload the page without command arguments
  // This allows return from link to use cookies
  // to set report display parameters
  if ( bReload == true )
  {
    action = strPathname;
    if ( strTimeArg != "" )
      action += "?TE=" + strTimeArg;
    location.replace(action);
  }

  // Create cross browser array
  create_object_array();

  // "Define" event for older browsers
  if (!dhtml_ok) event = null;

  // Read parameters from cookies if not defined
  readParametersFromCookies();

	// Load the XML documents and display report
	loadXMLreports();
}

// Load the XML documents for the report display
function loadXMLreports()
{
  // Load XML sites document
  if(objXMLsites) delete objXMLsites;
  loadDOMDocument(getXMLPathName(strXMLsitesName),false,loadXMLreports1);
}
function loadXMLreports1(objDoc)
{
  // Save XML document
	if(objDoc == null) return;
	objXMLsites = objDoc;

  // Load XML reports document
  if(objXMLreports) delete objXMLreports;
  loadDOMDocument(getXMLPathName(strXMLreportsName),false,loadXMLreports2);
}
function loadXMLreports2(objDoc)
{
  // Save XML document
	if(objDoc == null) return;
	objXMLreports = objDoc;

	// Prepare report xml documents.
	prepXMLreports();

  // Append the reports document to the working document
  // This allows the report specific document defaults to be found first
  var objNodeList = objXMLreports.selectNodes("/reports");
  appendDocumentNodeList(objXMLsites.documentElement,objNodeList);

  // Load XML intervals document
  if(objXMLintervals) delete objXMLintervals;
  loadDOMDocument(getXMLPathName(strXMLintervalsName),false,loadXMLreports3);
}
function loadXMLreports3(objDoc)
{
  // Save XML document
	if(objDoc == null) return;
	objXMLintervals = objDoc;

  // Load XSL reports document
  if(objXSLreports) delete objXSLreports;
  loadDOMDocument(strXSLname,false,loadXMLreports4);
}
var strXMLPathName;
function loadXMLreports4(objDoc)
{
  // Save XSL document
	if(objDoc == null) return;
	objXSLreports = objDoc;

  // Construct the XML data document historic path name 
  // if the time argument is set
  if ( strTimeDisplay != "" )
    strXMLPathName = getHistoricXMLDataFileName(strYear, strMonth, strDay, strHour, strMinute, strSecond);

  // Otherwise use the current data file path name
  else
    strXMLPathName = getCurrentXMLDataFileName();

  // Load the XML data document
  if(objXMLsitedata) delete objXMLsitedata;
  loadDOMDocument(strXMLPathName,true,loadXMLreports5);
}
function loadXMLreports5(objDoc)
{
  // Save XML data document
	objXMLsitedata = objDoc;
	objXMLdata = null;
  if(objDoc == null) return;

	// Get site data date and time to append later to report node
	var strQuery = "/sitedata/@datetime";
	var objNode = objXMLsitedata.selectSingleNode(strQuery);
	if ( objNode != null ) strDateTime = objNode.firstChild.nodeValue;

  // Merge site data into sites XML document
  mergeSiteData(objXMLsites,objXMLsitedata);

	// Set xml data set.
	objXMLdata = objXMLsites;

  // Display the table
  displayReport(true);
}