Application: gvSIG desktop

package org.gvsig.app.extension.copytable;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.net.URL;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import javax.swing.AbstractCellEditor;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.DefaultTableColumnModel;

import javax.swing.table.TableCellEditor;

import javax.swing.table.TableColumn;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.text.similarity.LevenshteinDistance;

import org.gvsig.app.extension.copytable.CopyTable2ProcessParameters.ProcessFieldParameters;

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.expressionevaluator.swing.JExpressionPicker;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.featuretype.AttributeDescriptorPickerController;

import org.gvsig.fmap.dal.swing.storesrepository.StoresRepositoryController;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dispose.DisposeUtils;

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

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

import org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_GETVALUE;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_SETVALUE;

import org.gvsig.tools.swing.api.bookmarkshistory.BookmarksController;

import org.gvsig.tools.swing.api.bookmarkshistory.HistoryController;

import org.gvsig.tools.swing.api.documentfilters.IntegerDocumentFilter;

import org.gvsig.tools.swing.api.task.TaskStatusController;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 *

 * @author jjdelcerro

 */

public class CopyTable2Panel extends CopyTable2PanelView {

    private static final String BOOKMARKSANDHISTORY_NAME = "CopyTablePanel";

    private static final String CONFIGURABLE_PANEL_ID = "CopyTablePanel";

    private static final Integer MAX_DISTANCE_TO_ASSIGN_FIELD = 3;

    private AttributeDescriptorPickerController pickerSourceFieldJoin;

    private FeatureStore source;

    private FeatureStore target;

    private AttributeDescriptorPickerController pickerTargetFieldJoin;

    private ExpressionPickerController pickerSourceFilter;

    private ExpressionPickerController pickerTargetUpdateExpression;

    private DefaultTableColumnModel fieldsColumnModel;

    private SimpleTaskStatus taskStatus;

    private TaskStatusController status;

    private StoresRepositoryController treeSourceTableController;

    private StoresRepositoryController treeTargetTableController;

    private final Bookmarks bookmarks;

    private final History history;

    private BookmarksController bookmarksController;

    private HistoryController historyController;

    private ExpressionPickerController pickerJoinExpression;

    private class FeatureAttributeCellEditor extends AbstractCellEditor implements TableCellEditor {

        private final AttributeDescriptorPickerController picker;

        private final JComboBox combo;

        public FeatureAttributeCellEditor() {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            this.combo = new JComboBox();

            this.picker = dataSwingManager.createAttributeDescriptorPickerController(this.combo);

        }

        @Override

        public Component getTableCellEditorComponent(JTable jtable, Object value, boolean isSelected, int row, int column) {

            if( value == null ) {

                this.picker.clean();

                return this.combo;

            }

            this.picker.setFeatureType(source.getDefaultFeatureTypeQuietly());

            this.picker.setAllowNull(true);

            this.picker.set(Objects.toString(value,""));

            return this.combo;

        }

        @Override

        public Object getCellEditorValue() {

            return this.picker.getName();

        }

    }

    private class ExpressionCellEditor extends AbstractCellEditor implements TableCellEditor {

        private final JExpressionPicker picker;

        public ExpressionCellEditor() {

            ExpressionEvaluatorSwingManager manager = ExpressionEvaluatorSwingLocator.getManager();

            this.picker = manager.createJExpressionPicker();

            this.picker.removeBorder();

        }

        @Override

        public Component getTableCellEditorComponent(JTable jtable, Object value, boolean isSelected, int row, int column) {

            try {

                DataSwingManager manager = DALSwingLocator.getDataSwingManager();

                manager.configureExpressionBuilder(picker.getConfig(), source);

                if( value == null ) {

                    this.picker.setExpression(null);

                } else {

                    this.picker.setExpression(ExpressionUtils.createExpression((String) value));

                }

                return this.picker.asJComponent();

            } catch(Exception ex) {

                return new JLabel();

            }

        }

        @Override

        public Object getCellEditorValue() {

            Expression exp = this.picker.getExpression();

            if( exp==null ) {

                return null;

            }

            return exp.getPhrase();

        }

    }

    private class MyTableModel extends AbstractTableModel implements Iterable<MyTableModel.Row>{

        private final List<Row> rows;

        private final String[] columnNames;

        private final Class[] columnClass;

        private final FeatureType tableType;

        private class Row {

            String attrname;

            String expression;

            boolean update;

            public Object get(int index) {

                switch(index) {

                    case 0:

                        return update;

                    case 1:

                        return attrname;

                    case 2:

                        return expression;

                    default:

                        return null;

                }

            }

            public void set(int index, Object value) {

                switch(index) {

                    case 0:

                        this.update = (boolean) value;

                        break;

                    case 1:

                        this.attrname = (String) value;

                        break;

                    case 2:

                        this.expression = (String) value;

                        break;

                    default:

                        break;

                }

            }

        }

        public MyTableModel() {

            this.rows = new ArrayList<>();

            this.tableType = target.getDefaultFeatureTypeQuietly();

            for (FeatureAttributeDescriptor targetAttr : tableType) {

                Row row = new Row();

                row.attrname = targetAttr.getName();

                row.expression = getSourceExpression(row.attrname);

                if( targetAttr.isComputed()) {

                    row.update = false;

                } else {

                    row.update = true;

                }

                this.rows.add(row);

            }

            for (Row row : this.rows) {

                if(row.expression == null){

                    continue;

                }

//                Row first = null;

                boolean dup = false;

                for (Row row1 : this.rows) {

                    if(row == row1){

                        continue;

                    }

                    if(StringUtils.equalsIgnoreCase(row.expression, row1.expression)){

//                        if(first == null){

//                            first = row;

//                        }

                        dup = true;

                        row1.expression = null;

                    }

                }

//                if (first != null) {

//                    first.expression = null;

//                }

                if(dup){

                    row.expression = null;

                }

            }

            this.columnNames = new String[] {

                "Actualizar",

                "Campo",

                "Expresion"

            };

            this.columnClass = new Class[] {

                Boolean.class,

                String.class,

                String.class

            };

        }

        String getSourceExpression(String targetFieldName){

            FeatureType sourceType = source.getDefaultFeatureTypeQuietly();

            ExpressionBuilder expBuilder = source.createExpressionBuilder();

            Integer minDistance = Integer.MAX_VALUE;

            String minDistanceSourceFieldName = null;

            FeatureAttributeDescriptor attr = sourceType.getAttributeDescriptor(targetFieldName);

            if(attr!=null){

                return expBuilder.identifier(attr.getName());

            }

            for (FeatureAttributeDescriptor featureAttributeDescriptor : sourceType) {

                String sourceFieldName = featureAttributeDescriptor.getName();

//                if(StringUtils.equalsIgnoreCase(targetFieldName, sourceFieldName)){

//                    return expBuilder.identifier(sourceFieldName);

//                }

                if(StringUtils.containsIgnoreCase(targetFieldName, sourceFieldName)){

                    return expBuilder.identifier(sourceFieldName);

                }

                if(StringUtils.containsIgnoreCase(sourceFieldName, targetFieldName)){

                    return expBuilder.identifier(sourceFieldName);

                }

                Integer distance = LevenshteinDistance.getDefaultInstance().apply(targetFieldName, sourceFieldName);

                if(distance < minDistance){

                    minDistanceSourceFieldName = sourceFieldName;

                    minDistance = distance;

                }

            }

            if(minDistance <= MAX_DISTANCE_TO_ASSIGN_FIELD) {

                return expBuilder.identifier(minDistanceSourceFieldName);

            }

            return null;

        }

        @Override

        public String getColumnName(int column) {

            return this.columnNames[column];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            return this.columnClass[columnIndex];

        }

        @Override

        public int getRowCount() {

            return this.rows.size();

        }

        @Override

        public int getColumnCount() {

            return 3;

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            switch (columnIndex) {

                case 0:

                case 2:

                    return this.rows.get(rowIndex).get(columnIndex);

                case 1:

                    FeatureAttributeDescriptor attrdesc = this.tableType.getAttributeDescriptor(this.rows.get(rowIndex).attrname);

                    return attrdesc;

                default:

                    return null;

            }

        }

        @Override

        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

            this.rows.get(rowIndex).set(columnIndex, aValue);

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            FeatureAttributeDescriptor attrdesc = this.tableType.getAttributeDescriptor(rowIndex);

            if( attrdesc == null ) {

                return false;

            }

            // Dejamos marcarlos todos, y el proceso de copia decidira saltarselos

            // segun se este insertando registro nuevo o actualizando.

//            if( attrdesc.isAutomatic() || attrdesc.isReadOnly() ) { //|| attrdesc.isPrimaryKey() ) {

//                return false;

//            }

            switch(columnIndex) {

                case 1:

                    return false;

                case 0:

                case 2:

                default:

                    return true;

            }

        }

        @Override

        public Iterator<Row> iterator() {

            return this.rows.iterator();

        }

        @Override

        public void fireTableDataChanged() {

            super.fireTableDataChanged();

        }

    }

    public CopyTable2Panel() {

        this.bookmarks = ToolsLocator.getBookmarksAndHistoryManager().getBookmarksGroup(BOOKMARKSANDHISTORY_NAME);

        this.history = ToolsLocator.getBookmarksAndHistoryManager().getHistoryGroup(BOOKMARKSANDHISTORY_NAME);

        this.initComponents();

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        this.status = ToolsSwingLocator.getTaskStatusSwingManager().createTaskStatusController(lblStatusLabel, lblStatusMessage, pbStatus);

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        cfgActionsManager.addConfigurableActions(CONFIGURABLE_PANEL_ID, this, btnConfigurableActions);

        this.bookmarksController = ToolsSwingLocator.getToolsSwingManager().createBookmarksController(this.bookmarks, btnBookmarks);

        this.historyController = ToolsSwingLocator.getToolsSwingManager().createHistoryController(this.history, btnHistory);

        this.historyController.setFilter(null);

        ActionListener bookmarksAndHistoryListener = (ActionEvent e) -> {

                ActionEventWithCurrentValue<CopyTable2ProcessParameters> event = (ActionEventWithCurrentValue<CopyTable2ProcessParameters>) e;

                switch (event.getID()) {

                        case ID_GETVALUE:

                                event.setCurrentValue(fetch(null));

                                break;

                        case ID_SETVALUE:

                                put(event.getCurrentValue());

                                doUpdateComponents();

                                break;

                }

        };

        this.historyController.addActionListener(bookmarksAndHistoryListener);

        this.bookmarksController.addActionListener(bookmarksAndHistoryListener);

        this.treeSourceTableController = dataSwingManager.createStoresRepositoryController(this.treeSourceTable);

        this.treeSourceTable.addTreeSelectionListener((TreeSelectionEvent e) -> {

            doChangeSource();

            doUpdateComponents();

        });

        this.pickerSourceFieldJoin = dataSwingManager.createAttributeDescriptorPickerController(cboSourceJoinField);

        this.pickerSourceFieldJoin.setAllowNull(true);

        this.pickerSourceFieldJoin.addChangeListener((ChangeEvent e) -> {

            doUpdateComponents();

        });

        this.treeTargetTableController = dataSwingManager.createStoresRepositoryController(this.treeTargetTable);

        this.treeTargetTable.addTreeSelectionListener((TreeSelectionEvent e) -> {

            doChangeTarget();

            doUpdateComponents();

        });

        this.pickerTargetFieldJoin = dataSwingManager.createAttributeDescriptorPickerController(cboTargetJoinField);

        this.pickerTargetFieldJoin.setAllowNull(true);

        this.pickerTargetFieldJoin.addChangeListener((ChangeEvent e) -> {

            doUpdateComponents();

        });

        this.pickerSourceFilter = expressionSwingManager.createExpressionPickerController(

                txtSourceFilter,

                btnSourceFilter,

                btnSourceFilterBookmarks,

                btnSourceFilterHistory

        );

        this.pickerTargetUpdateExpression = expressionSwingManager.createExpressionPickerController(

                txtTargetUpdateWhenExpression,

                btnTargetUpdateWhenExpression,

                btnTargetUpdateWhenExpressionBookmarks,

                btnTargetUpdateWhenExpressionHistory

        );

        this.chkTargetInsertIfNotExistsInTarget.setSelected(false);

        this.chkTargetInsertIfNotExistsInTarget.addChangeListener((e) -> {

            doUpdateComponents();

        });

        this.chkTargetUpdateIfExistsInTarget.setSelected(false);

        this.chkTargetUpdateIfExistsInTarget.addChangeListener((e) -> {

            doUpdateComponents();

        });

        this.chkTargetDeleteIfNotExiststInSource.setEnabled(false);

        this.chkTargetDeleteIfNotExiststInSource.addChangeListener((e) -> {

            doUpdateComponents();

        });

        this.tableFields.setAutoCreateColumnsFromModel(false);

        this.tableFields.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        this.fieldsColumnModel = new DefaultTableColumnModel();

        this.rdbUseJoinExpression.addActionListener((ActionEvent e) -> {

            doUpdateComponents();

        });

        this.rdbUseJoinField.addActionListener((ActionEvent e) -> {

            doUpdateComponents();

        });

        this.pickerJoinExpression = expressionSwingManager.createExpressionPickerController(

                txtJoinExpression,

                btnJoinExpression,

                btnJoinExpressionBookmarks,

                btnJoinExpressionHistory

        );

        TableColumn column = new TableColumn();

        column.setHeaderValue("Actualizar");

        column.setCellRenderer(null);

        column.setResizable(true);

        column.setModelIndex(0);

        this.fieldsColumnModel.addColumn(column);

        column = new TableColumn();

        column.setHeaderValue("Campo destino");

        column.setCellRenderer(dataSwingManager.createDefaultFeatureAttributeTableCellRenderer());

        column.setCellEditor(null);

        column.setResizable(true);

        column.setModelIndex(1);

        this.fieldsColumnModel.addColumn(column);

        column = new TableColumn();

        column.setHeaderValue("Campo origen");

        column.setCellRenderer(null);

        column.setCellEditor(new ExpressionCellEditor());

        column.setResizable(true);

        column.setModelIndex(2);

        this.fieldsColumnModel.addColumn(column);

        this.btnCheckAllFields.addActionListener((ActionEvent e) -> {

            doSetAllChecksOfFields(true);

        });

        this.btnUnCheckAllFields.addActionListener((ActionEvent e) -> {

            doSetAllChecksOfFields(false);

        });

        this.tableFields.setColumnModel(this.fieldsColumnModel);

        SwingUtilities.invokeLater(() -> {

            lblStatusLabel.setText("");

            lblStatusMessage.setText("");

            pbStatus.setVisible(false);

        });

        this.lblJoinExpressionMsg.setText("<html>"+this.lblJoinExpressionMsg.getText()+"</html>");

        doUpdateComponents();

        ToolsSwingUtils.ensureRowsCols(this, 25, 80, 30, 100);

    }

    private void doSetAllChecksOfFields(boolean check) {

        MyTableModel model = (MyTableModel) this.tableFields.getModel();

        for (MyTableModel.Row row : model) {

            row.set(0, check);

        }

        model.fireTableDataChanged();

    }

    private void doUpdateComponents() {

        this.treeSourceTableController.setEnabled(

                true

        );

        this.pickerSourceFieldJoin.setEnabled(

                this.source != null

        );

        this.pickerSourceFilter.setEnabled(

                this.source != null

        );

        this.treeTargetTableController.setEnabled(

                this.source != null

        );

        this.btnCheckAllFields.setEnabled(

                this.source != null &&

                this.target != null

        );

        this.btnUnCheckAllFields.setEnabled(

                this.source != null &&

                this.target != null

        );

        this.rdbUseJoinField.setEnabled(

                this.source != null &&

                this.target != null

        );

        this.rdbUseJoinExpression.setEnabled(

                this.source != null &&

                this.target != null

        );

        this.rdbNotJoin.setEnabled(

                this.source != null &&

                this.target != null

        );

        this.pickerTargetFieldJoin.setEnabled(

                this.source != null &&

                this.target != null &&

                (this.rdbUseJoinField.isSelected() && this.rdbUseJoinField.isEnabled()) &&

                this.pickerSourceFieldJoin.getName() != null

        );

        this.pickerJoinExpression.setEnabled(

                this.source != null &&

                this.target != null &&

                (this.rdbUseJoinExpression.isSelected() && this.rdbUseJoinExpression.isEnabled())

        );

        this.chkTargetInsertIfNotExistsInTarget.setEnabled(

                this.source != null &&

                this.target != null && (

                (this.pickerSourceFieldJoin.getName() != null && this.pickerTargetFieldJoin.getName() != null) ||

                this.rdbUseJoinExpression.isSelected()

                )

        );

        this.chkTargetUpdateIfExistsInTarget.setEnabled(

                this.source != null &&

                this.target != null && (

                (this.pickerSourceFieldJoin.getName() != null && this.pickerTargetFieldJoin.getName() != null) ||

                this.rdbUseJoinExpression.isSelected()

                )

        );

        this.chkTargetDeleteIfNotExiststInSource.setEnabled(

                false // No esta implementado

//                this.source != null &&

//                this.target != null && (

//                (this.pickerSourceFieldJoin.getName() != null && this.pickerTargetFieldJoin.getName() != null) ||

//                this.rdbUseJoinExpression.isSelected()

//                )

        );

        this.pickerTargetUpdateExpression.setEnabled(

                this.chkTargetUpdateIfExistsInTarget.isSelected()

        );

        if( !this.pickerSourceFieldJoin.isEnabled() ) {

            this.pickerSourceFieldJoin.clean();

        }

        if( !this.pickerTargetFieldJoin.isEnabled() ) {

            this.pickerTargetFieldJoin.clean();

        }

        if( !this.chkTargetInsertIfNotExistsInTarget.isEnabled() ) {

            this.chkTargetInsertIfNotExistsInTarget.setSelected(false);

        }

        if( !this.chkTargetUpdateIfExistsInTarget.isEnabled() ) {

            this.chkTargetUpdateIfExistsInTarget.setSelected(false);

        }

        if( !this.chkTargetDeleteIfNotExiststInSource.isEnabled() ) {

            this.chkTargetDeleteIfNotExiststInSource.setSelected(false);

        }

        if( !this.pickerSourceFilter.isEnabled() ) {

            this.pickerSourceFilter.set(null);

        }

    }

    private void doChangeSource() {

        FeatureStore theSource = this.treeSourceTableController.getSelectedFeatureStore();

        if( theSource==null ) {

            return;

        }

        if(this.source != null){

            DisposeUtils.disposeQuietly(this.source);

        }

        this.source = theSource;

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        dataSwingManager.resetExpressionBuilder(this.pickerTargetUpdateExpression.getConfig());

        dataSwingManager.resetExpressionBuilder(this.pickerJoinExpression.getConfig());

        dataSwingManager.addToExpressionBuilder(this.pickerTargetUpdateExpression.getConfig(), this.source, "source");

        dataSwingManager.addToExpressionBuilder(this.pickerJoinExpression.getConfig(), this.source, "source", true);

        this.pickerSourceFieldJoin.setFeatureType(this.source.getDefaultFeatureTypeQuietly());

        try {

            this.pickerSourceFieldJoin.set(this.source.getDefaultFeatureTypeQuietly().getPrimaryKey()[0]);

        } catch (Exception e) {

            //Do nothing

        }

        if( this.target!=null ) {

            this.tableFields.setModel(new MyTableModel());

            dataSwingManager.addToExpressionBuilder(this.pickerTargetUpdateExpression.getConfig(), this.target, "target");

            dataSwingManager.addToExpressionBuilder(this.pickerJoinExpression.getConfig(), this.target, "target");

        }

    }

    private void doChangeTarget() {

        FeatureStore theTarget = this.treeTargetTableController.getSelectedFeatureStore();

        if( theTarget==null ) {

            return;

        }

        if(this.target != null){

            DisposeUtils.disposeQuietly(this.target);

        }

        this.target = theTarget;

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        dataSwingManager.resetExpressionBuilder(this.pickerTargetUpdateExpression.getConfig());

        dataSwingManager.resetExpressionBuilder(this.pickerJoinExpression.getConfig());

        dataSwingManager.addToExpressionBuilder(this.pickerTargetUpdateExpression.getConfig(), this.target, "target");

        dataSwingManager.addToExpressionBuilder(this.pickerJoinExpression.getConfig(), this.target, "target");

        this.pickerTargetFieldJoin.setFeatureType(this.target.getDefaultFeatureTypeQuietly());

        try {

            this.pickerTargetFieldJoin.set(this.target.getDefaultFeatureTypeQuietly().getPrimaryKey()[0]);

        } catch (Exception e) {

            //Do nothing

        }

        if( this.source!=null ) {

            this.tableFields.setModel(new MyTableModel());

            dataSwingManager.addToExpressionBuilder(this.pickerTargetUpdateExpression.getConfig(), this.source, "source");

            dataSwingManager.addToExpressionBuilder(this.pickerJoinExpression.getConfig(), this.source, "source", true);

        }

    }

//    public FeatureStore getSource() {

//        return this.source;

//    }

//

//    public String getSourceFieldJoin() {

//        return this.pickerSourceFieldJoin.getName();

//    }

//

//    public Expression getSourceFilter() {

//        return this.pickerSourceFilter.get();

//    }

//    public FeatureStore getTarget() {

//        return this.target;

//    }

//

//    public String getTargetFieldJoin() {

//        return this.pickerTargetFieldJoin.getName();

//    }

//

//    public Expression getUpdateIfExistsInTargetCondition() {

//        return this.pickerTargetUpdateExpression.get();

//    }

//

//    public boolean getInsertIfNotExistsTarget() {

//        return this.chkTargetInsertIfNotExistsInTarget.isSelected();

//    }

//

//    public boolean getUpdateIfExistsInTarget() {

//        return this.chkTargetUpdateIfExistsInTarget.isSelected();

//    }

//

//    public boolean getDeleteIfNotExiststInSource() {

//        return this.chkTargetDeleteIfNotExiststInSource.isSelected();

//    }

    public SimpleTaskStatus getStatus() {

        if( this.taskStatus == null ) {

            this.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Copy table");

            this.status.bind(this.taskStatus);

        }

        lblStatusLabel.setVisible(true);

        lblStatusMessage.setVisible(true);

        pbStatus.setVisible(true);

        return this.taskStatus;

    }

//    public Map<String/*target*/, String/*source*/> getFields() {

//        Map<String/*target*/, String/*source*/> fields = new HashMap<>();

//        MyTableModel model = (MyTableModel) this.tableFields.getModel();

//        for (MyTableModel.Row row : model) {

//            if( StringUtils.isNotBlank(row.source) ) {

//                fields.put(row.target, row.source);

//            }

//        }

//        return fields;

//    }

//

//    public List<String/*target*/> getFieldsToUpdate() {

//        List<String> fields = new ArrayList<>();

//        MyTableModel model = (MyTableModel) this.tableFields.getModel();

//        for (MyTableModel.Row row : model) {

//            if( StringUtils.isNotBlank(row.source) && row.update) {

//                fields.add(row.target);

//            }

//        }

//        return fields;

//    }

//

    public void put(CopyTable2ProcessParameters params) {

        FeatureStore sourceStore = params.getSourceStore();

        this.treeSourceTableController.setSelectedStore(sourceStore);

        doChangeSource();

        FeatureStore targetStore = params.getTargetStore();

        this.treeTargetTableController.setSelectedStore(targetStore);

        doChangeTarget();

        this.pickerSourceFieldJoin.set(params.getSourceFieldForJoin());

        this.pickerSourceFilter.set(params.getSourceFilter());

        this.pickerTargetFieldJoin.set(params.getTargetFieldForJoin());

        this.pickerTargetUpdateExpression.set(params.getUpdateIfExistsInTargetCondition());

        this.chkTargetInsertIfNotExistsInTarget.setSelected(params.isInsertIfNotExistsTargetActive());

        this.chkTargetUpdateIfExistsInTarget.setSelected(params.isUpdateIfExistsTargetActive());

        this.chkTargetDeleteIfNotExiststInSource.setSelected(params.isDeleteIfNotExiststInSourceActive());

        MyTableModel fieldsModel = new MyTableModel();

        this.tableFields.setModel(fieldsModel);

        for (MyTableModel.Row row : fieldsModel.rows) {

            ProcessFieldParameters paramfield = params.get(row.attrname);

            row.attrname = paramfield.getName();

            Expression expression = paramfield.getExpression();

            if (expression != null) {

                row.expression = expression.getPhrase();

            } else {

                row.expression = null;

            }

            row.update = paramfield.isCopyThisFieldActive();

        }

        //Options

        fieldsModel.fireTableDataChanged();

        switch (params.getEditMode()) {

            case FeatureStore.MODE_FULLEDIT:

            default:

                this.rdoOptionsFulledit.setSelected(true);

                this.rdoOptionsPassthrought.setSelected(false);

                break;

            case FeatureStore.MODE_PASS_THROUGH:

                this.rdoOptionsFulledit.setSelected(false);

                this.rdoOptionsPassthrought.setSelected(true);

                break;

        }

        this.chkOptionsBeginEditIfNeed.setSelected(params.isBeginEditIfNeed());

        this.chkOptionsFinishAndRestarEditEach.setSelected(params.isFinishAndRestarEdit());

        this.chkOptionsNotifyUserIfNeedBeginEditing.setSelected(params.isNotifyUserIfNeedBeginEditing());

        this.chkOptionsFinishEditAfterTerminate.setSelected(params.isFinishEditAfterTerminate());

        IntegerDocumentFilter.setValue(txtOptionsFinishAndRestarEditEach, params.getFinishAndRestarEditEach());

    }

    public CopyTable2ProcessParameters fetch(CopyTable2ProcessParameters params) {

        if( params == null ) {

            params = new CopyTable2ProcessParametersImpl();

        }

        params.setSourceStore(this.source);

        params.setSourceFilter(this.pickerSourceFilter.get());

        params.setSourceFieldForJoin(this.pickerSourceFieldJoin.getName());

        params.setTargetStore(this.target);

        if( this.rdbUseJoinExpression.isSelected() ) {

            params.setTargetFieldForJoin(null);

            params.setJoinExpression(this.pickerJoinExpression.get());

        } else if( this.rdbUseJoinField.isSelected() ) {

            params.setTargetFieldForJoin(this.pickerTargetFieldJoin.getName());

            params.setJoinExpression(null);

        } else {

            params.setTargetFieldForJoin(null);

            params.setJoinExpression(null);

        }

        params.setUpdateIfExistsInTargetCondition(this.pickerTargetUpdateExpression.get());

        params.setInsertIfNotExistsTargetActive(this.chkTargetInsertIfNotExistsInTarget.isSelected());

        params.setUpdateIfExistsTargetActive(this.chkTargetUpdateIfExistsInTarget.isSelected());

        params.setDeleteIfNotExiststInSourceActive(this.chkTargetDeleteIfNotExiststInSource.isSelected());

        fetch_fields(params);

        fetch_options(params);

        return params;

    }

    private void fetch_fields(CopyTable2ProcessParameters params) {

        MyTableModel model = (MyTableModel) this.tableFields.getModel();

        for (MyTableModel.Row row : model) {

            Expression exp = null;

            if( org.apache.commons.lang.StringUtils.isNotBlank(row.expression)) {

                exp = ExpressionUtils.createExpression(row.expression);

            }

            params.add(row.attrname, row.update, exp);

        }

    }

    private void fetch_options(CopyTable2ProcessParameters params) {

        if( this.rdoOptionsFulledit.isSelected() ) {

            params.setEditMode(FeatureStore.MODE_FULLEDIT);

        } else {

            params.setEditMode(FeatureStore.MODE_PASS_THROUGH);

        }

        params.setBeginEditIfNeed(this.chkOptionsBeginEditIfNeed.isSelected());

        params.setFinishAndRestarEdit(this.chkOptionsFinishAndRestarEditEach.isSelected());

        params.setNotifyUserIfNeedBeginEditing(this.chkOptionsNotifyUserIfNeedBeginEditing.isSelected());

        params.setFinishEditAfterTerminate(this.chkOptionsFinishEditAfterTerminate.isSelected());

        params.setFinishAndRestarEditEach(IntegerDocumentFilter.getValue(txtOptionsFinishAndRestarEditEach));

    }

    void message(String msg) {

        this.lblStatusMessage.setText(msg);

//        if(this.taskStatus.getCompleted() >= 100){

//            this.pbStatus.setVisible(false);

//        }

    }

    void addHistory(CopyTable2ProcessParameters params) {

        this.history.add(params);

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = CopyTable2Panel.class.getResource("images/"+name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

}