package usda.weru.util.tree;

import java.awt.EventQueue;
import de.schlichtherle.truezip.file.TFile;
import java.awt.Cursor;
import static java.awt.Cursor.getPredefinedCursor;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.FileFilter;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import javax.swing.tree.TreeNode;
import static usda.weru.remoteDataAccess.csip.CsipInputControllerCachingSupport.PROP_CSIP_BGCATALOG_COMPLETE;
import static usda.weru.remoteDataAccess.csip.CsipInputControllerCachingSupport.PROP_CSIP_BGCATALOG_STARTING;
import usda.weru.remoteDataAccess.csip.CsipLmodUtil;
import usda.weru.soil.SoilDatabase;
import usda.weru.util.About;
import usda.weru.util.ConfigData;
import usda.weru.util.wepsFileChooser2.WepsFileTypes2;
import usda.weru.weps.RunFileData;
import usda.weru.weps.Weps;
import static usda.weru.weps.gui.ConfigPanel_n.CSIP_SOIL_POLYGONSIZE_PROP;
import static usda.weru.remoteDataAccess.csip.crlmod.CsipInputContCrLmodBgCache.PROP_CSIP_BGFILLCACHE_COMPLETE_EXTERNAL;

public class WepsTreeModelSoil extends WepsTreeModel implements PropertyChangeListener, FileFilter {

    private static final long serialVersionUID = 1L;

    private List<SoilDatabase> databases;
    WepsTreeNodeSoilSdm sdmNode;
    WepsTreeNodeSoilCsip csipSoilNode;
    WepsTreeNodeFile csipSoilCacheNode;
    WepsTreeNodeSoilMdb mdbNode;

    public WepsTreeModelSoil(WepsTreeComboBox treeCombo, boolean useWaitCursor) {
        this (treeCombo, true, true, useWaitCursor);
    }
    
    public WepsTreeModelSoil(WepsTreeComboBox treeCombo, boolean includeProjectNode, boolean includeTemplateNode, boolean useWaitCursor) {
        super(treeCombo, includeProjectNode, includeTemplateNode,useWaitCursor);
        if (Weps.getInstance() == null) {
            System.err.println("WARNING: No WEPS Instance. Creating SWEEP Soil Tree.");
            build(true);
            setUseWaitCursor(true);
        } else if (Weps.getInstance().getRunFileData() != null) {
            Weps.getInstance().getRunFileData().addPropertyChangeListener(RunFileData.StrLatLong, this);
            ConfigData.getDefault().addPropertyChangeListener(CSIP_SOIL_POLYGONSIZE_PROP, this);
            build();
            setUseWaitCursor(true);
        }  
    }

    @Override
    public void refresh() {
        build();
    }
    
    public void build(boolean sweep) {
        super.build(false);
        sdmNode = new WepsTreeNodeSoilSdm();
        addNode(sdmNode);
        try{
            sdmNode.getNodeData();
        } catch(IOException e) {
            System.out.println("ERROR: Unable to properly initialize SSURGO Soil List.");
        }
    }
    
    @Override
    public void build() {
        super.build();
        
        TFile localSoil = new TFile(ConfigData.getDefault().getDataParsed(ConfigData.LocalSoilDB));
        //System.out.println("Local Soil Location: " + localSoil.getAbsolutePath());
        if(localSoil.exists() && localSoil.isDirectory()) {
            WepsTreeNodeFile localSoilDbDir = new WepsTreeNodeFile(localSoil, this);
            localSoilDbDir.setDisplayName("Local Soil Directory");
            addNode(localSoilDbDir);
        }
        
        TFile sdf = new TFile(ConfigData.getDefault().getDataParsed(ConfigData.SoilDB));
        if(sdf.exists() && sdf.isDirectory()) {
            WepsTreeNodeFile soilDataFile = new WepsTreeNodeFile(sdf, this);
            soilDataFile.setDisplayName("Soil Data Folder");
            addNode(soilDataFile);
        }
        
        if (includeTemplateNode && !isNRCSMode) {
            addTemplateNode(new TFile(ConfigData.getDefault().getDataParsed(ConfigData.SoilDB)));
        }
       
        databases = new LinkedList<>();
        
        csipSoilNode = new WepsTreeNodeSoilCsip();
        addNode(csipSoilNode);
        
        csipSoilCacheNode = new WepsTreeNodeFileSoilCache (new TFile(About.getWepsCacheDir(), CsipLmodUtil.WepsCacheDirNameSoil), this);
        addNode (csipSoilCacheNode, "Cached CSIP Soils");
        
        sdmNode = new WepsTreeNodeSoilSdm();
        addNode(sdmNode);
        
        csipSoilNode.getBackgroundPropertyChangeObject()
                    .addPropertyChangeListener(PROP_CSIP_BGCATALOG_STARTING, this);
        csipSoilNode.getBackgroundPropertyChangeObject()
                    .addPropertyChangeListener(PROP_CSIP_BGCATALOG_COMPLETE, this);
        
        // set the listener on the csipSoilNode, and when done, 
        // then the csipSoilCacheNode will get updated in propertyChange() 
        csipSoilNode.getBackgroundPropertyChangeObject()
                    .addPropertyChangeListener(PROP_CSIP_BGFILLCACHE_COMPLETE_EXTERNAL, this);
        
        if (!isNRCSMode) {
            TFile file = new TFile (ConfigData.getDefault().getDataParsed(ConfigData.SoilDB),"WEPS_baseline.mdb");
            if (file.exists()) {
                mdbNode = new WepsTreeNodeSoilMdb(file);
            addNode(mdbNode);
            }
        }
        
        
    }
    
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        super.propertyChange(evt);
        String propertyName = evt.getPropertyName();
        if (propertyName != null && propertyName.contentEquals(PROP_CSIP_BGCATALOG_STARTING)) {
            isLoading = true;
            if(treeCombo != null) {
                cursorSave = treeCombo.getCursor();
                if (cursorSave == getPredefinedCursor(Cursor.WAIT_CURSOR)) {
                    // If set to WAIT somewhere else, restore to default
                    cursorSave = getPredefinedCursor(Cursor.DEFAULT_CURSOR);
                }
                treeCombo.setCursor(getPredefinedCursor(Cursor.WAIT_CURSOR));
            }
            csipSoilNode.removeAllChildren();
            csipSoilNode.setTemporarilyClosed(true);
            nodeStructureChanged(csipSoilNode);

            nodeStructureChanged(csipSoilCacheNode);
        } else if (propertyName != null && propertyName.contentEquals(PROP_CSIP_BGCATALOG_COMPLETE)) {
            
            boolean inCache = (evt.getNewValue() instanceof Boolean) ? ((Boolean)evt.getNewValue()) : false;
            if (inCache) {
                csipSoilNode.setTemporarilyClosed(false);
                if(treeCombo != null) {
                    treeCombo.setCursor(cursorSave);
                }
            }
            
            csipSoilNode.refreshChildren();
            nodeStructureChanged(csipSoilNode);
            isLoading = false;
            //treeCombo.setCursor(cursorSave);
        } else if (propertyName != null && propertyName.contentEquals(PROP_CSIP_BGFILLCACHE_COMPLETE_EXTERNAL)) {

            csipSoilNode.setTemporarilyClosed(false);
            csipSoilNode.refreshChildren();
            nodeStructureChanged(csipSoilNode);
            
            csipSoilCacheNode.refreshChildren();
            nodeStructureChanged(csipSoilCacheNode);
            
            isLoading = false;
            treeCombo.setCursor(cursorSave);
        }
    }

    @Override
    public void nodeStructureChanged(final TreeNode node) {
        try {
            super.nodeStructureChanged(node);
        } catch (Exception e) {
            EventQueue.invokeLater(new Runnable() {

                @Override
                public void run() {
                    //use the super so if the second time there is still an exception then the user will be alerted.
                    WepsTreeModelSoil.super.nodeStructureChanged(node);
                }
            });
        }
    }

    public List<SoilDatabase> getDatabases() {
        return databases;
    }

    @Override
    public boolean accept(java.io.File file) {
        return ( file.isDirectory() || file.getName().toLowerCase().trim().endsWith(WepsFileTypes2.Soil.getExtension()) );
    }

}