package edu.vt.marian.WebGate;

import java.net.*;
import java.util.*;
import java.io.*;
import edu.vt.marian.common.*;


/**
 * Class Name: folder_manager
 * Class Description: This class manages a bunch of folders for a user.  It can
 *		envolve to a database in the future, but that's hidden to the outside.
 *		The same service will still be available after that.
 * Author: Richard Baker
 * Finished Time: May 1, 2000
 * Known Bugs: None.
 * Platform: Microsoft Visual J++ 6.0 under Windows NT
 */
public class folder_manager
{
	// this is for debugging
	Debug debug;
	
	// this is the folder database
	private Vector folders;
	
	// this keeps track of the number of the current folder
	private String curr_folder;
	
	// this is the directory of the folder_manager
	private String folder_manager_dir;
	
	// this stores the HTML code to display the folder list
	private String folder_list_html;
	
	// this stores the HTML code to display the drop down box of folders
	private String drop_box_html;
	
	// this is the current number to assign to the next folder created
	private int curr_number;
	
	
	/**
	 * This constructor creates a new empty folder_manager.
	 */
	public folder_manager(Debug debug)
	{	
		init();
		
		this.debug = debug;
	}
	
	
	/**
	 * This constructor creates a new folder_manager from a specified directory
	 * which contains all the folder information about the user.
	 */
	public folder_manager(String user_name, String dir, Debug debug)
	{	
		// first initialize data members
		init();
		
		this.debug = debug;
		folder_manager_dir = dir;

		File file = new File(dir);
		if (! file.exists())
		{
			// this is the first time this object is created, do nothing
			// except create the directory and the top level folder (numbered "0")
			try
			{
				file.mkdir();
				new_folder(user_name);
				set_curr_folder("0");
			}
			catch (SecurityException e)
			{
				debug.dumpTrace("class folder_manager: cannot create directory");
			}

			return;
		}

		
		// there is something in the directory, probably folders created before
		// read them out
		File folders_config = new File(dir + File.separator + "index");
		BufferedReader br;
		
		try
		{
			String s;
			FileReader fr = new FileReader(folders_config);
			br = new BufferedReader(fr);

			// first read out number of folders 
			int number_folders = Integer.parseInt(br.readLine());
			
			if (number_folders == 0)
			{
				new_folder(user_name);
				set_curr_folder("0");
			}
			
			// then read out each folder
			int i;
			folder f;
			for (i = 0; i < number_folders; i++)
			{	
				// read next line
				s = br.readLine();
				
				// if the line consists of "*", then the next line read will be the current folder
				if (s.equals("*"))
				{
					// read out folder
					f = new folder(dir + File.separator + br.readLine(), debug);
					
					// set folder as the current folder
					curr_folder = f.get_number();
				}
				
				// otherwise, read out folder
				else
					f = new folder(dir + File.separator + s, debug);
				
				// open the top level folder
				if (f.get_number().equals("0"))
					f.open();
				
				// add folder to database
				folders.addElement(f);
			}
			br.close();
			
			// set the current number to assign to the next folder
			if (number_folders > 0)
			{
				f = (folder)folders.elementAt(folders.size()-1);
				curr_number = Integer.parseInt(f.get_number()) + 1;
			}
		}
		catch (IOException e3) 
		{
			debug.dumpTrace("error reading data from " + folders_config.getAbsolutePath());
		}
	}
	
	/**
	 * This method returns the Vector of folders.
	 */
	public Vector get_folders()
	{
		return folders;
	}
	
	
	/**
	 * This method adds a new folder with a specified name to the folder
	 * database.
	 */
	public synchronized String new_folder(String name)
	{
		if (name == null)
			return null;
		
		// currently, we use index as folder number, but this may be changed
		// in the future
		String dir;
		
		// if current folder is the top level folder, create inside folder_manager
		// driectory
		if (curr_folder.equals("0"))
			dir = folder_manager_dir;
		
		// otherwise, create inside current folder directory
		else
			dir = get_curr_folder().get_dir();
		
		// add folder to database
		folder f = new folder(Integer.toString(curr_number), name,
			dir + File.separator + Integer.toString(curr_number), debug);
		folders.addElement(f);
		
		// increment current number to assign to next folder
		curr_number++;
		
		return f.get_number();
	}
	
	
	/**
	 * This method deletes the current folder.
	 */
	public String delete_folder()
	{
		folder f;			
		my_directory md;
		String parent;
		String[] children;
		
		// if current folder exists and is not the top level folder
		if (curr_folder != null && (! curr_folder.equals("0")))
		{
			for (int i = 0; i < folders.size(); i++)
			{
				f = (folder)folders.elementAt(i);
				if (f.get_number().equals(curr_folder))
				{
					// find children of current folder
					children = get_children(curr_folder);
					for (int j = 0; j < children.length; j++)
					{
						// don't look at config file and query_manager directory
						if (! (children[j].equals("config") || children[j].equals("query_manager")))
						{
							// delete child folder
							set_curr_folder(children[j]);
							delete_folder();
						}
					}
					
					md = new my_directory(f.get_dir(), debug);
					parent = get_parent(curr_folder);
					
					// if parent directory of current folder is folder_manager,
					// set the top level folder as current folder
					if (parent.equals("folder_manager"))
						set_curr_folder("0");
					
					// otherwise, set parent folder as current folder
					else
						set_curr_folder(parent);
					
					// delete folder directory and remove it from the database
					md.delete();
					folders.removeElementAt(i);
					folders.trimToSize();
					
					return "OK";
				}
			}
		}
		
		return null;
	}
	
	
	/**
	 * This method deletes all the folders in the folder database.
	 */
	public String delete_folders()
	{
		folder f;
		my_directory md;
		
		for (int i = 0; i < folders.size(); i++){
			f = (folder)folders.elementAt(i);
			//f.delete_queries();
			md = new my_directory(f.get_dir(), debug);
			md.delete();
			folders.removeElementAt(i);
		}
		folders.trimToSize();
		return "OK";
	}
	
	
	/**
	 * This method moves the current folder into a specified folder.
	 */
	public String move_folder_to(String folder_number)
	{
		folder f, f1;
		File this_file, new_file;
		my_directory md;
		
		// if specified folder exists and is not the current folder
		if (folder_number == null || folder_number.equals(curr_folder))
			return null;
		
		f = get_curr_folder();
		this_file = new File(f.get_dir());
		md = new my_directory(f.get_dir(), debug);
		if (md.is_child(folder_number))
			return null;
		
		// if specified folder is the top level folder, move current folder
		// to folder_manager directory
		if (folder_number.equals("0"))
		{
			new_file = new File(folder_manager_dir + File.separator + f.get_number());
			f.set_dir(folder_manager_dir + File.separator + f.get_number());
		}
		
		// otherwise, move current folder to specified folder directory
		else
		{
			f1 = get_folder(folder_number);
			new_file = new File(f1.get_dir() + File.separator + f.get_number());
			f.set_dir(f1.get_dir() + File.separator + f.get_number());
		}
		
		// execute the move
		this_file.renameTo(new_file);
		md.delete();
		
		return "OK";
	}
	
	
	/**
	 * This method moves a specified query into a specified folder.
	 */
	public String move_query_to(String query_number, String folder_number)
	{
		folder f, f1;
		File this_file, new_file;
		int next_number;
		Vector queries;
		String next_query_number;
		query q;
		
		// if specified folder and specified query exist
		if (folder_number == null || query_number == null)
			return null;
		
		f = get_curr_folder();
		f1 = get_folder(folder_number);
		this_file = new File(f.get_dir() + File.separator + "query_manager" + File.separator + query_number);
		
		queries = f1.get_queries();
		
		// if no queries are in specified folder's query database, query will be numbered 0
		if (queries.size() == 0)
			next_number = 0;
		
		// otherwise, query will be numbered the next number in the specified folder's
		// query database
		else
		{
			q = (query)queries.elementAt(queries.size()-1);
			next_query_number = q.get_number();
			next_number = Integer.parseInt(next_query_number) + 1;
		}
		new_file = new File(f1.get_dir() + File.separator + "query_manager" + File.separator + next_number);
		
		// execute the move
		q = f.get_query(query_number);
		this_file.renameTo(new_file);
		f.delete_query(query_number);
		q.set_number(Integer.toString(next_number));
		q.set_dir(f1.get_dir() + File.separator + "query_manager" + File.separator + next_number);
		f1.add_query(q);
		
		return "OK";
	}
	
	
	/**
	 * This method sets the name of the current folder.
	 */
	public String set_name(String name)
	{
		return get_curr_folder().set_name(name);
	}
	
	
	/**
	 * This method returns the name of the current folder.
	 */
	public String get_name()
	{
		return get_curr_folder().get_name();
	}
	
	
	/**
	 * This method sets the current folder to a specified folder.
	 */
	public String set_curr_folder(String folder_number)
	{
		curr_folder = folder_number;
		return "OK";
	}
	
	
	/**
	 * This method returns the current folder.
	 */
	public folder get_curr_folder()
	{
		return get_folder(curr_folder);
	}
	
	
	/**
	 * This method returns a specified folder from the folder database.
	 */
	public folder get_folder(String folder_number)
	{
		folder f;
		
		if (!folder_number.equals(null)){
			for (int i = 0; i < folders.size(); i++){
				f = (folder)folders.elementAt(i);
				if (f.get_number().equals(folder_number))
					return f;
			}
		}

		return null;
	}
	
	
	/**
	 * This method returns the name of the parent folder of a specified folder.
	 */
	public String get_parent(String folder_number)
	{
		folder f = get_folder(folder_number);
		File file = new File(f.get_dir());
		File parent = new File(file.getParent());
		return parent.getName();
	}
	
	
	/**
	 * This method returns the children of a specified folder.
	 */
	public String[] get_children(String folder_number)
	{
		File file;
		
		// if folder_number is the top level folder, return children of the folder_manager
		// directory
		if (folder_number.equals("0"))
			file = new File(folder_manager_dir);
		
		// otherwise, return children of the specified folder's directory
		else
		{
			folder f = get_folder(folder_number);
			file = new File(f.get_dir());
		}
		
		return file.list();
	}	
	
	
	/**
	 * This method will unload those folders which have not been accessed for a
	 * specified time.
	 */	
	public String unload(long time)
	{
		int i;
		folder f;

		for (i = 0; i < folders.size(); i++)
		{
			f = (folder)folders.elementAt(i);
			f.unload(time);
		}

		return "ok";
	}
	
	
	/**
	 * This method saves the object to the specified directory.
	 */
	public String save(String dir)
	{
		// create the directory
		File file = new File(dir);
		try
		{
			file.mkdir();
		}
		catch (SecurityException e)
		{
			debug.dumpTrace("class folder_manager: cannot create directory");
		}
		
		// write folder index file
		FileOutputStream fos = null;
        try
        {
			fos = new FileOutputStream(dir + File.separator + "index", false);             
        }
        catch (IOException e3)
        {
			debug.dumpTrace("error opening folder index file to write");
        }
		PrintWriter pw = new PrintWriter(fos);
        
		// write number of folders
		pw.println(folders.size());

		// write each folder
		int i, j;
		folder f, f1;
		Vector parent_dirs;
		String parent, folder_dir;
		for (i = 0; i < folders.size(); i++) 
		{ 
			folder_dir = dir;
			f = (folder)folders.elementAt(i);
			parent_dirs = new Vector();
			parent = get_parent(f.get_number());
			
			// find this folder's directory path up to folder_manager
			while (! parent.equals("folder_manager"))
			{
				parent_dirs.addElement(parent);
				f1 = get_folder(parent);
				parent = get_parent(f1.get_number());
			}
			
			// if current folder, write a line containing "*" first
			if (f.get_number().equals(curr_folder))
				pw.println("*");
			
			// write path of this folder 
			for (j = parent_dirs.size(); j > 0; j--)
			{
				parent = (String)parent_dirs.elementAt(j-1);
				folder_dir += File.separator + parent;
				pw.print(parent + File.separator);
			}
			
			folder_dir += File.separator + f.get_number();

			// write the file name of this folder to index file
			pw.println(f.get_number());

			// save this folder to the file
			f.save(folder_dir);
		}
		
		pw.flush();
		pw.close();
		return "OK";
	}
	
	
	/**
	 * This method recursively generates the HTML code necessary to display all
	 * the currently visible folders in the folder display frame.
	 */
	private String generate_folder_list_html(String parent_folder, int num_spaces)
	{
		String folder_img;
		String action;
		String open_close_marker;
		String spaces = "";
		folder f;
		int i;
		
		// get the correct number of spaces to display in front of the folder image
		for (i = 0; i < num_spaces; i++)
			spaces += "&nbsp;";
		
		for (i = 1; i < folders.size(); i++)
		{
			f = (folder)folders.elementAt(i);
			
			// if parent of this folder is parent_folder
			if (get_parent(f.get_number()).equals(parent_folder))
			{
				// set the proper folder image to display
				if (f.get_number().equals(curr_folder))
					folder_img = "curr_folder.gif";
				else
					folder_img = "folder.gif";
				
				// set the proper action to do for the "type" variable
				if (f.get_number().equals(curr_folder))
				{
					if (f.is_open())
					{
						action = "close_folder";
						open_close_marker = "-";
					}
					else
					{
						action = "open_folder";
						open_close_marker = "+";
					}
				}
				else
				{
					action = "open_folder";
					if (f.is_open())
						open_close_marker = "-";
					else
						open_close_marker = "+";
				}
				
				// generate the HTML code to display this folder
				folder_list_html += "<TR>\n";
				folder_list_html += "\t<TD ALIGN=left NOWRAP>" +
		spaces + "<FONT SIZE=-1><B>" + open_close_marker +
		"</B></FONT><A HREF=\"@webgate:client_name@/type=" + action +
		"/folder_number=" + f.get_number() +
		"/@webgate:user_name@\" TARGET=\"_parent\"><IMG SRC=\"@webgate:image_directory@" +
		folder_img +
		"\" BORDER=0></A>&nbsp;<A HREF=\"@webgate:client_name@/type=" +
		action + "/folder_number=" + f.get_number() +
		"/@webgate:user_name@\" TARGET=\"_parent\">" + f.get_name() +
		"</A></TD>\n";
				folder_list_html += "</TR>\n";
				
				// if this folder is open, generate the HTML code to display its children
				if (f.is_open())
					generate_folder_list_html(f.get_number(), num_spaces+4);
			}
		}
		
		return "OK";
	}
	
	
	/**
	 * This method returns the HTML code necessary to display all the current
	 * visible folders in the folder display frame of the web page.
	 */
	public String get_folder_list_html()
	{
		String folder_img;
		folder f = (folder)folders.elementAt(0);
		
		// get the proper image to display for the top level folder
		if (curr_folder.equals("0"))
			folder_img = "curr_folder.gif";
		else
			folder_img = "top_folder.gif";
		
		// generate the HTML code to display the top level folder
		folder_list_html = "<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>\n";
		folder_list_html += "<TR>\n\t<TD ALIGN=left NOWRAP><A HREF=\"@webgate:client_name@/type=open_folder/folder_number=0/@webgate:user_name@\" TARGET=\"_parent\"><IMG SRC=\"@webgate:image_directory@" +
			folder_img + "\" BORDER=0></A>&nbsp;<A HREF=\"@webgate:client_name@/type=open_folder/folder_number=0/@webgate:user_name@\" TARGET=\"_parent\"><B>" +
			f.get_name() + "</B></A></TD>\n";
		folder_list_html += "</TR>\n";
		
		// generate the HTML code to display the rest of the folders
		generate_folder_list_html("folder_manager", 4);
		folder_list_html += "</TABLE>";
		
		return folder_list_html;
	}
	
	
	/**
	 * This method recursively generates the HTML code necessary to display all
	 * the names of the currently visible folders in the drop down box.
	 */
	private String generate_drop_box_html(String parent)
	{
	    folder f;
	    for (int i = 0; i < folders.size(); i++)
	    {
	        f = (folder)folders.elementAt(i);
			
			// if parent of this folder is parent_folder
	        if (get_parent(f.get_number()).equals(parent))
	        {
				// if this folder is not the current folder, generate the HTML code to
				// add it to the drop down box
				if (! f.get_number().equals(curr_folder))
					drop_box_html += "\t<OPTION VALUE=" + f.get_number() + ">" + f.get_name() + "\n";
				
				// if this folder is open, generate the HTML code to add its children to
				// the drop down box
	            if (f.is_open())
	                generate_drop_box_html(f.get_number());
	        }
	    }
		
		return "OK";
	}
	 
	 
	/**
	 * This method returns the HTML code necessary to display all the names of
	 * all the current visible folders in the drop down box.
	 */
	public String get_drop_box_html()
	{
	    drop_box_html = "<SELECT NAME=folder_number>\n";
		drop_box_html += "\t<OPTION VALUE=\"-1\">Select Folder..............................\n";
	    generate_drop_box_html("folder_manager");
	    drop_box_html += "</SELECT>";
	 
	    return drop_box_html;
	}

	
	/**
	 * This method initializes the data members of this object.
	 */
	private void init()
	{
		debug = null;
		folders = new Vector();
		curr_folder = "0";
		folder_manager_dir = null;
		folder_list_html = null;
		drop_box_html = null;
		curr_number = 0;
	}
}