FavFolders.java

package uc;

import helpers.IPrefSerializer;
import helpers.PrefConverter;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import logger.LoggerFactory;


import org.apache.log4j.Logger;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;




/**
 * 
 * FavFolders  are special folders that are either shared (and all subfolders of it) (SharedDir)
 * of Folders that are preferred targets for downloads (FavDir).
 * 
 * @author Quicksilver
 *
 */
public class FavFolders {

	private static final Logger logger = LoggerFactory.make();
	
		
	private final List<SharedDir> sharedDirs;
	
	FavFolders() {
		sharedDirs = new CopyOnWriteArrayList<SharedDir>(SharedDir.loadSharedDirs());
		logger.debug("loaded Favdirs and SharedFolders");
	}

	
	public List<SharedDir> getSharedDirs() {
		return Collections.unmodifiableList(sharedDirs);
	}
	
	
	public void storeSharedDirs(List<SharedDir> shared) {
		sharedDirs.clear();
		sharedDirs.addAll(shared);
		String val = PrefConverter.createList(shared, new SharedDirTranslater());
		PI.put(PI.sharedDirs2, val);
		
		/*
		IEclipsePreferences pref = PI.get();
		try {
			sharedDirs.clear();
			sharedDirs.addAll(shared);
			
			Preferences shareddirs = pref.node(PI.sharedDirs);
			shareddirs.removeNode();
			shareddirs = pref.node(PI.sharedDirs);
			

			for (SharedDir sd:shared) {
				Preferences itemnode = shareddirs.node(sd.getName());
				sd.storeDir(itemnode);
			}
		
			pref.flush();
		} catch (BackingStoreException bse){
			logger.warn(bse,bse);
		} */
		
	}
	
	public static void storeFavDirs(List<FavDir> favdirs) {
		String val = PrefConverter.createList(favdirs, new FavDirTranslater());
		PI.put(PI.favDirs, val);
	}
	
	public static List<FavDir> getFavDirs() {
		return PrefConverter.parseString(PI.get(PI.favDirs), new FavDirTranslater());
	}
	
	
	public static class FavDir {
		
		
		protected String name;
		protected File directory;
		
		public FavDir(String name, File directory){
			this.name=name;
			this.directory=directory;
		}
		
		
		
		/*
		 * 
		 * @param itemnode node corresponding to the name
		 * of the FavDir
		 *
		protected void storeDir(Preferences itemnode) {
			itemnode.put(PI.sharedDirsName, name);
			itemnode.put(PI.sharedDirsdirectory, directory.getPath());
		} */
		
		/*
		public static void soreFavDirs(Collection<FavDir> favDirs){
			Preferences pref=Application.get().node(PI.favDirs);
			try {
				pref.removeNode();
				pref =  Application.get().node(PI.favDirs);
				for (FavDir fd: favDirs) {
					Preferences p = pref.node(fd.getName());
					p.put(PI.sharedDirsdirectory,fd.getDirectory().getAbsolutePath());
				}
				pref.flush();
			
			} catch(BackingStoreException bse){
				bse.printStackTrace();
			}
		} */
		
		/**
		 * @return the directory
		 */
		public File getDirectory() {
			return directory;
		}
		/**
		 * @param directory the directory to set
		 */
		public void setDirectory(File directory) {
			this.directory = directory;
		}
		/**
		 * @return the name
		 */
		public String getName() {
			return name;
		}
		/**
		 * @param name the name to set
		 */
		public void setName(String name) {
			this.name = name;
		}
		@Override
		public int hashCode() {
			final int PRIME = 31;
			int result = 1;
			result = PRIME * result + ((directory == null) ? 0 : directory.hashCode());
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			final FavDir other = (FavDir) obj;
			if (directory == null) {
				if (other.directory != null)
					return false;
			} else if (!directory.equals(other.directory))
				return false;
			return true;
		}
		
		
	}
	
	public static class FavDirTranslater implements IPrefSerializer<FavDir> {
		public String[] serialize(FavDir t) {
			return new String[]{t.getName(),t.getDirectory().getPath()};
		}

		public FavDir unSerialize(String[] all) {
			return new FavDir(all[0], new File(all[1]));
		}
	}
	
	
	public static class SharedDirTranslater implements IPrefSerializer<SharedDir> {

		public String[] serialize(SharedDir t) {
			return new String[] {t.getName(),t.getDirectory().getPath(),""+t.lastShared};
		}

		public SharedDir unSerialize(String[] all) {
			return new SharedDir(all[0], new File(all[1]),Long.parseLong(all[2]));
		}
		
	}
	
	public static class SharedDir extends FavDir {
		
		private long lastShared;
		
		public SharedDir(String name, File directory,long lastshared){
			this(name,directory);
			this.lastShared = lastshared;
		}
		
		public SharedDir(String name, File directory){
			super(name,directory);
			lastShared = 0;
		}

		

		/**
		 * @return the lastShared
		 */
		public long getLastShared() {
			return lastShared;
		}
		/**
		 * @param lastShared the lastShared to set
		 */
		public void setLastShared(long lastShared) {
			this.lastShared = lastShared;
		}
		
		
		private static List<SharedDir> loadSharedDirs() {
			String sd2 = PI.get(PI.sharedDirs2);
			if (!sd2.equals(PI.LegacyMode)) {
				logger.debug("Loading shared dirs in Modern mode.");
				List<SharedDir> ret = PrefConverter.parseString(sd2, new SharedDirTranslater());
				return ret;
			} else {
				logger.debug("Loading shared dirs in Legacy mode.");
				Preferences pref = PI.get().node(PI.sharedDirs);
				List<SharedDir> ret = new ArrayList<SharedDir>();
				try{
					for (String child: pref.childrenNames()) {
						Preferences p = pref.node(child);
						SharedDir sharedDir = new SharedDir(child,
								new File(p.get(PI.sharedDirsdirectory, null)),
								p.getLong(PI.SharedDirslastShared, 0));
						ret.add(sharedDir);
					}
				} catch(BackingStoreException bse) {
					bse.printStackTrace();
				}
				return ret;
			}
		}
		


		@Override
		public int hashCode() {
			return super.hashCode();
		}

		@Override
		public boolean equals(Object obj) {
			return super.equals(obj);
		}
		
		public boolean isOnline() {
			return getDirectory().isDirectory();
		}
		
		
	}

}