var errorMessage = ""
var userMessage = ""

function IP2int(IPvalue) {
  var tmpArray = IPvalue.split(".");
  return((tmpArray[0] * 0x1000000) + (tmpArray[1] * 0x10000) + (tmpArray[2] * 0x100) + (tmpArray[3] * 0x01));
}

function int2IP(IPint) {
  tmpStr = "";
  tmpStr = (IPint >>> 24) + "." + ((IPint >>> 16) & 0xFF) + "." + ((IPint >>> 8) & 0xFF) + "." + (IPint & 0xFF);
  return tmpStr;
}


function verifyIP (IPvalue,AddressOrMask) {
  //verify IP Address

  errorString = "";
  
  if( AddressOrMask )
    theName = "IP Address";
  else
    theName = "Network Mask";
  
  var ipArray = IPvalue.split(".");

  if (!ipArray || ipArray.length != 4)
    errorString += 'The '+theName+' does not have a valid format. Please use the following format: 123.123.123.123';
  else {
    for (i = 0; i < 4; i++) {
      thisSegment = ipArray[i];
      if (thisSegment != "") {
        if (!(thisSegment >=0 && thisSegment <= 255)) { //check if number?
          errorString += 'The '+theName+' can only consist out of numbers in the range 0-255 (separated by dots)';
          i = 4;
        }
      } else
         errorString += 'The '+theName+' does not have a valid format.\n Please use the following format: 123.123.123.123';
    }
  }
  if (errorString != "") {
    errorMessage = errorString+"\n";
    return false;
  }
  return true;
}

function verifyIPAddress (IPvalue, NullAllowed) {
  errorString = "";
  validValue = true;
  
  if (NullAllowed && (IPvalue == "0.0.0.0")) {
    return true;
  }

  if (verifyIP(IPvalue,true)) {
    var ipArray = IPvalue.split(".");    
    if ( !( (ipArray[0] >= 1) && (ipArray[0] <= 223) ) ) {
      errorString += "The first octet must be between 1 and 223";
      validValue = false;
    }
  } else {
    validValue = false;
  }

  if (errorString != "") {
    errorMessage = errorString+"\n";
  }
  return validValue;
}

function verifyMask (Mask) {
  validValue = true;
  
  if( verifyIP(Mask,false) ){
    var ipArray = Mask.split(".");
    var ipTest = 0;
    if( ipArray[0] < 255 ) {
      if( (ipArray[1] > 0) || (ipArray[2] > 0) || (ipArray[3] > 0) ) {
        validValue = false;
      } else { 
        ipTest = ipArray[0];
      }
    } else {
      if( ipArray[1] < 255 ) {
        if( (ipArray[2] > 0) || (ipArray[3] > 0) ) {
          validValue = false;
        } else {
          ipTest = ipArray[1];
        }
      } else {
        if( ipArray[2] < 255 ) {
          if( (ipArray[3] > 0) ) {
            validValue = false;
          } else {
            ipTest = ipArray[2];
          }
        } else {
          ipTest = ipArray[3];
        }
      }
    }
    if( validValue ) {
      switch( ipTest ) {
      case "0":
      case "128":
      case "192":
      case "224":
      case "240":
      case "248":
      case "252":
      case "254":
      case "255":
        break;
      default:
        validValue = false;
      }
    }
    if( Mask == "0.0.0.0" ) {
      validValue = false;
    }
  } else {
    validValue = false;
  }

  if( !validValue )
    errorMessage = 'The netmask must represent a contiguous number of bits with the leftmost bit 1\n';
  return validValue;
}

  function verifyMAC(macAddress) {
    // This function checks whether the address given is in MAC Address notation
    // MAC Address format is: 00:00:00:00:00:00
    validValue = true
    if (macAddress.length != 17) {
      validValue = false
    } else {
      testAddress = macAddress
      while (testAddress != "") {
        nrs = testAddress.substring(0,2)
        //  Use line below when MAC Address can only contain : . -
        if (testAddress.charAt(2) != ":" && testAddress.charAt(2) != "" && testAddress.charAt(2) != "." && testAddress.charAt(2) != "-"  && testAddress.charAt(2) != " ") return false
        if (!isHex(nrs) && (validValue)) { 
          errorMessage = macAddress+" is not a valid MAC Address.\n\nPlease enter a valid MAC Address."
          validValue = false;
        }
        testAddress = testAddress.substring(3,testAddress.length)
      }
    }
    if (!validValue)
      errorMessage = "Invalid MAC Address. Please use the following format: 00:00:00:00:00:00"
    return validValue
  }
  
function verifyRange (min, max) {
  min = parseInt(min);
  max = parseInt(max);
  if (min <= max)
    return (min <= max)
  else {
    alert('Invalid range. Minimum value exceeds maximum value.')
    return false;
  }
}

function numberInRange (el, elMin, elMax) {
  el = parseInt(el);
  elMin = parseInt(elMin);
  elMax = parseInt(elMax);
  if (el >= elMin && el <= elMax && elMax >=elMin && el.length != 0)
    return true;
  else {
    errorMessage = "Invalid value. Number ("+el+") must be in range "+elMin+"-"+elMax+".";
    return false;
  }
}

function verifyProtocol (myNumber) {
  if (!numberInRange(myNumber,0,256)) {
    errorMessage = "Invalid protocol number. Number must be between 0 and 256.";
    return false;
  } else
  return true;
}

function verifyPort (myNumber) {
  if (!numberInRange(myNumber,0,65535)) {
  errorMessage = "Invalid port number. Port must be between 0 and 65535.";
    return false;
  } else
  return true;
}

function validateString (str) {
// allowed characters: 32,33,35-126 (34=")
// accents are not allowed: 192-214 + 217-246 + 249-255 + 191 (=¿)

  validString = true
  for (i=0;i<str.length;i++) {
    nr = str.charCodeAt(i) 
    if (!(nr>=32 && nr<=126 && nr != 34)) {
      validString = false
      errorMessage += "The input contains unallowed characters. Please try again\n"
      break
    }
  }
  return validString
}

function validateHexString (str) {
// allowed characters: 48-57 (0-9), 65-70 (A-F), 97-102 (a-f)

  validString = true
  for (i=0;i<str.length;i++) {
    nr = str.charCodeAt(i) 
    if (!((nr >= 48 && nr <= 57) || (nr >=65 && nr <= 70) || (nr >=97 && nr <= 102))) {
      validString = false
      errorMessage = "Incorrect value. Your input must consist of the characters 0 throug 9 or a through f.'\n"
      break;
    }
  }
  return validString
}

function strLength(str, length) {
  if (str.length != length) {
    errorMessage = "Incorrect value. Your input must be "+length+" characters long.\n";
    return false;
  } return true;
}

/*
  // example. The # is used to seperate the different strings
  var macList = ""
  macList += "#" + "FF:FF:FF:FF:FF:FF"
  macList += "#" + "FF:FF:00:00:00:00"
*/
  
  function uniqueMACAddress(macValue, macList) {
    macValue = macValue.toUpperCase();
    macList = macList.toUpperCase();
    
    //if the MAC Address is not yet in the list
    return (macList.indexOf(macValue) == -1);
  }

  function uniqueIPAddress(ipValue, ipList) {
    return (ipList.indexOf(ipValue) == -1);  
  }
  
  function uniqueInList(unValue, unList) {
    return (unList.indexOf(unValue) == -1);  
  }

function macKeyFilter() {
//allow 0-9, A-F, a-f
//allow 45=-, 46=., 32= , 58=:
  if ((event.keyCode >= 48 && event.keyCode<=57) || (event.keyCode >= 65 && event.keyCode <= 70) || (event.keyCode >= 97 && event.keyCode <= 102) || 
      (event.keyCode == 45 || event.keyCode == 46 || event.keyCode == 32 || event.keyCode == 58))
    event.returnValue = true;
  else
    event.returnValue = false;
}

function hexKeyFilter() {
//allow 0-9, A-F, a-f
  if ((event.keyCode >= 48 && event.keyCode<=57) || (event.keyCode >= 65 && event.keyCode <= 70) || (event.keyCode >= 97 && event.keyCode <= 102))
    event.returnValue = true;
  else
    event.returnValue = false;
}

function ipKeyFilter() {
//allow 0-9 & "."
  if ((event.keyCode < 48 || event.keyCode > 57) && event.keyCode != 46)
    event.returnValue = false;
}

function phoneKeyFilter() {
//allow 0-9 & "+-,w"
  if ((event.keyCode < 48 || event.keyCode > 57) && event.keyCode != 43 && event.keyCode != 44 && event.keyCode != 45 && event.keyCode != 119)
    event.returnValue = false;
}

function digitKeyFilter() {
//allow 0-9
  if (event.keyCode < 48 || event.keyCode > 57)
    event.returnValue = false;
}

function printableKeyFilter() {
  if (event.keyCode < 32 || event.keyCode > 126)
    event.returnValue = false;
}

function handleError(handleFunc) {
  retValue = handleFunc
  if (!retValue) {
    if (errorMessage != "") {
      alert(errorMessage)
      errorMessage = ""
      return false
    } else
    return false    
  } else
    return true
}

function handle(handleFunc) {
  return handleFunc
}

function validateInput(objStr,validateFunc) {
//validate input with the given validation function
//show errorMessage, but only 1 per submit-request

  var result = validateFunc;
  if (!result) {
    if (userMessage=="") {
      if( objStr=="" )
        userMessage = errorMessage;
      else
        userMessage = "("+objStr+"): " + errorMessage;
    }
    return false;
  } else
    return true;
}

function announceValidation() {
  if (userMessage != "") {
    alert(userMessage);
    userMessage = "";
    errorMessage = "";
    return false;
  } else
    return true;
}

function trimLeft(s) {
  //removes spaces at the beginning of a string
  while(''+s.charAt(0)==' ')
    s = s.substring(1,s.length);
  return s
}

function isHex(nr) {
  // This function checks whether a number is a hexadecimal number
  nrStr = "" + nr
  for (var i=0; i < nrStr.length; i++) {
    var oneNr = nrStr.charAt(i)
    if ((oneNr >= "0" && oneNr <= "9") || (oneNr >= "a" && oneNr <= "f") || (oneNr >= "A" && oneNr <= "F")) { }
    else return false
  }
  return true;
}

function checkAndFormatIpAddress(ipAddress) {
  //var returnValue = "";
  var portionStart = 0;
  var portionCounter = 1;
  ipAddress = "" + ipAddress;
  for (var i=0; i< ipAddress.length; i++) {
    var curChar = ipAddress.charAt(i);
    if (curChar == ".") {
      //if the portion's value is not between 0 and 255 throw error
      var curVal = ipAddress.substring(portionStart,i);
      if (curVal < 0 || curVal > 255) {
        alert('Invalid IP Address. The value should be below 255');
        return "error";
      }
      portionCounter++;
      portionStart = i + 1;
    } else if (curChar >="0" && curChar <="9") {
    } else {
      alert('Invalid IP Address. The IP Address can only consist out of numbers (separated by dots)');
      return "error";
    }
  }
  if (portionCounter != 4) {
    alert('The IP Address does not have a valid format. Please use the following style: 123.123.123.123');
    return "error";
  }
  var curVal = ipAddress.substring(portionStart,ipAddress.length);
  if (curVal < 0 || curVal > 255) {
    alert('Invalid IP Address. The value should be below 255');
    return "error";
  }
  //return returnValue;
  return ipAddress;
}

function isValidPort(s) {
  if(!isNumeric(s))
    return(false);

  if((s > 65535) || (s < 1))
    return(false);

  return(true);
}
function checkMacAddress(macAddress) {
	macAddress = macAddress.toUpperCase()
	
	if (verifyMAC(macAddress) && macAddress != '00:00:00:00:00:00' && macAddress != 'FF:FF:FF:FF:FF:FF') {  
	  return true;
	}
	
	errorMessage += macAddress+" is not a valid MAC Address.\n\nPlease enter a valid MAC Address.";
	return false;
}	
	


function checkAndFormatMacAddress(macAddress) {
  // This function checks and converts a MAC Address to a specified address-notation
  // MAC Address format is: 00:00:00:00:00:00
  // eg. convertMacAddress('00-00-00-00-00-00') returns 00:00:00:00:00:00

  if (checkMacAddress(macAddress)) {
    for (var i = 1;i < 6; i++) {
      macAddress = macAddress.substring(0,i*3 - 1) + ":" + macAddress.substring(i*3,macAddress.length);
    }
       
    return macAddress;
  }
  errorMessage += macAddress+" is not a valid MAC Address.\n\nPlease enter a valid MAC Address.";
  return false;
}