Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.export.impl.service;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.spi.AttributeNamesTranslator;

import org.gvsig.export.spi.DummyAttributeNamesTranslator;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public final class DefaultExportAttributes implements ExportAttributes {

    private List<ExportAttribute> exportAttributes;

    private AttributeNamesTranslator namesTranslator = null;

    private FeatureType sourceFeatureType;

    static final Logger LOGGER = LoggerFactory.getLogger(DefaultExportAttributes.class);

    private boolean active;

    private FeatureQuery query = null;

    public DefaultExportAttributes() {

        this.namesTranslator = new DummyAttributeNamesTranslator();

        this.active = false;

    }

    public void fillExportAttributes(FeatureType ftype, FeatureQuery query) {

        ArrayList attrs = new ArrayList();

        if (ftype != null) {

            for (FeatureAttributeDescriptor fad : ftype) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad);

                String newName = this.getNamesTranslator().getNameSuggestion(fad.getName());

                exportAttribute.setNewName(newName);

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                if (query == null || (query != null && query.getGroupByColumns().isEmpty())) {

                    exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                } else {

                    if (query.getAggregate(fad.getName()) != null || query.getGroupByColumns().contains(fad.getName())) {

                        exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                    } else {

                        exportAttribute.setExported(false);

                    }

                }

                attrs.add(exportAttribute);

            }

        }

        if (query!=null && query.getExtraColumn().getColumns()!=null && !query.getExtraColumn().getColumns().isEmpty() ) {

            for (FeatureAttributeDescriptor fad : query.getExtraColumn().getColumns()) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad);

                String newName = this.getNamesTranslator().getNameSuggestion(fad.getName());

                exportAttribute.setNewName(newName);

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                exportAttribute.setExported(isShowableDataType(fad.getDataType().getType()));

                attrs.add(exportAttribute);

            }

        }

        this.setExportAttributes(attrs);

        this.fixAttributeNames();

    }

    protected boolean isShowableDataType(int dataType) {

        DataTypesManager dataTypemanager = ToolsLocator.getDataTypesManager();

        if (dataTypemanager.isContainer(dataType)

                || dataTypemanager.isObject(dataType)

                || dataType == DataTypes.ARRAY) {

            return false;

        } else {

            return true;

        }

    }

    @Override

    public void setNamesTranslator(AttributeNamesTranslator namesTranslator) {

        if (this.namesTranslator != namesTranslator) {

            this.namesTranslator = namesTranslator;

            if (this.sourceFeatureType != null) {

                this.fillExportAttributes(sourceFeatureType, this.query);

            }

        }

    }

    @Override

    public AttributeNamesTranslator getNamesTranslator() {

        return this.namesTranslator;

    }

    @Override

    public List<ExportAttribute> toList() {

        return this.exportAttributes;

    }

    @Override

    public boolean isEmpty() {

        return this.exportAttributes.isEmpty();

    }

    @Override

    public int size() {

        return this.exportAttributes.size();

    }

    @Override

    public Iterator<ExportAttribute> iterator() {

        return this.exportAttributes.iterator();

    }

    @Override

    public ExportAttribute get(int position) {

        return this.exportAttributes.get(position);

    }

    @Override

    public ExportAttribute getExportAttribute(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute;

            }

        }

        return null;

    }

    @Override

    public FeatureType getTargetFeatureType() {

        if (!this.isAttributeNamesValid()) {

            this.fixAttributeNames();

            LOGGER.warn("An extra fix attributes names in the feature type has been made");

        }

        EditableFeatureType targetFeatureType = this.getSourceFeatureType().getCopy().getEditable();

        for (FeatureAttributeDescriptor attrSource : this.getSourceFeatureType()) {

            FeatureAttributeDescriptor attr = targetFeatureType.getAttributeDescriptor(attrSource.getName());

            String name = attr.getName();

            ExportAttribute exportAttr = this.getExportAttribute(name);

            if (!exportAttr.isExported()) {

                targetFeatureType.remove(name);

                continue;

            }

            EditableFeatureAttributeDescriptor eAttr = targetFeatureType.getEditableAttributeDescriptor(name);

            if( eAttr.isComputed() && !exportAttr.isComputed() ) {

                eAttr.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);

            }

            if (this.getTargetName(name) == null && name != null && !this.getTargetName(name).equals(name)) {

                eAttr.setName(this.getTargetName(name));

            }

            int type = attr.getDataType().getType();

            if (type != this.getTargetType(name)) {

                eAttr.setDataType(this.getTargetType(name));

                eAttr.setDefaultValue(null); // TODO: delete default value

            }

            int size = exportAttr.getSize();

            eAttr.setSize(size);

        }

        if (this.query!=null && this.query.getExtraColumn().getColumns()!=null && !this.query.getExtraColumn().getColumns().isEmpty()) {

            for (EditableFeatureAttributeDescriptor attrExtra : this.query.getExtraColumn().getColumns()) {

                //FeatureAttributeDescriptor attr = targetFeatureType.getAttributeDescriptor(attrSource.getName());

                String name = attrExtra.getName();

                ExportAttribute exportAttr = this.getExportAttribute(name);

                if (!exportAttr.isExported()) {

                    //targetFeatureType.remove(name);

                    continue;

                }

                //EditableFeatureAttributeDescriptor eAttr = targetFeatureType.getEditableAttributeDescriptor(name);

//                if( eAttr.isComputed() && !exportAttr.isComputed() ) {

//                    eAttr.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);

//                }

                if (this.getTargetName(name) == null && name != null && !this.getTargetName(name).equals(name)) {

                    attrExtra.setName(this.getTargetName(name));

                }

                int type = attrExtra.getDataType().getType();

                if (type != this.getTargetType(name)) {

                    attrExtra.setDataType(this.getTargetType(name));

                    attrExtra.setDefaultValue(null); // TODO: delete default value

                }

                int size = exportAttr.getSize();

                attrExtra.setSize(size);

            }        

        }

        return targetFeatureType.getNotEditableCopy();

    }

    @Override

    public void setSourceFeatureType(FeatureType sourceFeatureType, FeatureQuery query) {

        this.query = query;

        if (!sourceFeatureType.equals(this.sourceFeatureType)) {

            this.sourceFeatureType = sourceFeatureType;

            this.fillExportAttributes(this.sourceFeatureType, query);

        }

    }

    @Override

    public FeatureType getSourceFeatureType() {

        return this.sourceFeatureType;

    }

    @Override

    public String getTargetName(String name) {

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

            ExportAttribute exportAttribute = exportAttributes.get(i);

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                String newName = exportAttribute.getNewName();

//TODO return value or fixed value?

//                if (!this.namesTranslator.isValidName(this, i, newName)) {

//                    newName = this.namesTranslator.getNameSuggestion(this, i, newName);

//                    //exportAttribute.setNewName(newName); //Change the name in the exportAttribute after chacking

//                }

                return newName;

            }

        }

        return null;

    }

    @Override

    public String getSourceName(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equalsIgnoreCase(exportAttribute.getNewName(), name)) {

                return exportAttribute.getName();

            }

        }

        return null;

    }

    @Override

    public int getTargetType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute.getNewDataType();

            }

        }

        return 0;

    }

    @Override

    public int getSourceType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getNewName(), name)) {

                return exportAttribute.getDataType();

            }

        }

        return 0;

    }

    @Override

    public boolean isAttributeNamesValid() {

        if (this.namesTranslator == null) {

            return true;

        }

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

            ExportAttribute attr = exportAttributes.get(i);

            if (!this.namesTranslator.isValidName(this, i, attr.getNewName())) {

                return false;

            }

        }

        return true;

    }

    @Override

    public void fixAttributeNames() {

        if (this.isAttributeNamesValid() == true) {

            return;

        }

        if (this.namesTranslator == null) {

            return;

        }

        int n = 0;

        while (!this.isAttributeNamesValid()) {

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

                ExportAttribute attr = exportAttributes.get(i);

                String newName = attr.getNewName();

                if (!this.namesTranslator.isValidName(this, i, newName)) {

                    String sug = this.namesTranslator.getNameSuggestion(this, i, newName);

                    attr.setNewName(sug);

                }

            }

            if (n > 5000) {

                LOGGER.warn("Not been able to fix attribute field names, it will require a manual operation");

                break;

            }

            n += 1;

        }

    }

    @Override

    public ExportAttributes clone() throws CloneNotSupportedException {

        DefaultExportAttributes clone = (DefaultExportAttributes) super.clone();

        this.namesTranslator.clone();

        clone.setNamesTranslator(this.namesTranslator.clone());

        List cloneListAttribute = new ArrayList();

        for (ExportAttribute exportAttribute : exportAttributes) {

            cloneListAttribute.add(exportAttribute.clone());

        }

        clone.setExportAttributes(cloneListAttribute);

        return clone;

    }

    @Override

    public void setExportAttributes(List<ExportAttribute> exportAttributes) {

        this.exportAttributes = exportAttributes;

    }

    @Override

    public void setActive(boolean active) {

        this.active = active;

    }

    @Override

    public boolean isActive() {

        return this.active;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("ExportAttributes") == null) {

            DynStruct definition = manager.addDefinition(DefaultExportAttributes.class,

                    "ExportAttributes", "ExportAttributes persistence definition", null, null);

            definition.addDynFieldList("exportAttributes").setClassOfItems(ExportAttribute.class);

            definition.addDynFieldObject("namesTranslator").setClassOfValue(AttributeNamesTranslator.class);

            definition.addDynFieldObject("sourceFeatureType").setClassOfValue(FeatureType.class);

            definition.addDynFieldBoolean("active");

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("exportAttributes", this.exportAttributes.iterator());

        state.set("namesTranslator", this.namesTranslator);

        state.set("sourceFeatureType", this.sourceFeatureType);

        state.set("active", this.active);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        Iterator it = state.getIterator("exportAttributes");

        List<ExportAttribute> data = new ArrayList<ExportAttribute>();

        while (it.hasNext()) {

            ExportAttribute ref = (ExportAttribute) it.next();

            data.add(ref);

        }

        this.exportAttributes = data;

        AttributeNamesTranslator nameTranslatorState = (AttributeNamesTranslator) state.get("namesTranslator");

        if (nameTranslatorState != null) {

            this.namesTranslator = nameTranslatorState;

        }

        this.sourceFeatureType = (FeatureType) state.get("sourceFeatureType");

        this.active = state.getBoolean("active");

    }

}