package org.ala.spatial.analysis.web;

import au.com.bytecode.opencsv.CSVReader;
import au.org.emii.portal.composer.UtilityComposer;
import au.org.emii.portal.menu.MapLayer;
import au.org.emii.portal.settings.SettingsSupplementary;
import au.org.emii.portal.util.LayerSelection;
import au.org.emii.portal.util.LayerUtilities;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.ala.logger.client.RemoteLogger;
import org.ala.spatial.data.Query;
import org.ala.spatial.util.CommonData;
import org.ala.spatial.data.BiocacheQuery;
import org.ala.spatial.data.QueryUtil;
import org.ala.spatial.data.UploadQuery;
import org.ala.spatial.util.SelectedArea;
import org.ala.spatial.util.UserData;
import org.ala.spatial.util.Util;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.lang.StringUtils;
import org.zkoss.util.media.Media;
import org.zkoss.zk.ui.Components;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.SuspendNotAllowedException;
import org.zkoss.zk.ui.event.CheckEvent;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zk.ui.event.Events;
import org.zkoss.zk.ui.event.ForwardEvent;
import org.zkoss.zk.ui.event.UploadEvent;
import org.zkoss.zk.ui.util.Clients;
import org.zkoss.zul.Button;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Comboitem;
import org.zkoss.zul.Div;
import org.zkoss.zul.Doublebox;
import org.zkoss.zul.Filedownload;
import org.zkoss.zul.Fileupload;
import org.zkoss.zul.Image;
import org.zkoss.zul.Label;
import org.zkoss.zul.Listbox;
import org.zkoss.zul.Listcell;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.ListitemRenderer;
import org.zkoss.zul.Menuitem;
import org.zkoss.zul.Menupopup;
import org.zkoss.zul.Messagebox;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Radiogroup;
import org.zkoss.zul.Textbox;
import org.zkoss.zul.Vbox;
import org.zkoss.zul.Window;

/**
 * 
 * TODO: NC 20130712 - This class really needs to be reviewed when we get a chance. 
 * 
 * @author ajay
 */
public class AddToolComposer extends UtilityComposer {

    SettingsSupplementary settingsSupplementary;
    RemoteLogger remoteLogger;
    int currentStep = 1, totalSteps = 5;
    Map<String, Object> params;
    String selectedMethod = "";
    String pid = "";
    Radiogroup rgArea, rgAreaHighlight, rgSpecies, rgSpeciesBk;
    Radio rMaxent, rAloc, rScatterplot, rGdm, rTabulation;
    Radio rSpeciesAll, rSpeciesMapped, rSpeciesSearch, rSpeciesUploadLSID, rSpeciesUploadSpecies, rMultiple;
    Radio rSpeciesNoneBk, rSpeciesAllBk, rSpeciesMappedBk, rSpeciesSearchBk, rSpeciesUploadLSIDBk, rSpeciesUploadSpeciesBk, rMultipleBk;
    Radio rAreaWorld, rAreaCustom, rAreaWorldHighlight, rAreaSelected;
    Button btnCancel, btnOk, btnBack, btnHelp;
    Textbox tToolName;
    SpeciesAutoCompleteComponent searchSpeciesACComp, bgSearchSpeciesACComp;
    //SpeciesAutoComplete searchSpeciesAuto, bgSearchSpeciesAuto;
    EnvironmentalList lbListLayers;
    Div divSpeciesSearch, divSpeciesSearchBk;
    EnvLayersCombobox cbLayer1;
    EnvLayersCombobox cbLayer2;
    String winTop = "300px";
    String winLeft = "500px";
    // boolean setCustomArea = false;
    boolean hasCustomArea = false;
    MapLayer prevTopArea = null;
    Fileupload fileUpload;
    SelectedLayersCombobox selectedLayersCombobox;
    Div tlinfo;
    Textbox tLayerList;
    Div dLayerSummary;
    EnvLayersCombobox cbLayer, cbLayerEnvironmentalOnly, cbLayerMix;
    Button bLayerListDownload1;
    Button bLayerListDownload2;
    Label lLayersSelected, lendemicNote;
    Button btnClearSelection;
    Menupopup mpLayer2, mpLayer1;
    Doublebox dResolution;
    Vbox vboxMultiple, vboxMultipleBk;
    SpeciesAutoCompleteComponent mSearchSpeciesACComp, mSearchSpeciesACCompBk;
    //SpeciesAutoComplete mSearchSpeciesAuto, mSearchSpeciesAutoBk;
    Textbox tMultiple, tMultipleBk;
    Listbox lMultiple, lMultipleBk;
    boolean includeAnalysisLayers = true;
    boolean includeContextualLayers = false;
    boolean singleLayerDomain = true;
    boolean fullList = false;
    boolean includeAnalysisLayersForUploadQuery = false;
    boolean includeAnalysisLayersForAnyQuery = false;
    boolean mpLayersIncludeAnalysisLayers = false;
    Checkbox chkGeoKosherTrue, chkGeoKosherFalse,  chkEndemicSpecies;
    Checkbox chkGeoKosherTrueBk, chkGeoKosherFalseBk;
    boolean[] defaultGeospatialKosher = { true, true, false };

    private Label lEstimateMessage;
    private Button bLogin;
    private Div notLoggedIn;
    private Div isLoggedIn;
    boolean isBackgroundProcess = true;
    boolean hasEstimated = false;
    
    //stuff for the dynamic species list inclusion
    private Vbox vboxImportSL, vboxImportSLBk; //the box layout for the import species list
    private SpeciesListListbox speciesListListbox,speciesListListboxBk;
    
    @Override
    public void afterCompose() {
        super.afterCompose();

        winTop = this.getTop();
        winLeft = this.getLeft();

        setupDefaultParams();
        setParams(Executions.getCurrent().getArg());

        //add the species lists stuff
        if(rSpeciesUploadLSID != null && this.hasFellow("splistbox")) {
            vboxImportSL = (Vbox)this.getFellow("splistbox").getFellow("vboxImportSL");
            speciesListListbox = (SpeciesListListbox)this.getFellow("splistbox").getFellow("speciesListListbox");
            speciesListListbox.addEventListener("onSlCheckBoxChanged", new EventListener(){
              @Override
              public void onEvent(Event event) throws Exception {
                  btnOk.setDisabled((Integer)event.getData() == 0);
              }
            });
        }

        if(rSpeciesUploadLSIDBk != null && this.hasFellow("splistboxbk")){
            vboxImportSLBk = (Vbox)this.getFellow("splistboxbk").getFellow("vboxImportSL");
            speciesListListboxBk = (SpeciesListListbox)this.getFellow("splistboxbk").getFellow("speciesListListbox");
            speciesListListbox.addEventListener("onSlCheckBoxChanged", new EventListener(){
              @Override
              public void onEvent(Event event) throws Exception {
                  btnOk.setDisabled((Integer)event.getData() == 0);
              }
            });
        }
        
        updateWindowTitle();

        fixFocus();

        if (lbListLayers != null) {
            lbListLayers.clearSelection();
            lbListLayers.updateDistances();
        }

        // init mpLayer1 and mpLayer2
        if (mpLayer1 != null && mpLayer2 != null) {
            for (MapLayer ml : getMapComposer().getGridLayers()) {
                addToMpLayers(ml, false);
            }
        }

        if (mSearchSpeciesACComp != null) {
            mSearchSpeciesACComp.getAutoComplete().setBiocacheOnly(true);
        }
        if (mSearchSpeciesACCompBk != null) {
            mSearchSpeciesACCompBk.getAutoComplete().setBiocacheOnly(true);
        }

        // init includeLayers
        if (cbLayer != null) {
            cbLayer.setIncludeLayers("AllLayers");
            cbLayer.refresh("");
        }
        if (cbLayerEnvironmentalOnly != null) {
            cbLayerEnvironmentalOnly.setIncludeLayers("EnvironmentalLayers");
            cbLayerEnvironmentalOnly.refresh("");
        }
        if (cbLayer1 != null) {
            cbLayer1.setIncludeLayers("EnvironmentalLayers");
            cbLayer1.refresh("");
        }
        if (cbLayer2 != null) {
            cbLayer2.setIncludeLayers("EnvironmentalLayers");
            cbLayer2.refresh("");
        }
        if (cbLayerMix != null) {
            cbLayerMix.setIncludeLayers("MixLayers");
            cbLayerMix.refresh("");
        }

        updateDefaultGeospatialKosherValues();
    }

    void updateDefaultGeospatialKosherValues() {
        if (chkGeoKosherTrue != null) {
            defaultGeospatialKosher[0] = chkGeoKosherTrue.isChecked();
        }
        if (chkGeoKosherFalse != null) {
            defaultGeospatialKosher[1] = chkGeoKosherFalse.isChecked();
        }
        
    }

    void addToMpLayers(MapLayer ml, boolean analysis) {
        // get layer name
        String name = null;
        String url = ml.getUri();
        if (analysis) {
            name = ml.getName();
        } else {
            int p1 = url.indexOf("ALA:") + 4;
            int p2 = url.indexOf("&", p1);
            if (p1 > 4) {
                if (p2 < 0) {
                    p2 = url.length();
                }
                name = url.substring(p1, p2);
            }
        }

        // cbLayer1
        Menuitem mi = new Menuitem(ml.getDisplayName());
        mi.setValue(name);
        mi.addEventListener("onClick", new EventListener() {

            public void onEvent(Event event) throws Exception {
                Menuitem mi = (Menuitem) event.getTarget();
                cbLayer1.setValue(mi.getValue() + " ");
                cbLayer1.refresh(mi.getValue());
                for (Object o : cbLayer1.getItems()) {
                    Comboitem ci = (Comboitem) o;
                    JSONObject jo = (JSONObject) ci.getValue();
                    if (jo.getString("name").equals(mi.getValue())) {
                        cbLayer1.setSelectedItem(ci);
                        cbLayer1.setText(ci.getLabel());
                        toggles();
                        return;
                    }
                }
            }
        });
        mi.setParent(mpLayer1);

        // cbLayer2
        mi = new Menuitem(ml.getDisplayName());
        mi.setValue(name);
        mi.addEventListener("onClick", new EventListener() {

            public void onEvent(Event event) throws Exception {
                Menuitem mi = (Menuitem) event.getTarget();
                cbLayer2.setValue(mi.getValue() + " ");
                cbLayer2.refresh(mi.getValue());
                for (Object o : cbLayer2.getItems()) {
                    Comboitem ci = (Comboitem) o;
                    JSONObject jo = (JSONObject) ci.getValue();
                    if (jo.getString("name").equals(mi.getValue())) {
                        cbLayer2.setSelectedItem(ci);
                        cbLayer2.setText(ci.getLabel());
                        toggles();
                        return;
                    }
                }
            }
        });
        mi.setParent(mpLayer2);
    }

    private void setupDefaultParams() {
        Hashtable<String, Object> p = new Hashtable<String, Object>();
        p.put("step1", "Select area(s)");
        p.put("step2", "Select species(s)");
        p.put("step3", "Select grid(s)");
        p.put("step4", "Select your analytical options");
        p.put("step5", "Name your output for");

        if (params == null) {
            params = p;
        } else {
            setParams(p);
        }

        Div currentDiv = (Div) getFellowIfAny("atstep" + currentStep);
        btnOk.setLabel("Next >");
    }

    public void updateWindowTitle() {
        this.setTitle("Step " + currentStep + " of " + totalSteps + " - " + selectedMethod);
    }

    public void updateName(String name) {
        if (tToolName != null) {
            tToolName.setValue(name);
        }
    }

    private void loadSummaryDetails() {
        try {
            Div atsummary = (Div) getFellowIfAny("atsummary");
            if (atsummary != null) {
                String summary = "";
                summary += "<strong>Analytical tool</strong>: " + selectedMethod;
                summary += "<strong>Area</strong>: ";
                summary += "<strong>Species</strong>: ";
                summary += "<strong>Grids</strong>: ";
                summary += "<strong>Additional options</strong>: ";
                atsummary.setContext(summary);
            }
        } catch (Exception e) {
        }
    }

    public void setParams(Map<String, Object> params) {
        // iterate thru' the passed params and load them into the
        // existing default params
        if (params == null) {
            setupDefaultParams();
        }
        if (params != null && params.keySet() != null && params.keySet().iterator() != null) {
            Iterator<String> it = params.keySet().iterator();
            while (it.hasNext()) {
                String key = it.next();
                this.params.put(key, params.get(key));
            }
        } else {
            this.params = params;
        }
    }

    public void loadSpeciesLayers() {
        loadSpeciesLayers(false);
    }

    public void loadSpeciesLayers(boolean biocacheOnly) {
        try {

            Radiogroup rgSpecies = (Radiogroup) getFellowIfAny("rgSpecies");
            Radio rSpeciesMapped = (Radio) getFellowIfAny("rSpeciesMapped");

            List<MapLayer> layers = getMapComposer().getSpeciesLayers();

            Radio selectedSpecies = null;
            String selectedSpeciesLayer = (String) params.get("speciesLayerName");
            int speciesLayersCount = 0;

            for (int i = 0; i < layers.size(); i++) {
                MapLayer lyr = layers.get(i);
                if (biocacheOnly && lyr.getData("query") != null && !(lyr.getData("query") instanceof BiocacheQuery)) {
                    continue;
                }
                if (lyr.getSubType() != LayerUtilities.SPECIES_UPLOAD) {
                    speciesLayersCount++;
                }

                Radio rSp = new Radio(lyr.getDisplayName());
                rSp.setValue(lyr.getName());
                rSp.setId(lyr.getName().replaceAll(" ", ""));
                rgSpecies.insertBefore(rSp, rSpeciesMapped);

                if (selectedSpeciesLayer != null && rSp.getValue().equals(selectedSpeciesLayer)) {
                    selectedSpecies = rSp;
                }
            }

            if (speciesLayersCount > 1) {
                rSpeciesMapped.setLabel("All " + speciesLayersCount + " species currently mapped (excludes coordinate uploads)");
            } else {
                rSpeciesMapped.setVisible(false);
            }

            if (selectedSpecies != null) {
                rgSpecies.setSelectedItem(selectedSpecies);
            } else if (selectedSpeciesLayer != null && selectedSpeciesLayer.equals("none")) {
                rgSpecies.setSelectedItem(rSpeciesAll);
            } else if (layers.size() > 0) {
                rgSpecies.setSelectedItem(rgSpecies.getItemAtIndex(1));
            } else {
                for (int i = 0; i < rgSpecies.getItemCount(); i++) {
                    if (rgSpecies.getItemAtIndex(i).isVisible() && rgSpecies.getItemAtIndex(i) != rSpeciesAll) {
                        rgSpecies.setSelectedItem(rgSpecies.getItemAtIndex(i));
                        break;
                    }
                }
            }

            updateGeospatialKosherCheckboxes();
        } catch (Exception e) {
            logger.error("Unable to load species layers:", e);
            //e.printStackTrace(System.out);
        }
    }

    public void loadSpeciesLayersBk() {
        try {
            Radiogroup rgSpecies = (Radiogroup) getFellowIfAny("rgSpeciesBk");

            List<MapLayer> layers = getMapComposer().getSpeciesLayers();
            int speciesLayersCount = 0;

            for (int i = 0; i < layers.size(); i++) {
                MapLayer lyr = layers.get(i);
                if (lyr.getSubType() != LayerUtilities.SPECIES_UPLOAD) {
                    speciesLayersCount++;
                }

                Radio rSp = new Radio(lyr.getDisplayName());
                rSp.setValue(lyr.getName());
                rSp.setId(lyr.getName().replaceAll(" ", "") + "__bk");
                rgSpecies.insertBefore(rSp, rSpeciesMappedBk);
            }

            if (speciesLayersCount > 1) {
                rSpeciesMappedBk.setLabel("All " + speciesLayersCount + " species currently mapped (excludes coordinate uploads)");
            } else {
                rSpeciesMappedBk.setVisible(false);
            }

            updateGeospatialKosherCheckboxesBk();
        } catch (Exception e) {
            logger.error("Unable to load species layers:", e);            
        }
    }

    public void loadAreaLayers() {
        loadAreaLayers(null);
    }

    public void loadAreaLayers(String selectedAreaName) {
        try {
            Radiogroup rgArea = (Radiogroup) getFellowIfAny("rgArea");
            // remove all radio buttons that don't have an id
            for (int i = rgArea.getItemCount() - 1; i >= 0; i--) {
                String id = ((Radio) rgArea.getItems().get(i)).getId();
                if (id == null || id.length() == 0) {
                    rgArea.removeItemAt(i);
                } else {
                    rgArea.getItemAtIndex(i).setSelected(false);
                }
            }

            Radio rAreaCurrent = (Radio) getFellowIfAny("rAreaCurrent");

            String selectedLayerName = (String) params.get("polygonLayerName");
            Radio rSelectedLayer = null;

            StringBuilder allWKT = new StringBuilder();
            int count_not_envelopes = 0;
            List<MapLayer> layers = getMapComposer().getPolygonLayers();
            for (int i = 0; i < layers.size(); i++) {
                MapLayer lyr = layers.get(i);
                Radio rAr = new Radio(lyr.getDisplayName());
                rAr.setValue(lyr.getWKT());

                if (!lyr.getWKT().contains("ENVELOPE")) {
                    if (count_not_envelopes > 0) {
                        allWKT.append(',');
                    }
                    count_not_envelopes++;
                    String wkt = lyr.getWKT();
                    if (wkt.startsWith("GEOMETRYCOLLECTION(")) {
                        wkt = wkt.substring("GEOMETRYCOLLECTION(".length(), wkt.length() - 1);
                    }
                    allWKT.append(wkt);
                }

                rAr.setParent(rgArea);
                rgArea.insertBefore(rAr, rAreaCurrent);

                if (selectedLayerName != null && lyr.getName().equals(selectedLayerName)) {
                    rSelectedLayer = rAr;
                    rAreaSelected = rAr;
                }
            }

            if (!layers.isEmpty() && count_not_envelopes > 1) {
                Radio rAr = new Radio("All area layers" + ((count_not_envelopes < layers.size()) ? " (excluding Environmental Envelopes)" : ""));
                rAr.setValue("GEOMETRYCOLLECTION(" + allWKT.toString() + ")");
                rAr.setParent(rgArea);
                rgArea.insertBefore(rAr, rAreaCurrent);
            }

            if (selectedAreaName != null && !selectedAreaName.equals("")) {
                for (int i = 0; i < rgArea.getItemCount(); i++) {
                    if (rgArea.getItemAtIndex(i).isVisible() && rgArea.getItemAtIndex(i).getLabel().equals(selectedAreaName)) {
                        rAreaSelected = rgArea.getItemAtIndex(i);
                        logger.debug("2.resetting indexToSelect = " + i);
                        rgArea.setSelectedItem(rAreaSelected);
                        break;
                    }
                }
            } else if (rSelectedLayer != null) {
                rAreaSelected = rSelectedLayer;
                rgArea.setSelectedItem(rAreaSelected);
            } else if (selectedLayerName != null && selectedLayerName.equals("none")) {
                rgArea.setSelectedItem(rAreaWorld);
                rAreaSelected = rAreaWorld;
                rgArea.setSelectedItem(rAreaSelected);
            } else {
                for (int i = 0; i < rgArea.getItemCount(); i++) {
                    if (rgArea.getItemAtIndex(i).isVisible()) {
                        rAreaSelected = rgArea.getItemAtIndex(i);
                        rgArea.setSelectedItem(rAreaSelected);
                        break;
                    }
                }
            }

            if (chkEndemicSpecies != null) {
                updateEndemicCheckBox();
            }

            Clients.evalJavaScript("jq('#" + rAreaSelected.getUuid() + "-real').attr('checked', true);");

        } catch (Exception e) {
            logger.error("Unable to load active area layers:", e);            
        }
    }

    public void loadAreaHighlightLayers(String selectedAreaName) {
        try {
            Radiogroup rgArea = (Radiogroup) getFellowIfAny("rgAreaHighlight");
            // remove all radio buttons that don't have an id
            for (int i = rgArea.getItemCount() - 1; i >= 0; i--) {
                String id = ((Radio) rgArea.getItems().get(i)).getId();
                if (id == null || id.length() == 0) {
                    rgArea.removeItemAt(i);
                } else {
                    rgArea.getItemAtIndex(i).setSelected(false);
                }
            }

            Radio rAreaCurrentHighlight = (Radio) getFellowIfAny("rAreaCurrentHighlight");

            String selectedLayerName = (String) params.get("polygonLayerName");
            Radio rSelectedLayer = null;

            StringBuilder allWKT = new StringBuilder();
            int count_not_envelopes = 0;
            List<MapLayer> layers = getMapComposer().getPolygonLayers();
            for (int i = 0; i < layers.size(); i++) {
                MapLayer lyr = layers.get(i);
                Radio rAr = new Radio(lyr.getDisplayName());
                rAr.setValue(lyr.getWKT());

                if (!lyr.getWKT().contains("ENVELOPE")) {
                    if (count_not_envelopes > 0) {
                        allWKT.append(',');
                    }
                    count_not_envelopes++;
                    String wkt = lyr.getWKT();
                    if (wkt.startsWith("GEOMETRYCOLLECTION(")) {
                        wkt = wkt.substring("GEOMETRYCOLLECTION(".length(), wkt.length() - 1);
                    }
                    allWKT.append(wkt);
                }

                rAr.setParent(rgArea);
                rgArea.insertBefore(rAr, rAreaCurrentHighlight);

                if (selectedLayerName != null && lyr.getName().equals(selectedLayerName)) {
                    rSelectedLayer = rAr;
                    // rAreaSelected = rAr;
                }
            }

            if (!layers.isEmpty() && count_not_envelopes > 1) {
                Radio rAr = new Radio("All area layers" + ((count_not_envelopes < layers.size()) ? " (excluding Environmental Envelopes)" : ""));
                rAr.setValue("GEOMETRYCOLLECTION(" + allWKT.toString() + ")");
                rAr.setParent(rgArea);
                rgArea.insertBefore(rAr, rAreaCurrentHighlight);
            }

            if (selectedAreaName != null && !selectedAreaName.equals("")) {
                for (int i = 0; i < rgArea.getItemCount(); i++) {
                    if (rgArea.getItemAtIndex(i).isVisible() && rgArea.getItemAtIndex(i).getLabel().equals(selectedAreaName)) {
                        logger.debug("2.resetting indexToSelect = " + i);
                        rgArea.setSelectedItem(rgArea.getItemAtIndex(i));
                        break;
                    }
                }
            } else if (rSelectedLayer != null) {
                rgArea.setSelectedItem(rAreaSelected);
            } else if (selectedLayerName != null && selectedLayerName.equals("none")) {
                rgArea.setSelectedItem(rAreaWorld);
            } else {
                for (int i = 0; i < rgArea.getItemCount(); i++) {
                    if (rgArea.getItemAtIndex(i).isVisible()) {
                        // rAreaSelected = rgArea.getItemAtIndex(i);
                        rgArea.setSelectedItem(rgArea.getItemAtIndex(i));
                        break;
                    }
                }
            }
            Clients.evalJavaScript("jq('#" + rgArea.getSelectedItem().getUuid() + "-real').attr('checked', true);");

        } catch (Exception e) {
            logger.error("Unable to load active area layers:", e);            
        }
    }

    public void loadAreaLayersHighlight() {
        try {

            Radiogroup rgArea = (Radiogroup) getFellowIfAny("rgAreaHighlight");
            Radio rAreaCurrent = (Radio) getFellowIfAny("rAreaCurrentHighlight");
            Radio rAreaNone = (Radio) getFellowIfAny("rAreaNoneHighlight");

            List<MapLayer> layers = getMapComposer().getPolygonLayers();
            for (int i = 0; i < layers.size(); i++) {
                MapLayer lyr = layers.get(i);
                Radio rAr = new Radio(lyr.getDisplayName());
                rAr.setId(lyr.getName().replaceAll(" ", ""));
                rAr.setValue(lyr.getWKT());
                rAr.setParent(rgArea);
                rgArea.insertBefore(rAr, rAreaCurrent);
            }

            rAreaNone.setSelected(true);
        } catch (Exception e) {
            logger.error("Unable to load active area layers:", e);            
        }
    }

    public void loadGridLayers(boolean includeAnalysisLayers, boolean includeContextualLayers, boolean singleLayerDomain) {
        this.includeAnalysisLayers = includeAnalysisLayers;
        this.includeContextualLayers = includeContextualLayers;
        this.singleLayerDomain = singleLayerDomain;
        this.fullList = true;

        if (selectedLayersCombobox != null) {
            selectedLayersCombobox.init(getMapComposer().getLayerSelections(), getMapComposer(), false);
        }
        try {

            if (fullList) {
                lbListLayers.init(getMapComposer(), includeAnalysisLayers, !includeContextualLayers, singleLayerDomain);
                lbListLayers.updateDistances();
            } else {
                List<MapLayer> layers = getMapComposer().getPolygonLayers();
                for (int i = 0; i < layers.size(); i++) {
                    MapLayer lyr = layers.get(i);
                    // System.out.println(lyr.getDisplayName());
                }
            }

            String layers = (String) params.get("environmentalLayerName");
            if (layers != null) {
                lbListLayers.selectLayers(layers.split(","));
            }

            lbListLayers.renderAll();
        } catch (Exception e) {
            logger.error("Unable to load species layers:", e);            
        }
    }

    public void onCheck$rgArea(Event event) {
        if (rgArea == null) {
            return;
        }
        // setCustomArea = false;
        hasCustomArea = false;
        rAreaSelected = rgArea.getSelectedItem();
        try {
            rAreaSelected = (Radio) ((org.zkoss.zk.ui.event.ForwardEvent) event).getOrigin().getTarget();
        } catch (Exception e) {
        }
        if (rAreaSelected == rAreaCustom) {
            // setCustomArea = true;
            hasCustomArea = false;
        }

        
        // case for enabling the endemic checkbox
        // System.out.println("RADIO SELECTED = " + rAreaSelected.getValue());

        if (chkEndemicSpecies != null) {
            updateEndemicCheckBox();
        }
    }

    private void updateEndemicCheckBox() {
        // check to see if the area is within the required size...
        boolean showEndemic = false;
        String value = rAreaSelected.getValue();
        if (rAreaSelected != null) {
            if (value.equals("australia") || value.equals("world") || value.equals("custom")) {
                // System.out.println("Large areas");

            } else {

                String areaName = rAreaSelected.getLabel();
                MapLayer ml = getMapComposer().getMapLayer(areaName);
                String sarea = "";
                if (value.equals("current")) {
                    // check to see if the current extent is within the maximum
                    // area
                    SelectedArea sa = getSelectedArea();
                    sarea = sa.getKm2Area();
                } else if (ml != null) {
                    sarea = (String) ml.getData("area");
                    if (sarea == null)
                        sarea = ml.calculateAndStoreArea();
                } else {
                    // for 'all areas'
                    SelectedArea sa = new SelectedArea(null, rAreaSelected.getValue());
                    sarea = sa.getKm2Area();

                }
                try {
                    Float area = Float.parseFloat(sarea.replaceAll(",", ""));
                    showEndemic = (area <= CommonData.maxEndemicArea);
                } catch (NumberFormatException e) {

                }

            }
        }
        chkEndemicSpecies.setDisabled(!showEndemic);
        chkEndemicSpecies.setChecked(false);

        if(lendemicNote != null){
            if (showEndemic){
                lendemicNote.setValue("Please note this may take several minutes depending on the area selected.");
            } else{
                lendemicNote.setValue("The selected area is too large to be considered for endemic species.");
            }
        }
    }

    public void onCheck$rgAreaHighlight(Event event) {
        if (rgAreaHighlight == null) {
            return;
        }
        // setCustomArea = false;
        hasCustomArea = false;
        if (rgAreaHighlight.getSelectedItem().getId().equals("rAreaCustomHighlight")) {
            // setCustomArea = true;
            hasCustomArea = false;
        }
    }

    public void onCheck$rgSpecies(Event event) {
        if (rgSpecies == null) {
            return;
        }
        Radio selectedItem = rgSpecies.getSelectedItem();
        try {
            selectedItem = (Radio) ((org.zkoss.zk.ui.event.ForwardEvent) event).getOrigin().getTarget();
        } catch (Exception e) {
        }
        try {
            if(event != null&&selectedItem != rSpeciesUploadLSID){
                vboxImportSL.setVisible(false);
            }
            if(event != null && vboxImportSLBk != null && selectedItem != rSpeciesUploadLSIDBk){
                vboxImportSLBk.setVisible(false);
            }
            // Check to see if we are perform a normal or background upload
            if (rgSpecies != null && selectedItem == rSpeciesSearch) {
                if (divSpeciesSearch != null) {
                    divSpeciesSearch.setVisible(true);
                    vboxMultiple.setVisible(false);
                    if (event != null) {
                        toggles();
                    }
                    return;
                }
            }
            if (divSpeciesSearch != null) {
                divSpeciesSearch.setVisible(false);
            }

            if (selectedItem == rSpeciesUploadSpecies) {
                // btnOk.setVisible(false);
                // fileUpload.setVisible(true);                
                btnOk.setVisible(true);
                vboxMultiple.setVisible(false);
            } else if(selectedItem == rSpeciesUploadLSID) {
                btnOk.setDisabled(true);
                vboxImportSL.setVisible(true);
                vboxMultiple.setVisible(false);
            } else if (rMultiple != null && rMultiple.isSelected()) {
            
                vboxMultiple.setVisible(true);
            }  else {
                btnOk.setDisabled(false);
                vboxMultiple.setVisible(false);
            }

            if (event != null) {
                toggles();
            }

            // set default geospatial kosher checkboxes unless a map layers has
            // been chosen
            MapLayer ml = null;
            Query q = null;
            if (rgSpecies.getSelectedItem() != null && rgSpecies.getSelectedItem().getValue() != null && (ml = getMapComposer().getMapLayer(rgSpecies.getSelectedItem().getValue())) != null
                    && (q = (Query) ml.getData("query")) != null && q instanceof BiocacheQuery) {
                setGeospatialKosherCheckboxes(((BiocacheQuery) q).getGeospatialKosher());
            } else {
                setGeospatialKosherCheckboxes(defaultGeospatialKosher);
            }
            updateGeospatialKosherCheckboxes();
        } catch (Exception e) {
        }
    }

    public void onCheck$rgSpeciesBk(Event event) {
        if (rgSpeciesBk == null) {
            return;
        }
        Radio selectedItem = rgSpeciesBk.getSelectedItem();
        try {
            selectedItem = (Radio) ((org.zkoss.zk.ui.event.ForwardEvent) event).getOrigin().getTarget();
        } catch (Exception e) {
        }
        try {
          
          if(event != null&&selectedItem != rSpeciesUploadLSID){
              vboxImportSL.setVisible(false);
          }
          if(event != null &&vboxImportSLBk != null && selectedItem != rSpeciesUploadLSIDBk){
              vboxImportSLBk.setVisible(false);
          }
          
            if (rgSpeciesBk != null && selectedItem == rSpeciesSearchBk) {
                if (divSpeciesSearchBk != null) {
                    divSpeciesSearchBk.setVisible(true);
                    vboxMultipleBk.setVisible(false);
                    if (event != null) {
                        toggles();
                    }
                    return;
                }
            }

            if (divSpeciesSearchBk != null) {
                divSpeciesSearchBk.setVisible(false);
            }
            
            if(selectedItem == rSpeciesUploadLSIDBk) {
              btnOk.setDisabled(true);
              vboxImportSLBk.setVisible(true);
              vboxMultiple.setVisible(false);
            } else if (selectedItem == rSpeciesUploadSpeciesBk) {
                // btnOk.setVisible(false);
                // fileUpload.setVisible(true);
                btnOk.setVisible(true);
            }

            if (rMultipleBk != null && rMultipleBk.isSelected()) {
                vboxMultipleBk.setVisible(true);
            } else {
                vboxMultipleBk.setVisible(false);
            }

            if (event != null) {
                toggles();
            }

            // set default geospatial kosher checkboxes unless a map layers has
            // been chosen
            MapLayer ml = null;
            Query q = null;
            if (rgSpeciesBk.getSelectedItem() != null && rgSpeciesBk.getSelectedItem().getValue() != null && (ml = getMapComposer().getMapLayer(rgSpeciesBk.getSelectedItem().getValue())) != null
                    && (q = (Query) ml.getData("query")) != null && q instanceof BiocacheQuery) {
                setGeospatialKosherCheckboxesBk(((BiocacheQuery) q).getGeospatialKosher());
            } else {
                setGeospatialKosherCheckboxesBk(defaultGeospatialKosher);
            }
            updateGeospatialKosherCheckboxes();
            updateGeospatialKosherCheckboxesBk();
        } catch (Exception e) {
        }
    }

    public void onValueSelected$searchSpeciesACComp(Event event){
        toggles();
    }
//DELETE    
//    public void onSelect$searchSpeciesAuto(Event event) {
//        toggles();
//    }

    public void onClick$btnHelp(Event event) {
        String helpurl = "";

        if (selectedMethod.equals("Prediction")) {
            helpurl = "http://www.ala.org.au/spatial-portal-help/analysis-prediction-tab/";
        } else if (selectedMethod.equals("Sampling")) {
            helpurl = "http://www.ala.org.au/spatial-portal-help/analysis-sampling-tab/";
        } else if (selectedMethod.equals("Classification")) {
            helpurl = "http://www.ala.org.au/spatial-portal-help/analysis-classification-tab/";
        } else if (selectedMethod.equals("Scatterplot")) {
            helpurl = "http://www.ala.org.au/spatial-portal-help/scatterplot-tab/";
        }

        if (StringUtils.isNotBlank(helpurl)) {
            getMapComposer().activateLink(helpurl, "Help", false, "");
        }
    }

    public void onClick$btnCancel(Event event) {
        currentStep = 1;
        if (lbListLayers != null) {
            lbListLayers.clearSelection();
            toggles();
        }
        this.detach();
    }

    public void onClick$btnBack(Event event) {

        Div currentDiv = (Div) getFellowIfAny("atstep" + currentStep);
        Div nextDiv = (Div) getFellowIfAny("atstep" + (currentStep + 1));
        Div previousDiv = (currentStep > 1) ? ((Div) getFellowIfAny("atstep" + (currentStep - 1))) : null;

        if (currentDiv.getZclass().contains("first")) {
            btnBack.setDisabled(true);
        } else {
            currentDiv.setVisible(false);
            previousDiv.setVisible(true);

            Image currentStepCompletedImg = (Image) getFellowIfAny("imgCompletedStep" + (currentStep - 1));
            currentStepCompletedImg.setVisible(false);

            Label nextStepLabel = (Label) getFellowIfAny("lblStep" + (currentStep));
            nextStepLabel.setStyle("font-weight:normal");

            Label currentStepLabel = (Label) getFellowIfAny("lblStep" + (currentStep - 1));
            currentStepLabel.setStyle("font-weight:bold");

            currentStep--;

            if (previousDiv != null) {
                btnBack.setDisabled(((!previousDiv.getZclass().contains("first")) ? false : true));
            }
        }

        btnOk.setLabel("Next >");
        toggles();
        updateWindowTitle();
        displayTrafficLightInfo();

    }

    private void displayTrafficLightInfo() {
        if (tlinfo != null) {
            if (selectedMethod.equalsIgnoreCase("Prediction") && currentStep == 3) {
                tlinfo.setVisible(true);
            } else if (selectedMethod.equalsIgnoreCase("Classification") && currentStep == 2) {
                tlinfo.setVisible(true);
            } else if (selectedMethod.equalsIgnoreCase("GDM") && currentStep == 3) {
                tlinfo.setVisible(true);
            } else if (selectedMethod.equalsIgnoreCase("Sampling") && currentStep == 3) {
                tlinfo.setVisible(true);
            } else {
                tlinfo.setVisible(false);
            }
        }
    }

    public void resetWindowFromSpeciesUpload(String lsid, String type) {
        try {
            if (type.compareTo("cancel") == 0) {
                fixFocus();
                return;
            }
            if (type.compareTo("normal") == 0) {
                setLsid(lsid);
            }
            if (type.compareTo("bk") == 0) {
                setLsidBk(lsid);
            }
            if (type.compareTo("assemblage") == 0) {
                setMultipleLsids(lsid);
            }
            if (type.compareTo("assemblagebk") == 0) {
                setMultipleLsidsBk(lsid);
            }
        } catch (Exception e) {
            logger.error("Exception when resetting analysis window", e);            
        }
    }

    public void resetWindow(String selectedArea) {
        try {

            if (selectedArea == null) {
                hasCustomArea = false;
            } else if (selectedArea.trim().equals("")) {
                hasCustomArea = false;
            } else {
                hasCustomArea = true;
            }

            boolean ok = false;
            if (hasCustomArea) {
                MapLayer curTopArea = null;
                List<MapLayer> layers = getMapComposer().getPolygonLayers();
                if (layers != null && layers.size() > 0) {
                    curTopArea = layers.get(0);
                } else {
                    curTopArea = null;
                }

                if (curTopArea != prevTopArea) {
                    if (isAreaHighlightTab()) {
                        loadAreaHighlightLayers(curTopArea.getDisplayName());
                    } else if (isAreaTab()) {
                        loadAreaLayers(curTopArea.getDisplayName());
                    }

                    ok = true;
                }
            }
            this.setTop(winTop);
            this.setLeft(winLeft);

            this.doModal();

            if (ok) {
                onClick$btnOk(null);
                hasCustomArea = false;
            }

            fixFocus();
        } catch (InterruptedException ex) {
            logger.error("InterruptedException when resetting analysis window", ex);            
        } catch (SuspendNotAllowedException ex) {
            logger.error("Exception when resetting analysis window", ex);            
        }
    }

    public void onClick$btnOk(Event event) {
        if (btnOk.isDisabled()) {
            return;
        }
        boolean successful = false;
        try {
          
            if (!hasCustomArea && (isAreaCustom() || isAreaHighlightCustom())) {
                this.doOverlapped();
                this.setTop("-9999px");
                this.setLeft("-9999px");

                Map<String, Object> winProps = new HashMap<String, Object>();
                winProps.put("parent", this);
                winProps.put("parentname", "AddTool");
                winProps.put("selectedMethod", selectedMethod);

                List<MapLayer> layers = getMapComposer().getPolygonLayers();
                if (layers != null && layers.size() > 0) {
                    prevTopArea = layers.get(0);
                } else {
                    prevTopArea = null;
                }

                Window window = (Window) Executions.createComponents("WEB-INF/zul/AddArea.zul", this, winProps);
                window.setAttribute("winProps", winProps, true);
                window.doModal();

                return;
            }

            Div currentDiv = (Div) getFellowIfAny("atstep" + currentStep);
            Div nextDiv = (Div) getFellowIfAny("atstep" + (currentStep + 1));
            Div previousDiv = (currentStep > 1) ? ((Div) getFellowIfAny("atstep" + (currentStep + 1))) : null;
            
          //check to see if one of the "create new species list" radio buttons is seleceted
          //ONLY perform these checks if the "lMultiple" or lMultipleBk" is on the current page
            if(Components.isAncestor(currentDiv, lMultiple)&& rMultiple.isChecked()){
                // display the dialog and change the radio button to "use existing"...
              showExportSpeciesListDialog(lMultiple);
              return;
            } else if (Components.isAncestor(currentDiv, lMultipleBk)&& rMultipleBk.isChecked()){
                showExportSpeciesListDialog(lMultipleBk);
                return;
            }

            if (!currentDiv.getZclass().contains("last")) {
                if (currentDiv.getZclass().contains("species") && (rSpeciesUploadSpecies.isSelected())) {
                    Boolean test = currentDiv.getZclass().contains("species") && (rSpeciesUploadSpecies.isSelected());
                    logger.debug("test=" + test);
                    onClick$btnUpload(event);

                } else {
                    currentDiv.setVisible(false);
                    nextDiv.setVisible(true);

                    Image previousStepCompletedImg = (Image) getFellowIfAny("imgCompletedStep" + (currentStep));
                    previousStepCompletedImg.setVisible(true);

                    Label previousStepLabel = (Label) getFellowIfAny("lblStep" + (currentStep));
                    previousStepLabel.setStyle("font-weight:normal");

                    Label currentStepLabel = (Label) getFellowIfAny("lblStep" + (currentStep + 1));
                    currentStepLabel.setStyle("font-weight:bold");

                    // now include the extra options for step 4
                    if (nextDiv != null) {

                        if (nextDiv.getZclass().contains("last")) {
                            loadSummaryDetails();
                            onLastPanel();
                        }
                        btnOk.setLabel("Next >");
                    }

                    currentStep++;

                    successful = true;
                }
            } else {
                saveLayerSelection();

                successful = onFinish();

                if (successful) {
                    currentStep = 1;
                }
            }

            if (successful) {
                if (nextDiv != null && rgSpecies != null && (includeAnalysisLayersForUploadQuery || includeAnalysisLayersForAnyQuery)) {
                    Query q = getSelectedSpecies();
                    if (q != null) {
                        boolean test = (includeAnalysisLayersForAnyQuery || (q instanceof UploadQuery));

                        if (selectedLayersCombobox != null) {
                            if ((selectedLayersCombobox.getIncludeAnalysisLayers()) != test) {
                                selectedLayersCombobox.init(getMapComposer().getLayerSelections(), getMapComposer(), test);
                            }
                        }
                        if (lbListLayers != null) {
                            if ((lbListLayers.getIncludeAnalysisLayers()) != test) {
                                String[] selectedLayers = lbListLayers.getSelectedLayers();
                                lbListLayers.init(getMapComposer(), test, !includeContextualLayers, singleLayerDomain);
                                lbListLayers.updateDistances();

                                if (selectedLayers != null && selectedLayers.length > 0) {
                                    lbListLayers.selectLayers(selectedLayers);
                                }

                                lbListLayers.renderAll();
                            }
                        }
                        if (cbLayer != null) {
                            if ((cbLayer.getIncludeAnalysisLayers()) != test) {
                                cbLayer.setIncludeAnalysisLayers(test);
                            }
                        }
                        if (cbLayerEnvironmentalOnly != null) {
                            if ((cbLayerEnvironmentalOnly.getIncludeAnalysisLayers()) != test) {
                                cbLayerEnvironmentalOnly.setIncludeAnalysisLayers(test);
                            }
                        }
                        if (cbLayer1 != null) {
                            if ((cbLayer1.getIncludeAnalysisLayers()) != test) {
                                cbLayer1.setIncludeAnalysisLayers(test);
                            }
                        }
                        if (cbLayer2 != null) {
                            if ((cbLayer2.getIncludeAnalysisLayers()) != test) {
                                cbLayer2.setIncludeAnalysisLayers(test);
                            }
                        }
                        if (cbLayerMix != null) {
                            if ((cbLayerMix.getIncludeAnalysisLayers()) != test) {
                                cbLayerMix.setIncludeAnalysisLayers(test);
                            }
                        }
                        if (mpLayer1 != null && mpLayer2 != null && mpLayersIncludeAnalysisLayers != test) {
                            // remove
                            while (mpLayer1.getChildren().size() > 0) {
                                mpLayer1.removeChild(mpLayer1.getFirstChild());
                            }
                            while (mpLayer2.getChildren().size() > 0) {
                                mpLayer2.removeChild(mpLayer2.getFirstChild());
                            }
                            // add
                            for (MapLayer ml : getMapComposer().getGridLayers()) {
                                addToMpLayers(ml, false);
                            }
                            mpLayersIncludeAnalysisLayers = test;
                            if (mpLayersIncludeAnalysisLayers) {
                                for (MapLayer ml : getMapComposer().getAnalysisLayers()) {
                                    if (ml.getSubType() != LayerUtilities.ALOC) {
                                        addToMpLayers(ml, true);
                                    }
                                }
                            }
                        }
                    }
                }
                if (nextDiv != null && nextDiv.getZclass().contains("last")) {
                    updateLayerListText();
                }

                btnBack.setDisabled(false);
                updateWindowTitle();
            }

        } catch (Exception ex) {
            Logger.getLogger(AddToolComposer.class.getName()).log(Level.SEVERE, null, ex);
        }

        toggles();
        displayTrafficLightInfo();

        fixFocus();
    }

    void fixFocus() {
        // set element of focus
    }

    public void onLastPanel() {
    }

    public boolean onFinish() {
        try {
            this.detach();
            Messagebox.show("Running your analysis tool: " + selectedMethod);

        } catch (InterruptedException ex) {
            Logger.getLogger(AddToolComposer.class.getName()).log(Level.SEVERE, null, ex);
        } catch (Exception e) {
        }

        return true;
    }

    public void loadMap(Event event) {
    }

    public long getEstimate() {
        return -1;
    }

    public void onClick$bLogin(Event event) {
        getMapComposer().activateLink("https://auth.ala.org.au/cas/login", "Login", false);

        // Window extWin = (Window) getFellowIfAny("externalContentWindow");
        // extWin.addEventListener("onClose", new EventListener() {
        // @Override
        // public void onEvent(Event event) throws Exception…