/********************************************************************************
    * InternetCafe is a software solution that helps the management of Cybercafes
    * according with the ITALIAN DECREE LAW ON ANTI-TERROR MEASURES, 27 JULY 2005.
    * Copyright (C) 2006  Guido Angelo Ingenito
   
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU General Public License
    * as published by the Free Software Foundation; either version 2
    * of the License, or (at your option) any later version.
  
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   *******************************************************************************/
  package base;
  
  import java.io.File;
  import java.util.Date;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import base.user.Document;
  import base.user.User;
  import base.user.UserCredential;
  
  public class Control {
  	public static boolean isValidUserName(String name) {
  		if ((name == null) || (name.length() == 0)) {
  			return false;
  		}
  
  		Pattern pattern = Pattern
  				.compile("([A-Za-z]*[ //t//n//x0B//f//r]{0,1})*");
  		Matcher matcher = pattern.matcher(name);
  
  		return matcher.matches();
  	}
  
  	public static boolean isValidUserSurname(String surname) {
  		if ((surname == null) || (surname.length() == 0)) {
  			return false;
  		}
  
  		Pattern pattern = Pattern
  				.compile("([A-Za-z]*[ //t//n//x0B//f//r]{0,1})*");
  		Matcher matcher = pattern.matcher(surname);
  
  		return matcher.matches();
  	}
  
  	public static boolean isValidUserNickname(String nickname) {
  		if ((nickname == null) || (nickname.length() == 0)) {
  			return false;
  		}
  
  		return isValidCharacterOnlyString(nickname);
  	}
  
  	public static boolean isValidBirthdayDate(Date birthday) {
  		return (birthday != null) && birthday.before(new Date());
  	}
  
  	public static boolean isValidCharacterOnlyString(String string) {
  		if ((string == null) || (string.length() == 0)) {
  			return false;
  		}
  
  		Pattern pattern = Pattern.compile("[A-Za-z]*");
  		Matcher matcher = pattern.matcher(string);
  
  		return matcher.matches();
  	}
  
  	public static boolean isValidDoubleString(String string) {
  		if ((string == null) || (string.length() == 0)) {
  			return false;
  		}
  
  		Pattern pattern = Pattern.compile("[+-]?[0-9]*[//.]{0,1}[0-9]*");
  		Matcher matcher = pattern.matcher(string);
  
  		return matcher.matches();
  	}
  
  	public static boolean isValidIntegerOnlyString(String string) {
  		if ((string == null) || (string.length() == 0)) {
  			return false;
  		}
  
  		Pattern pattern = Pattern.compile("[0-9]*");
  		Matcher matcher = pattern.matcher(string);
  
  		return matcher.matches();
  	}
 
 	public static boolean isValidEMailAddress(String email) {
 		Pattern pattern = Pattern
 				.compile("[A-Za-z]*[//.]{0,1}[A-Za-z0-9]*@[A-Za-z0-9]*//.[A-Za-z]*");
 		Matcher matcher = pattern.matcher(email);
 
 		return matcher.matches();
 	}
 
 	public static boolean isValidUDPPort(int port) {
 		return (port > 1024) && (port < 65536);
 	}
 
 	public static boolean isValidDocumentDate(Date releaseDate,
 			Date expirationDate) {
 		Date currentDate = new Date();
 
 		return (releaseDate != null) && (expirationDate != null)
 				&& releaseDate.before(expirationDate)
 				&& releaseDate.before(currentDate);
 	}
 
 	public static boolean isValidSessionDate(Date startTime, Date endTime) {
 		return (startTime != null) && (endTime != null)
 				&& startTime.before(endTime);
 	}
 
 	public static boolean isValidIPAddress(String address) {
 		Pattern pattern = Pattern
 				.compile("([0-9]{1,3})//.([0-9]{1,3})//.([0-9]{1,3})//.([0-9]{1,3})");
 		Matcher matcher = pattern.matcher(address);
 
 		return matcher.matches();
 	}
 
 	public static boolean isValidUserPassword(String password) {
 		return (password != null) && (password.length() > 0);
 	}
 
 	public static boolean isValidUserDocument(Document document) {
 		if (document == null) {
 			return false;
 		}
 
 		if (!isValidDocumentDate(document.getRelease(), document
 				.getExpiration())
 				|| !isValidDocumentNumber(document.getType(), document
 						.getNumber())) {
 			return false;
 		}
 
 		return true;
 	}
 
 	public static boolean isValidDocumentImage(String imagePath) {
 		if ((imagePath == null) || (imagePath == "")
 				|| !new File(imagePath).exists()) {
 			return false;
 		}
 
 		return true;
 	}
 
 	public static boolean isValidDocumentNumber(String documentType,
 			String documentNumber) {
 		// FIXME We must search a strategy to support world's documents...
 		if ((documentNumber == null) || (documentNumber.length() == 0)) {
 			return false;
 		}
 
 		return true;
 	}
 
 	public static boolean isValidServiceMinMaxDuration(
 			int minDurationInMinutes, boolean careAboutMinDuration,
 			int maxDurationInMinutes, boolean careAboutMaxDuration) {
 		if ((minDurationInMinutes < 0) || (maxDurationInMinutes < 0)) {
 			return false;
 		}
 
 		if (careAboutMinDuration && !(minDurationInMinutes >= 0)) {
 			return false;
 		}
 
 		if (careAboutMaxDuration && !(maxDurationInMinutes > 0)) {
 			return false;
 		}
 
 		if (careAboutMinDuration && careAboutMaxDuration) {
 			return maxDurationInMinutes >= minDurationInMinutes;
 		}
 
 		return true;
 	}
 
 	public static boolean areValidAdministratorCredentials(String nickname,
 			String password) {
 		User[] user = InternetCafeManager.getInstance().getUser();
 
 		for (int i = 0; i < user.length; i++) {
 			if (user[i].getNickname().equals(nickname)) {
 				return user[i]
 						.getCredential()
 						.equals(
 								UserCredential.USER_CREDENTIAL[UserCredential.ADMINISTRATOR])
 						&& user[i].getPassword().equals(
 								User.buildUserPassword(password));
 			}
 		}
 
 		return false;
 	}
 }