Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2017 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.raster.lib.buffer.impl.operations;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.OperationManager;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferOperationException;

import org.gvsig.raster.lib.buffer.api.operations.InvalidLookupParametersException;

import org.gvsig.raster.lib.buffer.api.operations.InvalidLookupParametersException.Problem;

import org.gvsig.raster.lib.buffer.api.operations.Operation;

import org.gvsig.raster.lib.buffer.api.operations.OperationFactory;

import org.gvsig.raster.lib.buffer.api.operations.OperationFactory.Applicable;

import org.gvsig.raster.lib.buffer.api.operations.OperationList;

import org.gvsig.raster.lib.buffer.api.operations.OperationListEntry;

import org.gvsig.raster.lib.buffer.api.operations.OperationListNotification;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.TaskStatus;

/**

 * @author fdiaz

 *

 */

public class DefaultOperationList extends BaseWeakReferencingObservable implements OperationList {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultOperationList.class);

    /**

     * Persistence definition name

     */

    public static final String PERSISTENT_NAME = "OperationListPersistence";

    /**

     * Description of persistence definition

     */

    public static final String PERSISTENT_DESCRIPTION = "Persistence definition of operation list";

    private final static String OPERATIONS_PERSISTENCE_FIELD = "operations";

    private List<OperationListEntry> operations;

    private DynObject defaultParameters = null;

    /**

     *

     */

    public DefaultOperationList() {

        this.operations = new ArrayList<>();

    }

    @Override

    public int size() {

        return this.operations.size();

    }

    @Override

    public boolean isEmpty() {

        return this.operations.isEmpty();

    }

    @Override

    public boolean contains(Object o) {

        return this.operations.contains(o);

    }

    @Override

    public Iterator<OperationListEntry> iterator() {

        return this.operations.iterator();

    }

    @Override

    public Object[] toArray() {

        return this.operations.toArray();

    }

    @Override

    public <T> T[] toArray(T[] a) {

        return this.operations.toArray(a);

    }

    @Override

    public boolean add(OperationListEntry e) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.add(e);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRY, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public boolean remove(Object o) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.remove(o);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.REMOVED_ENTRY, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public boolean containsAll(Collection<?> c) {

        return this.operations.containsAll(c);

    }

    @Override

    public boolean addAll(Collection<? extends OperationListEntry> c) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.addAll(c);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRIES, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public boolean addAll(int index, Collection<? extends OperationListEntry> c) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.addAll(index, c);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRIES, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public boolean removeAll(Collection<?> c) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.removeAll(c);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.REMOVED_ENTRIES, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public boolean retainAll(Collection<?> c) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        boolean result = this.operations.retainAll(c);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.RETAINED_ENTRIES, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public void clear() {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        this.operations.clear();

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.CLEAR_ENTRIES, new Object[] {

            oldOperations, this.operations }));

    }

    @Override

    public OperationListEntry get(int index) {

        return this.operations.get(index);

    }

    @Override

    public OperationListEntry set(int index, OperationListEntry element) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        OperationListEntry result = this.operations.set(index, element);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.SETTED_ENTRY, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public void add(int index, OperationListEntry element) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        if(index<0){

            index = this.operations.size()+index;

        }

        this.operations.add(index, element);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRY, new Object[] {

            oldOperations, this.operations }));

    }

    @Override

    public OperationListEntry remove(int index) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        OperationListEntry result = this.operations.remove(index);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.REMOVED_ENTRY, new Object[] {

            oldOperations, this.operations }));

        return result;

    }

    @Override

    public int indexOf(Object o) {

        return this.operations.indexOf(o);

    }

    @Override

    public int lastIndexOf(Object o) {

        return this.operations.lastIndexOf(o);

    }

    @Override

    public ListIterator<OperationListEntry> listIterator() {

        return this.operations.listIterator();

    }

    @Override

    public ListIterator<OperationListEntry> listIterator(int index) {

        return this.operations.listIterator(index);

    }

    @Override

    public List<OperationListEntry> subList(int fromIndex, int toIndex) {

        return this.operations.subList(fromIndex, toIndex);

    }

    @Override

    public Buffer execute(TaskStatus status, Buffer buffer) throws BufferOperationException {

        Buffer tmpBuffer1 = buffer;

        DisposeUtils.bind(tmpBuffer1);

        Buffer tmpBuffer2;

        int i=0;

        for (OperationListEntry operationListEntry : operations) {

            Operation operation = operationListEntry.getOperation();

            DynObject parameters = operationListEntry.getParameters();

            OperationFactory factory = operation.getFactory();

            if (operationListEntry.isActive()) {

                if (factory.isApplicable(tmpBuffer1).equals(Applicable.NO)) {

                    throw new IllegalArgumentException("The operation is not applicable to the input buffer");

                }

                DynClass paramsDefinition = parameters.getDynClass();

                DynField[] fields = paramsDefinition.getDynFields();

                for (DynField field1 : fields) {

                    DynField_v2 field = (DynField_v2) field1;

                    String name = operationListEntry.getLookpupParameterName(field.getName());

                    if (StringUtils.isEmpty(name)) {

                        name = (String) field.getTags().get("lookupParameter");

                    }

                    if (!StringUtils.isEmpty(name)) {

                        parameters.setDynValue(field.getName(), getParameterValue(name, i));

                    }

                }

                tmpBuffer2 = operation.execute(status, tmpBuffer1, parameters);

                DisposeUtils.dispose(tmpBuffer1);

                tmpBuffer1 = tmpBuffer2;

            }

            i++;

        }

        return tmpBuffer1;

    }

    @Override

    public void add(Operation operation, DynObject parameters) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        OperationManager operationManager = ((OperationManager)BufferLocator.getBufferManager());

        OperationListEntry entry = operationManager.createOperationListEntry(operation, parameters);

        this.operations.add(entry);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRY, new Object[] {

            oldOperations, this.operations }));

    }

    @Override

    public void add(int index, Operation operation, DynObject parameters) {

        ArrayList<OperationListEntry> oldOperations = this.cloneOperations();

        OperationManager operationManager = ((OperationManager)BufferLocator.getBufferManager());

        OperationListEntry entry = operationManager.createOperationListEntry(operation, parameters);

        this.operations.add(index, entry);

        this.notifyObservers(new DefaultOperationListNotification(OperationListNotification.ADDED_ENTRY, new Object[] {

            oldOperations, this.operations }));

    }

    @Override

    public void removeIfExists(String name) {

        int removed = 0;

        int size = this.size();

        for (Iterator<OperationListEntry> iterator = this.iterator(); iterator.hasNext();) {

            OperationListEntry entry = (OperationListEntry) iterator.next();

            Operation operation = entry.getOperation();

            if (operation.getFactory().getName().equals(name)) {

                iterator.remove();

                removed++;

            }

        }

        if(this.size()!=size-removed){

            LOG.warn("NO SE HAN ELIMINADO CORRECTAMENTE LAS ENTRADAS DE LA OPERATION_LIST.");

        }

    }

    @Override

    public Object getParameterValue(String name) {

        int size = operations.size();

        return getParameterValue(name, size);

    }

    private Object getParameterValue(String name, int index) {

        if(index<0){

            index = this.operations.size()+index;

        }

        ListIterator<OperationListEntry> iterator = operations.listIterator(index);

        Object result = null;

        while (iterator.hasPrevious()) {

            OperationListEntry operationListEntry = (OperationListEntry) iterator.previous();

            if (operationListEntry != null && operationListEntry.isActive()) {

                DynObject parameters = operationListEntry.getParameters();

                if (parameters.getDynClass().getDynField(name) != null) {

                    result = parameters.getDynValue(name);

                    break;

                }

            } else {

                LOG.warn("***** THE ENTRY IS NULL *****");

            }

        }

        if(result == null && defaultParameters!=null){

            if (defaultParameters.getDynClass().getDynField(name) != null) {

                result = defaultParameters.getDynValue(name);

            }

        }

        return result;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(OPERATIONS_PERSISTENCE_FIELD, this.operations);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.operations = new ArrayList<>();

        Iterator it = state.getIterator(OPERATIONS_PERSISTENCE_FIELD);

        while(it.hasNext()) {

            OperationListEntry operationListEntry = (OperationListEntry) it.next();

            this.add(operationListEntry);

        }

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

        if (definition == null) {

            definition =

                manager.addDefinition(DefaultOperationList.class, PERSISTENT_NAME,

                    PERSISTENT_DESCRIPTION, null, null);

            definition.addDynFieldList(OPERATIONS_PERSISTENCE_FIELD).setMandatory(false).setClassOfItems(OperationListEntry.class);

        }

    }

    public List<String> getAvailableParameterNames() {

        Set<String> result = new HashSet<>();

        for (OperationListEntry operationListEntry : operations) {

            DynObject parameters = operationListEntry.getParameters();

            DynField[] dynFields = parameters.getDynClass().getDynFields();

            for (int i = 0; i < dynFields.length; i++) {

                result.add(dynFields[i].getName());

            }

        }

        if (this.defaultParameters != null) {

            DynField[] dynFields = this.defaultParameters.getDynClass().getDynFields();

            for (DynField dynField : dynFields) {

                result.add(dynField.getName());

            }

        }

        return new ArrayList<>(result);

    }

    @Override

    public void setDefaultParameters(DynObject parameters) {

        this.defaultParameters = parameters;

    }

    @Override

    public void validateLookupParameters() throws InvalidLookupParametersException {

        List<Problem> problems = new ArrayList<>();

//        InvalidLookupParametersException exception = new InvalidLookupParametersException(problems);

        ListIterator<OperationListEntry> iterator = operations.listIterator();

        int i = operations.size();

        while (iterator.hasPrevious()) {

            OperationListEntry operationListEntry = (OperationListEntry) iterator.previous();

            Operation operation = operationListEntry.getOperation();

            DynObject parameters = operationListEntry.getParameters();

            OperationFactory factory = operation.getFactory();

            if (operationListEntry.isActive()) {

                DynClass paramsDefinition = parameters.getDynClass();

                DynField[] fields = paramsDefinition.getDynFields();

                for (DynField field1 : fields) {

                    DynField_v2 field = (DynField_v2) field1;

                    String name = operationListEntry.getLookpupParameterName(field.getName());

                    if( !StringUtils.isEmpty(name) ) {

                        name = (String) field.getTags().get("lookupParameter");

                    }

                    if( !StringUtils.isEmpty(name) ) {

                        if( getParameterValue(name, i) == null){

                            Problem problem = new Problem(factory.getName(), field.getName(), name);

                            problems.add(problem);

                        }

                    }

                }

            }

            i--;

        }

        if(!problems.isEmpty()){

            throw new InvalidLookupParametersException(problems);

        }

    }

    private ArrayList<OperationListEntry> cloneOperations() {

        ArrayList<OperationListEntry> clonedOperations = null;

        if (operations != null) {

            try {

                clonedOperations = new ArrayList(operations.size());

                for (int i = 0; i < operations.size(); i++) {

                    clonedOperations.add((OperationListEntry) operations.get(i).clone());

                }

            } catch (CloneNotSupportedException e) {

                LOG.warn("Can't clone operation list", e);

            }

        }

        return clonedOperations;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        OperationList cloned = new DefaultOperationList();

        if (operations != null) {

            for (int i = 0; i < operations.size(); i++) {

                cloned.add((OperationListEntry) operations.get(i).clone());

            }

        }

        return cloned;

    }

}