source: trunk/gli/src/org/greenstone/gatherer/file/FileNode.java@ 7224

package org.greenstone.gatherer.file;

import java.io.*;
import java.util.ArrayList;
import java.util.Enumeration;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.collection.BasicCollectionConfiguration;
import org.greenstone.gatherer.collection.Collection;
import org.greenstone.gatherer.file.FileFilter;
import org.greenstone.gatherer.file.FileSystemModel;
import org.greenstone.gatherer.util.ArrayTools;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;

public class FileNode
    implements MutableTreeNode {

    static final private int FALSE   = 0;
    static final private int TRUE    = 1;
    static final private int UNKNOWN = 2;

    private ArrayList children;
    private ArrayList raw_children;
    private boolean children_readonly = true;
    private boolean current_collection = false;
    private boolean readonly = true;
    private File file;
    private FileSystemModel model;
    private int allows_children = UNKNOWN;
    private MutableTreeNode parent;
    private String title;

    public FileNode(File file) {
    // System.err.println("New FileNode(" + file.getAbsolutePath() + ")");
    this.file = file;
    }

    public FileNode(File file, boolean readonly) {
    this(file);
    this.children_readonly = readonly;
    this.readonly = readonly;
    }

    public FileNode(File file, FileSystemModel model) {
    this(file);
    this.model = model;
    }

    public FileNode(File file, FileSystemModel model, boolean readonly) {
    this(file, readonly);
    this.model = model;
    }

    public FileNode(File file, FileSystemModel model, String title) {
    this(file, model);
    this.title = title;
    }

    public FileNode(File file, String title) {
    this(file);
    this.title = title;
    }

    public FileNode(File file, String title, boolean readonly) {
    this(file, readonly);
    this.title = title;
    }

    public FileNode(File file, FileSystemModel model, String title, boolean readonly) {
    this(file, model, readonly);
    this.title = title;
    }

    /** The special 'dummy' root node, that is not based on a particular file, but instead holds several special directory mappings. */
    public FileNode(String title) {
    this.children = new ArrayList();
    this.title = title;
    }

    /** Returns the children of the receiver as an Enumeration. */
    public Enumeration children() {
    return new FileEnumeration();
    }

    /** Compare two filenodes for equality. */
    public boolean equals(FileNode node) {
    boolean result = false;
    if(node != null) {
        if(file != null) {
        result = (file.equals(node.getFile()));
        }
        else {
        result = toString().equals(node.toString());
        }
    }
    return result;
    }

    /** Retrieve the filenode at the given index, regardless of filters set.
     * @param index int
     */
    public FileNode get(int index) {
    if(0 <= index && index < size() && file != null) {
        return (FileNode) raw_children.get(index);
    }
    return null;
    }

    /** Returns true if the receiver allows children. We have to cache the result of this call to prevent unceasing missing disk messages being thrown if the removable media was, um, removed after directory mapped. */
    public boolean getAllowsChildren() {
    if(readonly) {
        if(allows_children == UNKNOWN) {
        // If the file is non-null but doesn't exist (as is the case for removable media), return true anyway.
        if(file != null) {
            if(isFileSystemRoot()) {
            allows_children = TRUE;
            }
            else if(file.exists() && file.isDirectory()) {
            allows_children = TRUE;
            }
            // Any mapped directories always allow children.
            else if(getParent() != null && getParent().getParent() == null) {
            allows_children = TRUE;
            }
            else {
            allows_children = FALSE;
            }
        }
        // Allows children is always true for dummy nodes.
        else {
            allows_children = TRUE;
        }
        }
        return (allows_children == TRUE);
    }
    else {
        return (file == null || file.isDirectory());
    }
    }
    
    /** Returns the child TreeNode at index childIndex. */
    public TreeNode getChildAt(int index) {
    TreeNode result = null;
    map();
    if(0 <= index && index < children.size()) {
        result = (TreeNode) children.get(index);
    }
    else {
        result = new DefaultMutableTreeNode("Error");
    }
    ///ystem.err.println(this + ".getChildAt(" + index + ") = " + result);
    return result;
    }

    /** Returns the number of children TreeNodes the receiver contains. */
    public int getChildCount() {
    int size = 0;
    // We don't automatically map if this is a system root, or we risk the 50,000 Disk not found error messages of death.
    if(isFileSystemRoot()) {
        size = 1; // Size is always non-zero for a system root
    }
    else {
        map();
    }
    if(children != null) {
        size = children.size();
    }
    ///ystem.err.println(this + ".getChildCount() = " + size);
    return size;
    }

    public File getFile() {
    return file;
    }

    /** Retrieve the icon the system thinks should be assigned to this node. If this node has no file then the icon will be null. */
    public ImageIcon getIcon() {
    return null;
    }

    /** Returns the index of node in the receivers children. */
    public int getIndex(TreeNode node) {
    map();
    return children.indexOf(node);
    }

    /** Returns the parent TreeNode of the receiver. */
    public TreeNode getParent() {
    return parent;
    }

    /** Retrieves the tree path from the root node to this node. */
    public TreeNode[] getPath() {
    int count = 0;
    TreeNode current = this;
    while(current != null) {
        count++;
        current = current.getParent();
    }
    TreeNode[] path = new TreeNode[count];
    current = this;
    while(current != null) {
        path[count - 1] = current;
        count--;
        current = current.getParent();
    }
    return path;
    }

    public void insert(MutableTreeNode child) {
    insert(child, children.size());
    }

    /** Adds child to the receiver at index. */
    public void insert(MutableTreeNode child, int index) {
    Gatherer.println("Insert " + child + " in " + this + " at index " + index + " [Model: " + model + "]");
    if (child == null) {
        return;
    }
    try {
        children.add(index, child);
        // Set parent and model.
        FileNode new_child = (FileNode) child;
        new_child.setModel(model);
        new_child.setParent(this);
        new_child.setReadOnly(readonly);
    }
    catch(Exception error) {
        error.printStackTrace();
    }
    }

    /** Is this file node within the currently open collection? */
    public boolean isInCurrentCollection() {
    if(current_collection) {
        return true;
    }
    else {
        FileNode parent = (FileNode) getParent();
        if(parent != null) {
        return parent.isInCurrentCollection();
        }
    }
    return false;
    }

    /** Returns true if the receiver is a leaf. */
    public boolean isLeaf() {
    return !getAllowsChildren();
    }

    public boolean isReadOnly() {
    return readonly;
    }

    public boolean isFileSystemRoot() {
    boolean result = false;
    if(file != null) {
        result = FileSystemView.getFileSystemView().isFileSystemRoot(file);
    }
    return result;
    }

    public void map() {
    if(children == null) {
        children = new ArrayList();
        // Super Special Case: if the name of this node is the Tree.World string, then we actually map the collections installed in greenstone. The file in this case will actually by the collect directory of greenstone.
        if(file == null && title.equals(Dictionary.get("Tree.World"))) {
        ///atherer.println("Map the 'Greenstone Collections' node.");
        // For each of the children directories, which are collections...
        File start = new File(Utility.getCollectDir(Gatherer.config.gsdl_path));
        File cols[] = start.listFiles();
        ArrayTools.sort(cols);
        // We add their import directories, except for the model collection
        for(int i = 0; cols != null && i < cols.length; i++) {
            if (!cols[i].getName().equals(StaticStrings.MODEL_COLLECTION_NAME)) {
            File dirs[] = cols[i].listFiles();
            ArrayTools.sort(dirs);
            File import_dir = new File(cols[i], StaticStrings.IMPORT_FOLDER);
            if(import_dir.exists()) {
                BasicCollectionConfiguration collect_cfg = new BasicCollectionConfiguration(new File(cols[i], Utility.CONFIG_DIR));
                FileNode collection_root = new FileNode(import_dir, collect_cfg.toString(), true);
                collection_root.setParent(this);
                collection_root.setModel(model);
                // One last piece of magic so we can determine the current collection
                Collection collection = Gatherer.c_man.getCollection();
                if(collection != null) {
                collection_root.setCurrentCollection(cols[i].getName().equals(collection.getName()));
                }
                children.add(collection_root);
                collection_root = null;
            }
            import_dir = null;
            dirs = null;
            }
        }
        cols = null;
        model.nodeStructureChanged(this);
        }
        // General case: Only map if there are no children.
        else if(file != null && getAllowsChildren()) {
        File[] files = file.listFiles();
        if(files != null && files.length > 0) {
            // Sort the remaining files.
            Gatherer.println("Number of files to sort: " + files.length);
            ArrayTools.sort(files);
            Gatherer.println("Files sorted.");
            // Now add them to children.
            raw_children = new ArrayList();
            for(int i = 0; i < files.length; i++) {
            FileNode child = new FileNode(files[i], model, children_readonly);
            child.setParent(this);
            raw_children.add(child);
            }

            // Apply the filters set in the model.
            //if(model != null) {
            FileFilter[] filters = model.getFilters();
            for(int i = 0; filters != null && i < filters.length; i++) {
            files = ArrayTools.filter(files, filters[i].filter, filters[i].exclude);
            }
            //}

            // Now add them to children.
            for(int i = 0; i < files.length; i++) {
            FileNode child = new FileNode(files[i], model, children_readonly);
            int index = -1;
            if((index = raw_children.indexOf(child)) != -1) {
                children.add(raw_children.get(index));
            }
            else {
                child.setParent(this);
                children.add(child);
            }
            }
        }
        model.nodeStructureChanged(this);
        }
    }
    }

    /** Removes the child at index from the receiver. */
    public void remove(int index) {
    if(0 <= index && index < children.size()) {
        children.remove(index);
    }
    }

    /** Removes node from the receiver. */
    public void remove(MutableTreeNode node){
    int index = getIndex(node);
    if(index != -1) {
        children.remove(index);
    }
    }

    /** Removes the receiver from its parent. */
    public void removeFromParent() {
    parent.remove(this);
    parent = null;
    }

    public void setCurrentCollection(boolean current_collection) {
    this.current_collection = current_collection;
    }

    /* private void setChildrenReadOnly(boolean children_readonly) {
    this.children_readonly = children_readonly;
    } */

    public void setFile(File file) {
    this.file = file;
    }

    public void setModel(FileSystemModel model) {
    this.model = model;
    }

    public void setParent(MutableTreeNode parent) {
    this.parent = parent;
    }

    public void setReadOnly(boolean readonly) {
    this.readonly = readonly;
    }

    /** Resets the user object of the receiver to object. */
    public void setUserObject(Object object) {
    try {
        file = (File) object;
        title = null;
    }
    catch(Exception error) {
        error.printStackTrace();
    }
    }

    /** Retrieve the total number of child files for the file this node represents, irrespective of filters set
     * @return int
     */
    public int size() {
    if(raw_children != null) {
        return raw_children.size();
    }
    return 0;
    }

    public String toString() {
    if(title == null) {
        if(isFileSystemRoot()) {
        title = file.getAbsolutePath();
        }
        else {
        title = file.getName();
        }
    }
    return title;
    }

    /** Unmap this nodes children. */
    public void unmap() {
    // You cannot unmap nodes that have no file basis.
    if(file != null || title.equals(Dictionary.get("Tree.World"))) {
        ///atherer.println("Unmap: " + this);
        children = null;
        raw_children = null;
    }
    else {
        ///ystem.err.println("No file for " + this + " - can't unmap.");
    }
    }

    private class FileEnumeration
    implements Enumeration {
    private int index = 0;
    /** Tests if this enumeration contains more elements. */
    public boolean hasMoreElements() {
        return (index < children.size());
    }
    /** Returns the next element of this enumeration if this enumeration object has at least one more element to provide. */
    public Object nextElement() {
        Object result = null;
        if(index < children.size()) {
        result = children.get(index);
        index++;
        }
        return result;
    }
    }
}