/* Note: these are functions specific to the first page of the JBB POST EDIT Job workflow -   
  //Uses:JEventUtil.js,JPageElementBase.js,JControllerBase.js,JValidBase.js,JInteractionUtil.js
*/

JEventUtil.addEvent(window,'load',init); 

/**
 * Initialize
 */

function init() {
  //if a form name isn't provided in the page, we won't initialize this form
  if (typeof(job_post_form_name) == "undefined") return;
  var job_post = new JBBJobPost(job_post_form_name);

  /***** Create controller mapping *****/
  /* -- Add events and handlers to a dispatcher object -- */
  var oController = new JControllerBase();
  oController.addEventType('name',changeHandler);
  oController.addEventType('email',changeHandler);
  oController.addEventType('phone',changeHandler);
  oController.addEventType('jobtitle',changeHandler);
  oController.addEventType('companyname',changeHandler);
  oController.addEventType('companyurl',changeHandler);
  oController.addEventType('altdetailurl',changeHandler);
  oController.addEventType('address',changeHandler);
  oController.addEventType('zip',changeHandler);
  oController.addEventType('salary',changeHandler);
  oController.addEventType('applyto',changeHandler);
  oController.addEventType('applysite',changeHandler);
  oController.addEventType('description',changeHandler);
  oController.addEventType('city', changeHandler);
  oController.addEventType('notblank',changeHandler);
  oController.addEventType('focus',focusHandler);
  oController.addEventType('count',countHandler);
  oController.addEventType('country', changeHandler);
  oController.addEventType('verification', changeHandler);
  oController.addEventType('togglecountry', toggleCountryHandler);

  //assign controller
  job_post.set_controller(oController);

  
  /***** Validation Definitions *****/
  
  /* -- Create base instance of validation object -- */
  var oValidation = new JValidBase();
  oValidation.main_msg_box = YAHOO.util.Dom.get('msgbox_main');
  oValidation.error_descriptions = _error_descriptions || {};//load descriptions rendered by server
  /* 
    Extend validation object with page specific rules and handler functions. 
    New handler functions can use the 'this' keyword to reference the validation object -
    and so has access to all the objects built methods / props
  */
  //ADD (or override) this pages extra Regex rules here:
  oValidation.addValidRule('string_min',3);
  oValidation.addValidRule('jobtitle_max',64);
  oValidation.addValidRule('companyname_max',48);
  oValidation.addValidRule('jobdescription_min',150);
  oValidation.addValidRule('jobdescription_max',64000);
  
  //ADD this pages extra validation handlers here:
  oValidation.addValidHandler('validateJobTitle', JBBJobPostValidation.validateJobTitle);
  oValidation.addValidHandler('validateCompanyName', JBBJobPostValidation.validateCompanyName);
  oValidation.addValidHandler('validateDescription', JBBJobPostValidation.validateDescription);
  oValidation.addValidHandler('validateLocation', JBBJobPostValidation.validateLocation);
  oValidation.addValidHandler('validateCountry', JBBJobPostValidation.validateCountry);
  oValidation.addValidHandler('validateVerification', JBBJobPostValidation.validateVerification);
  
  //DEFINE (or override) error messages appearing on screen
  oValidation.setErrorDescription('short_desc','please enter a minimum of 150 characters');
  
  //map events to their associated validation handlers
  //third item can be added that gets passed as an associative array of optional arguments
  var _evtToHandlerlist = [
    ['name','validateName'],
    ['email','validateEmail'],
    ['phone','validatePhone'],
    ['jobtitle','validateJobTitle'],
    ['companyname','validateCompanyName'],
    ['companyurl','validateUrl',{optional:true}],
    ['altdetailurl','validateUrl',{optional:true}],
    ['address','validateAddress'], 
    ['zip','validateLocation', {'zip': true, 'obj': YAHOO.util.Dom.get('f_job_country')}],
    ['city', 'validateLocation', {'city': true, 'obj': YAHOO.util.Dom.get('f_job_country')}],
    ['country', 'validateCountry'],
    ['salary','validateSalary'],
    ['applyto','validateEmail',{optional:true}],
    ['applysite','validateUrl',{optional:true}],
    ['description','validateDescription'],
    ['verification','validateVerification'],
    ['notblank','validateNotBlank']
  ];

  oValidation.mapEvtsToHandlers(_evtToHandlerlist);

  //set validator
  job_post.set_validator(oValidation);

  
  /***** add highlighting *****/
  
  //highlighting (id list -> container)
  job_post.add_group_highlight(['f_jobposter_firstname', 'f_jobposter_lastname', 'f_jobposter_email', 'f_jobposter_phone'],
                               'c_jobsection_1');
  job_post.add_group_highlight(['f_job_title', 'f_job_company', 'f_job_alt_detail_url', 'f_job_company_url'], 'c_jobsection_2');
  job_post.add_group_highlight(['f_job_address1'], 'c_jobsection_3')
  job_post.add_group_highlight(['f_job_country', 'f_job_zip', 'f_job_city'], 'c_jobsection_4');
  job_post.add_group_highlight(['f_job_salary'], 'c_jobsection_5');
  job_post.add_group_highlight(['f_job_apply_email', 'f_job_apply_website'], 'c_jobsection_6');
  job_post.add_group_highlight(['f_job_description'], 'c_jobsection_7');
  job_post.add_group_highlight(['f_category_location', 'f_category_occupation', 'f_category_industry',
                                'jt_1', 'jt_2', 'jt_4', 'jt_8', 'jt_16', 'jt_32', 'jt_64', 'jt_128'],
                               'c_jobsection_8');
  job_post.add_group_highlight(['f_captcha_verification'], 'c_jobsection_9');
  /***** add counter *****/
  
  //counter handler
  job_post.add_counter('f_job_description', 'c_job_description_count');

  /***** add toggling of country *****/
  
  //toggle country
  job_post.add_toggle('f_job_country', ['c_job-city', 'c_job-zip'], 'togglecountry');

  /***** add change handler for validation *****/
  
  //change handler
  //mapping ['input id', 'msgbox id', 'validation name']
  var onchange_handler_mapping = [
    ['f_jobposter_firstname', 'msgbox_firstname', 'name'],
    ['f_jobposter_lastname', 'msgbox_lastname', 'name'],
    ['f_jobposter_email', 'msgbox_email', 'email'],
    ['f_jobposter_phone', 'msgbox_phone', 'phone'],
    
    ['f_job_title', 'msgbox_jobtitle', 'jobtitle'],
    ['f_job_company', 'msgbox_company', 'companyname'],
    ['f_job_company_url', 'msgbox_companyurl', 'companyurl'],
    ['f_job_alt_detail_url', 'msgbox_jobaltdetailurl', 'altdetailurl'],
    ['f_job_address1', 'msgbox_address', 'address'],
    ['f_job_country', 'msgbox_country', 'country'],
    ['f_job_zip', 'msgbox_zip', 'zip'],
    ['f_job_city', 'msgbox_city', 'city'],
    ['f_job_salary', 'msgbox_salary', 'salary'],
    ['f_job_apply_email', 'msgbox_applyto', 'applyto'],
    ['f_job_apply_website', 'msgbox_applysite', 'applysite'],
    ['f_job_description', 'msgbox_description', 'description'],
    ['f_captcha_verification', 'msgbox_captcha', 'verification'],
    /*
    ['f_category_location', '', ''],
    ['f_category_occupation', '', ''],
    ['f_category_industry', '', ''],
    ['jt_1', 'msgbox_jobtype', ''],
    ['jt_2', 'msgbox_jobtype', ''],
    ['jt_4', 'msgbox_jobtype', ''],
    ['jt_8', 'msgbox_jobtype', ''],
    ['jt_16', 'msgbox_jobtype', ''],
    ['jt_32', 'msgbox_jobtype', ''],
    ['jt_64', 'msgbox_jobtype', ''],
    ['jt_128', 'msgbox_jobtype', ''],
    */

    //ignore this one
    ['', '', '']
  ];
  
  //add change handlers
  for (var i = 0; i < onchange_handler_mapping.length; i++) {
    var item = onchange_handler_mapping[i];
    job_post.add_onchange_handler(item[0], item[1], item[2]);
  }

  /***** add submit handler *****/
  
  //submit handler
  job_post.set_onsubmit_handler(submitHandler);

  /***** misc *****/
  
  //focus on first element  
  if(YAHOO.util.Dom.hasClass('msgbox_captcha', 'error')){
    //only captcha is server side validate
    YAHOO.util.Dom.get('f_captcha_verification').focus();    
  }
  else{
    YAHOO.util.Dom.get('f_jobposter_firstname').focus();
  }
  
  //count description initially
  countDisplay(YAHOO.util.Dom.get('f_job_description'), YAHOO.util.Dom.get('c_job_description_count'));
}

/**
 * Event Handlers
 * note: some of the below may belong in the controller which should manage the interface between 
 * handler function (View) and the element cache (Model)
 */

//Handle character count on keyup event
//called on page load to display # chars that may come in with form and onkeyup when focus is in element
function countHandler(event, type, obj) {
  var target = JEventUtil.getTarget(event);
  var observers = obj.element_cache.getObservers(target.id, type);

  try {
    for(var i = 0; i < observers.length; i++) {
      countDisplay(target, observers[i].obs);
    }
  }catch(e){}
}

function countDisplay(count_obj, display_obj) {
  display_obj.innerHTML = count_obj.value.length;
}

/**
 * flip between international location input and zip code input
 */
function toggleCountryHandler(event, type, obj) {
  var target = JEventUtil.getTarget(event);

  var container_zip  = obj.container_cache.elements['c_job-zip'];
  var container_city = obj.container_cache.elements['c_job-city'];

  if (target.value == 'US') {
    //show zip code, hide city
    YAHOO.util.Dom.removeClass(container_zip, 'hide');
    YAHOO.util.Dom.addClass(container_city, 'hide');
  }
  else {
    //show city, hide zip
    YAHOO.util.Dom.removeClass(container_city, 'hide');
    YAHOO.util.Dom.addClass(container_zip, 'hide');
  }
}

//Handle input change events
function focusHandler(event, type, obj) {
  var element_cache   = obj.element_cache;
  var container_cache = obj.container_cache;
  
  var target    = JEventUtil.getTarget(event);
  var observers = element_cache.getObservers(target.id, type);

  //remove highlight
  container_cache.walk(dimSection);

  //highlight the one that contains the element on focus
  for(var i = 0; i < observers.length; i++) { 
    JInteractionUtil.addClassName(observers[i].obs, 'containerHighlite');
  }
}

//Handle input change events
function changeHandler(event, type, obj) {
  var target = JEventUtil.getTarget(event);
  var error_id = false;
  var observers = obj.element_cache.getObservers(target.id, type);
  var validator = obj.validator;
  
  try {
    for(var i = 0; i < observers.length; i++) {
      //determine validation handler and run
      var handler = validator.getHandlerByEvtType(type);
      var args = validator.getHandlerArgsByEvtType(type);

      error_id = validator[handler](target.value, args);

      validator.manageErrors(target.id, error_id);

      JMessageUtil.toggleInlineError(observers[i].obs, error_id, validator);
    }
  }
  catch(e) {
  }
  
  JMessageUtil.hideMainError(validator);

  return error_id;
}

//Handle form submit event
function submitHandler(target, obj){
  var has_error = false;
  var observers = obj.element_cache.getAllObservers(target.id);
  var validator = obj.validator;

  //for each of the forms observers - validate using its validation handler
  for(var i = 0; i < observers.length; i++) {
    var observer = observers[i];

    //determine and run validation handler for observing element
    var handler  = validator.getHandlerByEvtType(observer.type);
    var args     = validator.getHandlerArgsByEvtType(observer.type);
    var error_id = validator[handler](observer.obs.value, args);

    validator.manageErrors(observer.obs.id, error_id);

    has_error = has_error || error_id;

    //if problem found find the field's observing message area and display error message  
    if(error_id) {
      var msgbox_observers = obj.element_cache.getObservers(observer.obs.id, observer.type); //get observers signed up for a given event
      for(var j = 0; j < msgbox_observers.length; j++) {
        JMessageUtil.toggleInlineError(msgbox_observers[j].obs, error_id, validator);
      }
    }
  }
  
  has_error  = has_error || error_id;
  
  JMessageUtil.toggleMainError(validator);
  
  JMessageUtil.focusFirstErrorByOrder(validator.errors, getFocusOrder());

  //cancelling form action takes the opposite of whats returned by the validation scripts (validation returns false to indicate lack of a problem)
  return has_error ? false : true;
}


/**
 *Presentation
 */

//dim a section
function dimSection(node){
  JInteractionUtil.removeClassName(node,'containerHighlite');
}

//get the focus order for error in validation
function getFocusOrder() {
  //validation focus order
  return [
    'f_jobposter_firstname',
    'f_jobposter_lastname',
    'f_jobposter_email',
    'f_jobposter_phone',
    'f_job_title',
    'f_job_company',
    'f_job_alt_detail_url',
    'f_job_company_url',    
    'f_job_address1',
    'f_job_country',
    'f_job_city',
    'f_job_zip',
    'f_job_salary',
    'f_job_apply_email',
    'f_job_apply_website',
    'f_job_description',
    'f_category_occupation',    
    'jt_1',
    'f_captcha_verification'];
}