gvSIG projects pool

/*

 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license

 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template

 */

package org.gvsig.online.swing.impl.simplesearch;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.table.TableModel;

import org.apache.commons.lang3.mutable.MutableObject;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.online.lib.api.OnlineLocator;

import org.gvsig.online.lib.api.OnlineManager;

import static org.gvsig.online.lib.api.OnlineManager.ERR_EXCEPTION;

import static org.gvsig.online.lib.api.OnlineManager.ERR_OK;

import org.gvsig.online.lib.api.workingcopy.OnlineEntity;

import org.gvsig.online.lib.api.workingcopy.OnlineWorkingcopy;

import org.gvsig.online.swing.api.OnlineSwingLocator;

import org.gvsig.online.swing.api.OnlineSwingServices;

import org.gvsig.online.swing.impl.MessageStatus;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import static org.gvsig.tools.task.SimpleTaskStatus.message;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class SimpleSearchImpl {

    public static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(SimpleSearchImpl.class);

    private final OnlineWorkingcopy wc;

    private OnlineEntity entity;

    private FeatureType featureType;

    private FeaturePagingHelper feats;

    private Envelope fullEnv;

    private final FeatureStore store;

    private Expression lastFilter;

    private boolean processing;

    public SimpleSearchImpl(FeatureStore store) {

        this(store, null);

    }

    public SimpleSearchImpl(FeatureStore store, JComponent panel) {

        OnlineManager manager = OnlineLocator.getOnlineManager();

        this.store = store;

        DisposeUtils.bind(this.store);

        this.wc = manager.getWorkingcopy(store);

        if (wc != null) {

            this.entity = wc.getEntity(store.getName());

            this.featureType = wc.getFeatureType(this.entity.getEntityName());

        }

        this.processing = false;

        if(panel != null) {

            panel.addComponentListener(new ComponentAdapter() {

                @Override

                public void componentHidden(ComponentEvent e) {

                    dispose();

                }

            });

        }

    }

    public void dispose() {

        DisposeUtils.disposeQuietly(store);

        DisposeUtils.disposeQuietly(wc);

        DisposeUtils.disposeQuietly(feats);

    }

    public long count(Expression filter) {

        return count(filter, null);

    }

    public long count(Expression filter, SimpleTaskStatus status) {

        if(status == null){

            status = SimpleTaskStatus.FAKE_STATUS;

        }

        long count = wc.simpleSearchCount(this.entity.getEntityName(), filter, status);

        return count;

    }

    public boolean areThereTooManyResults(Expression filter) {

        return areThereTooManyResults(filter, null);

    }

    public boolean areThereTooManyResults(Expression filter, SimpleTaskStatus status) {

        if(status == null){

            status = SimpleTaskStatus.FAKE_STATUS;

        }

        int minResultForAlert = wc.getMinResultForAlert();

        return (count(filter, status) > minResultForAlert);

    }

    public List<Feature> search(Expression filter) {

        return search(filter, null);

    }

    public List<Feature> search(Expression filter, SimpleTaskStatus status) {

        if (status == null) {

            status = SimpleTaskStatus.FAKE_STATUS;

        }

        this.fullEnv = null;

        this.lastFilter = null;

        if (this.feats != null) {

            DisposeUtils.disposeQuietly(feats);

            feats = null;

        }

        this.feats = wc.simpleSearch(this.entity.getEntityName(), filter, status);

        this.lastFilter = filter;

        return this.feats.asList();

    }

    protected boolean isSearched() {

        return this.lastFilter != null;

    }

    public int download() {

        return download(null);

    }

    public int download(SimpleTaskStatus status) {

        if(!isSearched()){

            return ERR_OK;

        }

        if(status == null){

            status = SimpleTaskStatus.FAKE_STATUS;

        }

        try {

            IProjection proj4326 = CRSFactory.getCRS("EPSG:4326");

            ICoordTrans ct = proj4326.getCT(this.entity.getCRSAsProjection());

            this.fullEnv = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);

            Iterator<Feature> it = feats.iterator();

            Iterator<Geometry> geoms = new Iterator<Geometry>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public Geometry next() {

                    Geometry geom = it.next().getDefaultGeometry();

                    geom.reProject(ct);

                    fullEnv.add(geom);

                    return geom;

                }

            };

            int n = wc.download(entity.getEntityName(), geoms, status);

            SwingUtilities.invokeLater(() -> {

                setSelection();

                OnlineSwingServices services = OnlineSwingLocator.getOnlineSwingManager().getDefaultServices();

                services.refreshDocument(getFeatureStore());

            });

            return n;

        } catch (Exception ex) {

            LOGGER.warn("Can't download.", ex);

            return ERR_EXCEPTION;

        }

    }

    public OnlineWorkingcopy getWorkingcopy() {

        return this.wc;

    }

    public Envelope getEnvelope(SimpleTaskStatus status) {

        if (fullEnv == null) {

            try {

                IProjection proj4326 = CRSFactory.getCRS("EPSG:4326");

                ICoordTrans ct = proj4326.getCT(this.entity.getCRSAsProjection());

                this.fullEnv = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);

                Iterator<Feature> it = feats.iterator();

                Iterator<Geometry> geoms = new Iterator<Geometry>() {

                    @Override

                    public boolean hasNext() {

                        return it.hasNext();

                    }

                    @Override

                    public Geometry next() {

                        Geometry geom = it.next().getDefaultGeometry();

                        geom.reProject(ct);

                        fullEnv.add(geom);

                        return geom;

                    }

                };

                status.message("_Calculating_envelope");

                status.setRangeOfValues(0, feats.size64());

                while(geoms.hasNext()) {

                    status.incrementCurrentValue();

                    geoms.next();

                }

            } catch (Exception ex) {

                LOGGER.warn("Can't get envelope.", ex);

            }

        }

        return this.fullEnv;

    }

    public FeatureType getFeatureType() {

        return this.featureType;

    }

    public boolean isEmpty() {

        return this.featureType == null;

    }

    FeatureStore getFeatureStore() {

        return store;

    }

    public TableModel createEmptyTableModel() {

        DataSwingManager swingManager = DALSwingLocator.getDataSwingManager();

        return swingManager.createSimpleFeaturesTableModel(

            this.getFeatureType(),

            null,

            null

        );

    }

    public TableModel createTableModel() {

        if(feats == null) {

            return createEmptyTableModel();

        }

        DataSwingManager swingManager = DALSwingLocator.getDataSwingManager();

        return swingManager.createSimpleFeaturesTableModel(

            this.getFeatureType(),

            null,

            this.feats.asList()

        );

    }

    public void zoom() {

        this.zoom(SimpleTaskStatus.FAKE_STATUS);

    }

    public void zoom(SimpleTaskStatus status) {

        Envelope env = this.getEnvelope(status);

        if(env == null){

            return;

        }

        try {

            OnlineSwingServices services = OnlineSwingLocator.getOnlineSwingManager().getDefaultServices();

            if (!env.isEmpty()) {

                services.zoomActiveViewToGeometry(env.getGeometry().buffer(100));

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't zoom to results.", ex);

        }

    }

    public void setSelection() {

        FeatureSet set = null;

        try {

            set = this.getFeatureStore().getFeatureSet(lastFilter);

            this.getFeatureStore().setSelection(set);

        } catch (DataException ex) {

            LOGGER.warn("Can't set selection", ex);

        }

    }

    public Thread runSearchTask(Expression filter, Runnable postProcessingAction, MessageStatus message) {

        SimpleTaskStatus status = message.createTaskStatus("_Search");

        message.setVisible(true);

        message.clear();

        I18nManager i18n = ToolsLocator.getI18nManager();

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        Thread task = new Thread(() -> {

            this.processing = true;

            try {

                if (this.areThereTooManyResults(filter)) {

                    int n = dialogs.confirmDialog(

                        i18n.getTranslation("_Search_returns_too_many_results")

                        + "\n"

                        + i18n.getTranslation("_Do_you_want_to_continue_anyway"),

                        i18n.getTranslation("_Upload"),

                        JOptionPane.YES_NO_OPTION,

                        JOptionPane.QUESTION_MESSAGE

                    );

                    if (n != JOptionPane.YES_OPTION) {

                        return;

                    }

                }

                this.search(filter, status);

            } catch (Exception ex) {

            } finally {

                if (postProcessingAction != null) {

                    SwingUtilities.invokeLater(() -> {

                        postProcessingAction.run();

                    });

                }

                message.setVisible(false);

                processing = false;

            }

        }, "OnlineSimpleSearch");

        this.processing = true;

        task.start();

        return task;

    }

    public Thread runDownloadTask(Runnable postProcessingAction, MessageStatus message) {

        if(!isSearched()){

            return null;

        }

        SimpleTaskStatus status = message.createTaskStatus("_Download");

        message.setVisible(true);

        message.clear();

        Thread task = new Thread(() -> {

            this.processing = true;

            try {

                this.download(status);

            } catch (Exception ex) {

                //FIXME: 

            } finally {

                if (postProcessingAction != null) {

                    SwingUtilities.invokeLater(() -> {

                        postProcessingAction.run();

                    });

                }

                message.setVisible(false);

                processing = false;

            }

        }, "OnlineSimpleSearchDownload");

        this.processing = true;

        task.start();

        return task;

    }

    public Thread runCalculateEnvelopeTask(Runnable postProcessingAction, MessageStatus message) {

        if(!isSearched()){

            return null;

        }

        SimpleTaskStatus status = message.createTaskStatus("_Calculate_envelope");

        message.setVisible(true);

        message.clear();

        Thread task = new Thread(() -> {

            this.processing = true;

            try {

                this.getEnvelope(status);

            } catch (Exception ex) {

                //FIXME: 

            } finally {

                if (postProcessingAction != null) {

                    SwingUtilities.invokeLater(() -> {

                        postProcessingAction.run();

                    });

                }

                message.setVisible(false);

                processing = false;

            }

        }, "OnlineSimpleSearchCalculateEnvelope");

        this.processing = true;

        task.start();

        return task;

    }

    public boolean isProcessing() {

        return this.processing;

    }

    public boolean canDownload(MutableObject<String> message) {

        return this.getWorkingcopy().canDownload(

            message, 

            Collections.singletonList(this.entity.getEntityCode())

        );

    }

}