/// <reference path="LaunchNetClientBase.js"/>
/// <reference path="BrowserServices.js"/>
/// <reference path="ErrorServices.js"/>
/// <reference path="ClientProxyServices.js"/>
/// <reference path="LaunchNetClientContext.js"/>

/* ***********************************************************************************
-  Event Subscription Methods
************************************************************************************ */

function AddPageLoadSubscriber(nameOfFunctionToSubscribe)
{
  if (nameOfFunctionToSubscribe.length > 0)
  {
    if (__pageLoadEventSubscribers.length > 0)
    {
      __pageLoadEventSubscribers = __pageLoadEventSubscribers + '|';
    }
    __pageLoadEventSubscribers = __pageLoadEventSubscribers + nameOfFunctionToSubscribe;
  }
}

function AddPageClickSubscriber(nameOfFunctionToSubscribe)
{
  if (nameOfFunctionToSubscribe.length > 0)
  {
    if (__pageClickEventSubscribers.length > 0)
    {
      __pageClickEventSubscribers = __pageClickEventSubscribers + '|';
    }
    __pageClickEventSubscribers = __pageClickEventSubscribers + nameOfFunctionToSubscribe;
  }
}


/* ***********************************************************************************
-  Page Load Event
************************************************************************************ */


function OnPageLoad()
{
  if (typeof OnPageLoad_DebugTieIn != "undefined")
  {
    //allow developers to tie in debugger through visual studio
    OnPageLoad_DebugTieIn();
  }
  
  //create various services
  var clientProxyServices = new ClientProxyServices();
  var errorServices = new ErrorServices();

  //create LaunchNetClientContext using services
  __context = new LaunchNetClientContext(clientProxyServices, errorServices);
  
  if(!__context.IsSessionAlive())
  {
    __context.ExpireSite(null);
    return;
  }

  //alert services of page load event
  OnPageLoad_Services();

  //alert any page load event subscribers
  OnPageLoad_Subscribers();
}

function OnPageLoad_Services()
{
  var serviceProviderArray = __context.GetServiceProviders();
  for (var i = 0; i < serviceProviderArray.length; i++)
  {
    OnPageLoad_Service(serviceProviderArray[i]);
  }
}

function OnPageLoad_Service(service)
{
  //only call functions that exist; this allows for developers to be lazy
  //which is good, since they all are
  if (eval('typeof(' + service + ');') != 'undefined')
  {
    eval('var serviceProvider = new ' + service + '();');
    if (typeof(serviceProvider.OnPageLoad) != 'undefined')
    {
      serviceProvider.OnPageLoad();
    }
  }
}

function OnPageLoad_Subscribers()
{
  if (__pageLoadEventSubscribers.length > 0)
  {
    var pageLoadEventSubscriberArray = __pageLoadEventSubscribers.split('|');
    for (var i = 0; i < pageLoadEventSubscriberArray.length; i++)
    {
      eval(pageLoadEventSubscriberArray[i] + '();');
    }
  }
}

/* ***********************************************************************************
-  Page Click Event
************************************************************************************ */

function OnPageClick(currentEvent,thisObj)	  
{
  if (typeof OnPageClick_DebugTieIn != "undefined")
  {
    //allow developers to tie in debugger through visual studio
    OnPageClick_DebugTieIn();
  }

//  if (!handlingPageClick && !pageSubmitted)
//  {
//    handlingPageClick = true;
  
    if(!__context.IsSessionAlive())
    {
//      handlingPageClick = false;
      __context.ExpireSite(null);
      return;
    }

    //get the event clicked
    var clickedElementId = __context.GetBrowserServices().GetEventId(currentEvent);
    if (clickedElementId == null || clickedElementId.length < 1)
    {
      //no id on the element clicked; do nothing
      return;
    }
    //turn clicked element id into a LaunchNetElement
    var launchNetElementClicked = new LaunchNetElement(clickedElementId);
    //perform validation if required
    var pageValid = DoValidationIfRequired(currentEvent, launchNetElementClicked);
    //if validation failed, normal browser events will have been cancelled

    //alert services of page click event
    OnPageClick_Services(launchNetElementClicked, pageValid);

    //alert any page click event subscribers
    OnPageClick_Subscribers(launchNetElementClicked, pageValid);

//    pageSubmitted = true;
//    handlingPageClick = false;
//  }
//  else
//  {
//    __context.GetBrowserServices().CancelEvent(currentEvent); 
//  }
}

function OnPageClick_Services(launchNetElementClicked, pageValid)
{
  var serviceProviderArray = __context.GetServiceProviders();
  for (var i = 0; i < serviceProviderArray.length; i++)
  {
    OnPageClick_Service(serviceProviderArray[i], launchNetElementClicked, pageValid);
  }
}

function OnPageClick_Service(service, launchNetElementClicked, pageValid)
{
  //only call functions that exist; this allows for developers to be lazy
  //which is good, since they all are
  if (eval('typeof(' + service + ');') != 'undefined')
  {
    eval('var serviceProvider = new ' + service + '();');
    if (typeof(serviceProvider.OnPageClick) != 'undefined')
    {
      eval(serviceProvider.OnPageClick(launchNetElementClicked, pageValid));
    }
  }
}

function OnPageClick_Subscribers(launchNetElementClicked, pageValid)
{
  if (__pageClickEventSubscribers.length > 0)
  {
    var pageClickEventSubscriberArray = __pageClickEventSubscribers.split('|');
    for (var i = 0; i < pageClickEventSubscriberArray.length; i++)
    {
      eval(pageClickEventSubscriberArray[i] + '(launchNetElementClicked, pageValid);');
    }
  }
}


/* ***********************************************************************************
-  Page Validation
************************************************************************************ */

function DoValidationIfRequired(currentEvent, launchNetElementClicked)
{
  var pageValid = true;
  
  if (OnValidationRequiredCheck(launchNetElementClicked))
  {
    //LaunchNet validation only required if a service says so
    pageValid = DoLaunchNetValidation();
  }
  else
  {
    //check asp.net validator controls otherwise
    pageValid = DoAspNetValidation();
  }
  
  //if the page isn't valid, cancel the event
  if (!pageValid)
  {
    //cancel the event since the page is not valid
    __context.GetBrowserServices().CancelEvent(currentEvent); 
  }
  
  return pageValid;
}

function OnValidationRequiredCheck(launchNetElementClicked)
{
  var validationRequired = false;
  
  //have services check to see if validation is required
  if (OnValidationRequiredCheck_Services(launchNetElementClicked))
  {
    validationRequired = true;
  }
  
  //alert any validate request check event subscribers
  if (OnValidationRequiredCheck_Subscribers(launchNetElementClicked))
  {
    validationRequired = true;
  }
  
  return validationRequired;
}

function OnValidationRequiredCheck_Services(launchNetElementClicked)
{
  var serviceProviderArray = __context.GetServiceProviders();
  for (var i = 0; i < serviceProviderArray.length; i++)
  {
    if (OnValidationRequiredCheck_Service(serviceProviderArray[i], launchNetElementClicked))
    {
      return true;
    }
  }
  //no validation required
  return false;
}

function OnValidationRequiredCheck_Service(service, launchNetElementClicked)
{
  var validationRequired = false;
  //only call functions that exist; this allows for developers to be lazy
  //which is good, since they all are
  if (eval('typeof(' + service + ');') != 'undefined')
  {
    eval('var serviceProvider = new ' + service + '();');
    if (typeof(serviceProvider.OnValidationRequiredCheck) != 'undefined')
    {
      validationRequired = serviceProvider.OnValidationRequiredCheck(launchNetElementClicked);
    }
  }
  
  return validationRequired;
}

function OnValidationRequiredCheck_Subscribers(launchNetElementClicked)
{
  var validationRequired = false;
  if (__validationRequiredCheckSubscribers.length > 0)
  {
    var validateRequestCheckSubscriberArray = __validationRequiredCheckSubscribers.split('|');
    for (var i = 0; i < validateRequestCheckSubscriberArray.length; i++)
    {
      if (eval(validateRequestCheckSubscriberArray[i] + '(launchNetElementClicked);'))
      {
        validationRequired = true;
      }
    }
  }
  
  return validationRequired;
}

function DoLaunchNetValidation()
{
  var validatableLaunchNetElements = GetValidatableLaunchNetElements();
  var launchNetElementsValid = true;
  
  //have services perform validation
  if (!OnValidateLaunchNetElements_Services(validatableLaunchNetElements))
  {
    launchNetElementsValid = false;
  }
  
  //alert any validation event subscribers
  if (!OnValidateLaunchNetElements_Subscribers(validatableLaunchNetElements))
  {
    launchNetElementsValid = false;
  }

  //perform custom validation if any exists
  if (!CallFunction("CustomValidation", true))
  {
    launchNetElementsValid = false;
  }

  return launchNetElementsValid;
}


function OnValidateLaunchNetElements_Services(validatableLaunchNetElements)
{
  var launchNetElementsValid = true;
  var serviceProviderArray = __context.GetServiceProviders();
  for (var i = 0; i < serviceProviderArray.length; i++)
  {
    if (!OnValidateLaunchNetElements_Service(serviceProviderArray[i], validatableLaunchNetElements))
    {
      launchNetElementsValid = false;
    }
  }

  return launchNetElementsValid;
}

function OnValidateLaunchNetElements_Service(service, validatableLaunchNetElements)
{
  var launchNetElementsValid = true;
  //only call functions that exist; this allows for developers to be lazy
  //which is good, since they all are
  if (eval('typeof(' + service + ');') != 'undefined')
  {
    eval('var serviceProvider = new ' + service + '();');
    if (typeof(serviceProvider.OnValidateLaunchNetElements) != 'undefined')
    {
      launchNetElementsValid = serviceProvider.OnValidateLaunchNetElements(validatableLaunchNetElements);
    }
  }
  
  return launchNetElementsValid;
}

function OnValidateLaunchNetElements_Subscribers(validatableLaunchNetElements)
{
  var launchNetElementsValid = true;
  if (__validateLaunchNetElementsSubscribers.length > 0)
  {
    var validateLaunchNetElementsSubscriberArray = __validateLaunchNetElementsSubscribers.split('|');
    for (var i = 0; i < validateLaunchNetElementsSubscriberArray.length; i++)
    {
      if (!eval(validateLaunchNetElementsSubscriberArray[i] + '(validatableLaunchNetElements);'))
      {
        launchNetElementsValid = false;
      }
    }
  }
  
  return launchNetElementsValid;
}

function DoAspNetValidation()
{ 
  //check the asp.net validator
  if(typeof(Page_IsValid) != "undefined")
  {
    return Page_IsValid;
  }
  else
  {
    //no flag set page is good
    return true;
  }
}