/*
 * IfcSoilDatabase.java
 *
 * Created on April 19, 2007, 2:34 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package usda.weru.soil;

import de.schlichtherle.io.File;

import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import javax.swing.ProgressMonitor;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import usda.weru.util.AbstractLazyLoadingTreeNode;

/**
 *
 * @author Joseph Levin
 */
public class IfcSoilDatabase implements SoilDatabase{
    private static final String[] IGNORE = {"svn", "cvs", ".cvs", ".svn"};
    protected File c_file;
    protected String c_name;
    protected DefaultMutableTreeNode c_rootNode;
    /** Creates a new instance of IfcSoilDatabase
     * @param file
     */
    public IfcSoilDatabase(File file) {
        c_file = file;
    }
    
    public IfcSoilDatabase(File file, String name) {
        this(file);
        c_name = name;
    }
    
    @Override
    public MutableTreeNode[] createNodes() {
        if (c_rootNode == null){
            if (c_file.isDirectory()){
                //Create Directory node
                c_rootNode = new FolderNode(c_file, c_name);
            } else if (c_file.getName().toLowerCase().endsWith(".ifc")){
                c_rootNode = new IfcNode(c_file);                
            }
        }
        
        return new MutableTreeNode[]{c_rootNode};

    }
    
    @Override
    public boolean isSoil(TreeNode node) {
        if (node != null && node instanceof IfcNode){
            IfcNode n = (IfcNode) node;
            return c_rootNode.equals(node) || c_rootNode.isNodeDescendant(n);
        }
        return false;
    }
    
    @Override
    public IFC getIfcFromNode(TreeNode node, ProgressMonitor progress) {
        progress.setMinimum(0);
        progress.setMaximum(10);
        progress.setProgress(0);
        
        if (isSoil(node)){
            progress.setProgress(2);
            IfcNode ifcNode = (IfcNode) node;
            IFC ifc = new IFC();
            try{
                progress.setProgress(5);
                progress.setNote(ifcNode.getFile().getName());
                ifc.readIfc(ifcNode.getFile());
                ifc.sendErrorsToInternalVariable();
                progress.setProgress(10);
                
                return ifc;
            } catch(FileNotFoundException fnfe){}
        }
        return null;
    }
    
    @Override
    public void dispose() {
        
    }
    
    
    class FolderNode extends AbstractLazyLoadingTreeNode{
        private File c_file;
        public FolderNode(File file){
            c_file = file;
            setUserObject(file.getName());
            setAllowsChildren(true);
        }
        
        public FolderNode(File file, String displayName){
            c_file = file;
            if (displayName != null){
                setUserObject(displayName);
            } else{
                setUserObject(file.getPath());
            }
            setAllowsChildren(true);
        }
        
        public boolean isLeaf() {
            return false;
        }
        
        @Override
        protected MutableTreeNode[] createChildren() {
            List <MutableTreeNode> temp = new LinkedList <MutableTreeNode> ();
            java.io.File[] fileList = c_file.listFiles();

            Files:
                for (java.io.File file : fileList){
                    if (file.isDirectory()){
                        //Ignore
                        for (String ignore : IGNORE){
                            if (file.getName().equalsIgnoreCase(ignore)){
                                continue Files;
                            }
                        }
                        //Create Directory node
                        temp.add(new FolderNode(new File(file)));
                    } else if (file.getName().toLowerCase().endsWith(".ifc")){
                        //create soil node
                        temp.add(new IfcNode(new File(file)));
                    }
                }
                Collections.sort(temp, new NodeComparator());
                MutableTreeNode[] nodes = new MutableTreeNode[0];
                return temp.toArray(nodes);
        }
        
    }
    
    static class NodeComparator implements Comparator <MutableTreeNode>{
        @Override
        public int compare(MutableTreeNode o1, MutableTreeNode o2) {
            boolean isDir1 = o1 instanceof FolderNode;
            boolean isDir2 = o2 instanceof FolderNode;
            
            if (isDir1 && !isDir2){
                return -1;
            } else if (!isDir1 && isDir2){
                return 1;
            } else{
                //Sort by name
                return o1.toString().compareTo(o2.toString());
            }
        }
        
    }
    
    static class IfcNode extends DefaultMutableTreeNode{
        private File c_file;
        
        public IfcNode(File file){
            c_file = file;
            setUserObject(file.getName());
        }
        
        public File getFile(){
            return c_file;
        }
    }
    
    
    
}