/********************************************************************************
    * 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.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Iterator;
  import java.util.Observable;
  
  import org.apache.log4j.Logger;
  
  import base.backup.Backup;
  import base.network.Network;
  import base.network.NetworkManager;
  import base.service.Service;
  import base.session.Session;
  import base.user.User;
  
  import com.db4o.Db4o;
  import com.db4o.ObjectContainer;
  import com.db4o.ObjectSet;
  
  public class InternetCafeManager extends Observable {
  
  	private static final transient Logger logger = Logger
  			.getLogger(InternetCafeManager.class.getName());
  
  	private static InternetCafeManager instance;
  
  	public static InternetCafeManager getInstance() {
  		return instance == null ? instance = new InternetCafeManager()
  				: instance;
  	}
  
  	private java.util.Hashtable<String, User> user = new java.util.Hashtable<String, User>();
  
  	private java.util.Hashtable<String, Session> session = new java.util.Hashtable<String, Session>();
  
  	private java.util.Hashtable<String, Service> service = new java.util.Hashtable<String, Service>();
  
  	private java.util.Hashtable<String, Backup> backup = new java.util.Hashtable<String, Backup>();
  
  	protected InternetCafeManager() {
  
  	}
  
  	private void deleteDB(ObjectContainer db) {
  		ObjectSet result = db.get(new Object());
  		while (result.hasNext())
  			db.delete(result.next());
  		db.commit();
  	}
  
  	public void store() {
  
  		if (!new File(ConfigurationManager.getInstance().getDataBasePath())
  				.exists()) {
  			try {
  				new File(ConfigurationManager.getInstance().getDataBasePath())
  						.createNewFile();
  			} catch (IOException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
  		ObjectContainer db = Db4o.openFile(ConfigurationManager.getInstance()
  				.getDataBasePath());
  		try {
  			// Here we will uppdate all the images...
  			updateImageReferences();
  
  			// We must delete the current database and restore it to the fresh
  			// values...
  			deleteDB(db);
  			// This will store in the db all the users...
  			Iterator iterator = user.values().iterator();
  			while (iterator.hasNext()) {
  				User u = (User) iterator.next();
 				if (u != null && u.getId() != -1)
 					db.set(u);
 			}
 			// This will store in the db the entire network...
 			db.set(NetworkManager.getInstance().getNetwork());
 			// This will store in the db all the sessions...
 			iterator = session.values().iterator();
 			while (iterator.hasNext())
 				db.set((Session) iterator.next());
 
 			// This will store in the db all the services...
 			iterator = service.values().iterator();
 			while (iterator.hasNext())
 				db.set((Service) iterator.next());
 
 			// This will store in the db all the backups...
 			iterator = backup.values().iterator();
 			while (iterator.hasNext())
 				db.set((Backup) iterator.next());
 
 			// This is the end of the operations on the db...
 			db.commit();
 
 			logger.debug("Internet Cafe Successfully Stored.");
 		} catch (Exception ex) {
 			ex.printStackTrace();
 		} finally {
 			db.close();
 		}
 	}
 
 	private void updateImageReferences() {
 		// Now we must store each user and document image
 		File userImageDirectory = new File(ConfigurationManager.getInstance()
 				.getUserImageDirectoryPath());
 		File documentImageDirectory = new File(ConfigurationManager
 				.getInstance().getDocumentImageDirectoryPath());
 
 		if (!userImageDirectory.exists()) {
 			boolean success = userImageDirectory.mkdirs();
 			if (!success)
 				logger.error("Can't create the User's image directory!");
 		}
 
 		if (!documentImageDirectory.exists()) {
 			boolean success = documentImageDirectory.mkdirs();
 			if (!success)
 				logger.error("Can't create the Document's image directory!");
 		}
 
 		// Here we must move all the new images to the correct directory...
 		Iterator iterator = user.values().iterator();
 		while (iterator.hasNext()) {
 			User u = (User) iterator.next();
 			if (u.getImagePath() != null && new File(u.getImagePath()).exists()) {
 				File userImageFile = new File(u.getImagePath());
 
 				String extension = userImageFile.getName().substring(
 						userImageFile.getName().lastIndexOf("."),
 						userImageFile.getName().length());
 				// This is the new file renamed according with the concat
 				// pattern "User" + UserId + "Image" + extension
 				File newUserImageFile = new File(userImageDirectory, "User"
 						+ u.getId() + "Image" + extension);
 
 				// CASE 0 - The user's image directory doesn't contains the
 				// user's file... copy it
 				if (!contains(userImageDirectory.list(), userImageFile
 						.getName())) {
 					try {
 						copy(userImageFile, newUserImageFile);
 						u.setImagePath(ConfigurationManager.getInstance()
 								.getUserImageDirectoryPath()
 								+ File.separatorChar
 								+ newUserImageFile.getName());
 					} catch (IOException e) {
 						logger
 								.error("Can't move the User's image file to the Users's images directory!");
 						// TODO Auto-generated catch block
 						e.printStackTrace();
 					}
 				}// CASE 1 - The user's image directory contains the user's
 				// file and it has the same length... discard changes,
 				// nothing to do...
 				else if (userImageFile.length() != newUserImageFile.length()) {
 					// CASE 2 - The user's image directory contains the user's
 					// file and it hasn't the same length... delete the previous
 					// file and copy the new one
 					try {
 						newUserImageFile.delete();
 						copy(userImageFile, newUserImageFile);
 					} catch (IOException e) {
 						logger
 								.error("Can't move the User's image file to the Users's images directory!");
 						// TODO Auto-generated catch block
 						e.printStackTrace();
 					}
 				}
 
 			}
 
 			if (u.getDocument() != null
 					&& u.getDocument().getImagePath() != null) {
 				File documentImageFile = new File(u.getDocument()
 						.getImagePath());
 				if (documentImageFile.exists()
 						&& !contains(documentImageDirectory.list(),
 								documentImageFile.getName())) {
 					String extension = documentImageFile.getName().substring(
 							documentImageFile.getName().lastIndexOf("."),
 							documentImageFile.getName().length());
 
 					File newDocumentImageFile = new File(
 							documentImageDirectory, "Document" + u.getId()
 									+ "Image" + extension);
 					try {
 						copy(documentImageFile, newDocumentImageFile);
 
 						u.getDocument().setImagePath(
 								ConfigurationManager.getInstance()
 										.getDocumentImageDirectoryPath()
 										+ File.separatorChar
 										+ newDocumentImageFile.getName());
 					} catch (IOException e) {
 						System.err
 								.println("Can't move the User's document image file to the Users's documents image directory!");
 						// TODO Auto-generated catch block
 						e.printStackTrace();
 					}
 
 				}
 			}
 
 		}
 	}
 
 	void copy(File src, File dst) throws IOException {
 		InputStream in = new FileInputStream(src);
 		OutputStream out = new FileOutputStream(dst);
 
 		// Transfer bytes from in to out
 		byte[] buf = new byte[1024];
 		int len;
 		while ((len = in.read(buf)) > 0) {
 			out.write(buf, 0, len);
 		}
 		in.close();
 		out.close();
 	}
 
 	public static boolean contains(String[] list, String text) {
 		for (int i = 0; i < list.length; i++)
 			if (list[i].equalsIgnoreCase(text))
 				return true;
 		return false;
 	}
 
 	public void retrieve() {
 
 		if (!new File(ConfigurationManager.getInstance().getDataBasePath())
 				.exists())
 			return;
 
 		ObjectContainer db = Db4o.openFile(ConfigurationManager.getInstance()
 				.getDataBasePath());
 		try {
 
 			// This will retrieve all the users...
 			user = new java.util.Hashtable<String, User>();
 			ObjectSet os = db.get(User.class);
 			while (os.hasNext()) {
 				User u = (User) os.next();
 				if (u != null && u.getId() != -1) {
 					// We must set the correct imagePath for each user image and
 					// document...
 					if (!ConfigurationManager.debugMode) {
 						if (u.getImagePath() != "" && u.getImagePath() != null
 								&& u.getImagePath().contains("..")) {
 							String imagePath = u.getImagePath().replace("..",
 									".");
 							u.setImagePath(imagePath);
 						}
 						if (u.getDocument() != null
 								&& u.getDocument().getImagePath() != ""
 								&& u.getDocument().getImagePath() != null
 								&& u.getDocument().getImagePath()
 										.contains("..")) {
 							String imagePath = u.getDocument().getImagePath()
 									.replace("..", ".");
 							u.getDocument().setImagePath(imagePath);
 						}
 					}
 					addUser(u);
 				}
 			}
 
 			// This will retrieve the entire network...
 			os = db.get(Network.class);
 			while (os.hasNext())
 				NetworkManager.getInstance().setNetwork((Network) os.next());
 
 			// This will retrieve all the sessions...
 			os = db.get(Session.class);
 			while (os.hasNext())
 				addSession((Session) os.next());
 
 			// This will retrieve all the services...
 			os = db.get(Service.class);
 			while (os.hasNext())
 				addService((Service) os.next());
 
 			// This will retrieve all the backups...
 			os = db.get(Backup.class);
 			while (os.hasNext())
 				addBackup((Backup) os.next());
 
 			logger.debug("Internet Cafe Successfully Retrieved.");
 		} catch (Exception ex) {
 			ex.printStackTrace();
 		} finally {
 			db.close();
 		}
 	}
 
 	/***
 	 * This method simply adds a user.
 	 * 
 	 * @param user
 	 *            The user to add.
 	 */
 	public void addUser(User user) {
 		this.setChanged();
 		this.user.put(userKey(user), user);
 		this.notifyObservers(user);
 	}
 
 	/***
 	 * This method simply adds a backup.
 	 * 
 	 * @param backup
 	 *            The backup to add.
 	 */
 	public void addBackup(Backup backup) {
 		this.setChanged();
 		this.backup.put(backupKey(backup), backup);
 		this.notifyObservers(backup);
 	}
 
 	/***
 	 * This method simply adds a service.
 	 * 
 	 * @param service
 	 *            The service to add.
 	 */
 	public void addService(Service service) {
 		this.setChanged();
 		this.service.put(serviceKey(service), service);
 		this.notifyObservers(service);
 	}
 
 	/***
 	 * @return Returns the user.
 	 */
 	public User[] getUser() {
 		return user.values().toArray(new User[0]);
 	}
 
 	/***
 	 * @return Returns the backup.
 	 */
 	public Backup[] getBackup() {
 		return backup.values().toArray(new Backup[0]);
 	}
 
 	/***
 	 * @return Returns the user.
 	 */
 	public Service[] getService() {
 		return service.values().toArray(new Service[0]);
 	}
 
 	/***
 	 * @return Returns the session.
 	 */
 	public Session[] getSession() {
 		return session.values().toArray(new Session[0]);
 	}
 
 	/***
 	 * This method simply adds a session.
 	 * 
 	 * @param session
 	 *            The session to add.
 	 */
 	public void addSession(Session session) {
 		this.setChanged();
 		this.session.put(sessionKey(session), session);
 		this.notifyObservers(session);
 	}
 
 	/***
 	 * This method simply adds a set of sessions.
 	 * 
 	 * @param sessionSet
 	 *            The session set to add.
 	 */
 	public void addSessionSet(Session[] sessionSet) {
 		for (int i = 0; i < sessionSet.length; i++)
 			addSession(sessionSet[i]);
 	}
 
 	/***
 	 * This method deletes the user.
 	 * 
 	 * @param user
 	 *            The user to be deleted.
 	 */
 	public void deleteUser(User user) {
 		this.setChanged();
 		this.user.remove(userKey(user));
 		this.notifyObservers(user);
 	}
 
 	/***
 	 * This method deletes the service.
 	 * 
 	 * @param service
 	 *            The user to be deleted.
 	 */
 	public void deleteService(Service service) {
 		this.setChanged();
 		this.service.remove(serviceKey(service));
 		this.notifyObservers(service);
 	}
 
 	/***
 	 * This method simply builds a key string for an instance of User.
 	 * 
 	 * @param user
 	 *            The user from wich build the key.
 	 * @return A key rappresentation for the user.
 	 */
 	protected static String userKey(User user) {
 		String key = user.getId() + " " + user.getName() + " "
 				+ user.getSurname() + " " + user.getBirthday();
 		return key;
 	}
 
 	/***
 	 * This method simply builds a key string for an instance of Backup.
 	 * 
 	 * @param backup
 	 *            The backup from wich build the key.
 	 * @return A key rappresentation for the backup.
 	 */
 	protected static String backupKey(Backup backup) {
 		String key = backup.getId() + " " + backup.getName() + " "
 				+ backup.getDate();
 		return key;
 	}
 
 	/***
 	 * This method simply builds a key string for an instance of Service.
 	 * 
 	 * @param service
 	 *            The service from wich build the key.
 	 * @return A key rappresentation for the service.
 	 */
 	protected static String serviceKey(Service service) {
 		String key = service.getId() + " " + service.getName() + " "
 				+ service.getRateType();
 		return key;
 	}
 
 	/***
 	 * This method simply builds a key string for an instance of Session.
 	 * 
 	 * @param session
 	 *            The session from wich build the key.
 	 * @return A key rappresentation for the session.
 	 */
 	protected static String sessionKey(Session session) {
 		String key = session.getId() + " " + session.getUser().getNickname()
 				+ " " + session.getWorkstation().getName() + " "
 				+ session.getStartTime();
 		return key;
 	}
 
 	/***
 	 * This method deletes a session.
 	 * 
 	 * @param session
 	 *            The session to delete.
 	 */
 	public void deleteSession(Session session) {
 		this.setChanged();
 		this.session.remove(sessionKey(session));
 		this.notifyObservers(session);
 	}
 
 	/***
 	 * This method retrieves a user specifying his id.
 	 * 
 	 * @param userId
 	 *            An id associated to the user to retrieve.
 	 * @return A user with id equals to userId, null if the specified userId is
 	 *         not a valid user's id.
 	 */
 	public User getUserById(int userId) {
 		User[] user = getUser();
 		for (int i = 0; i < user.length; i++)
 			if (user[i].getId() == userId)
 				return user[i];
 		return null;
 	}
 
 	/***
 	 * This method retrieves a session specifying his id.
 	 * 
 	 * @param sessionId
 	 *            An id associated to the session to retrieve.
 	 * @return A session with id equals to sessionId, null if the specified
 	 *         sessionId is not a valid session's id.
 	 */
 	public Session getSessionById(int sessionId) {
 		Session[] session = getSession();
 		for (int i = 0; i < session.length; i++)
 			if (session[i].getId() == sessionId)
 				return session[i];
 		return null;
 	}
 
 	/***
 	 * This method retrieves a service specifying his id.
 	 * 
 	 * @param serviceId
 	 *            An id associated to the service to retrieve.
 	 * @return A service with id equals to serviceId, null if the specified
 	 *         serviceId is not a valid service's id.
 	 */
 	public Service getServiceById(int serviceId) {
 		Service[] service = getService();
 		for (int i = 0; i < service.length; i++)
 			if (service[i].getId() == serviceId)
 				return service[i];
 		return null;
 	}
 
 	/***
 	 * This method retrieves a backup specifying his id.
 	 * 
 	 * @param backupId
 	 *            An id associated to the backup to retrieve.
 	 * @return A backup with id equals to backupId, null if the specified
 	 *         backupId is not a valid backup's id.
 	 */
 	public Backup getBackupById(int backupId) {
 		Backup[] backup = getBackup();
 		for (int i = 0; i < backup.length; i++)
 			if (backup[i].getId() == backupId)
 				return backup[i];
 		return null;
 	}
 
 	/***
 	 * This method deletes a backup from the system.
 	 * 
 	 * @param backup
 	 *            The backup to delete.
 	 */
 	public void deleteBackup(Backup backup) {
 		this.setChanged();
 		this.backup.remove(backupKey(backup));
 		this.notifyObservers(backup);
 	}
 
 	/***
 	 * This method clears all the InternetCafe's data. Backups will not be
 	 * deleted.
 	 */
 	public void clear() {
 		user.clear();
 		NetworkManager.getInstance().setNetwork(null);
 		session.clear();
 		service.clear();
 	}
 
 	/***
 	 * This method retrieves a user specifying his nickname.
 	 * 
 	 * @param userNickname
 	 *            A nickname associated to the user to retrieve.
 	 * @return A user with nickname equals to userNickname, null if the specified userNickname is
 	 *         not a valid user's nickname.
 	 */
 	public User getUserByNickname(String userNickname) {
 		User[] user = getUser();
 		for (int i = 0; i < user.length; i++)
 			if (user[i].getNickname().equals(userNickname))
 				return user[i];
 		return null;
 	}
 
 }