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.fmap.dal.store.gml.virtualrows;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.apache.commons.collections4.map.LinkedMap;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.store.gml.virtualrows.GfsFile.PropertyDefn;

import org.gvsig.fmap.dal.store.gml.virtualrows.xmlinfo.XMLAttributeInfoImpl;

import org.gvsig.fmap.dal.store.gml.virtualrows.xmlinfo.XMLInfoImpl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.IsEmpty;

import org.gvsig.tools.util.Size;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.Locator;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

/**

 *

 * @author fdiaz

 */

public class GfsFile implements Iterable<PropertyDefn>, IsEmpty, Size {

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

    private static final String PROPERTY_NAME_SEPARATOR = "_";

    private static final String PROPERTY_PATH_SEPARATOR = "|";

    private static final String PROPERTY_ATTRIBUTE_SEPARATOR = "@";

    public static class PropertyDefn {

        private String name;

        private String elementPath;

        private int type;

        private int width;

        private boolean isAttr;

        public PropertyDefn() {

        }

        public PropertyDefn(String name, String elementPath, int type, int width, boolean isAttr) {

            this.name = name;

            this.elementPath = elementPath;

            this.type = type;

            this.width = width;

            this.isAttr = isAttr;

        }

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public String getElementPath() {

            return elementPath;

        }

        public void setElementPath(String elementPath) {

            this.elementPath = elementPath;

        }

        public int getType() {

            return type;

        }

        public void setType(int type) {

            this.type = type;

        }

        public int getWidth() {

            return width;

        }

        public void setWidth(int width) {

            this.width = width;

        }

        public boolean isAttr() {

            return isAttr;

        }

        public void setIsAttr(boolean b) {

            this.isAttr = b;

        }

        @Override

        public boolean equals(Object obj) {

            if(!(obj instanceof PropertyDefn)) {

                return false;

            }

            PropertyDefn other = (PropertyDefn)obj;

            if(!StringUtils.equals(this.getName(), other.getName())){

                return false;

            }

            if(!StringUtils.equals(this.getElementPath(), other.getElementPath())){

                return false;

            }

            if(this.getType()!=other.getType()){

                return false;

            }

            if(this.getWidth()!=other.getWidth()){

                return false;

            }

            if(this.isAttr()!=other.isAttr()){

                return false;

            }

            return true;

        }

    }

    private String name;

    private List<String> geometryElementPaths;

    private String baseElementPath;

    private Map<String, PropertyDefn> properties;

    private int gmlVersion;

    private List<String> geometryElementSrss;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public List<String> getGeometryElementSrss() {

        return geometryElementSrss;

    }

    public List<String> getGeometryElementPaths() {

        return geometryElementPaths;

    }

    public void setGeometryElementPaths(List<String> geometryElementPaths) {

        this.geometryElementPaths = geometryElementPaths;

    }

    public void addGeometryElementPath(String geometryElementPath) {

        if(StringUtils.isBlank(geometryElementPath)){

            return;

        }

        if(this.geometryElementPaths == null){

            this.geometryElementPaths = new ArrayList<>();

        }

        this.geometryElementPaths.add(geometryElementPath);

    }

    public void addGeometryElementSrs(String geometryElementSrs) {

        if(StringUtils.isBlank(geometryElementSrs)){

            return;

        }

        if(this.geometryElementSrss == null){

            this.geometryElementSrss = new ArrayList<>();

        }

        if(StringUtils.equalsIgnoreCase("null", geometryElementSrs)){

            this.geometryElementSrss.add(null);

        } else {

            this.geometryElementSrss.add(geometryElementSrs);

        }

    }

    public String getBaseElementPath() {

        return baseElementPath;

    }

    public void setBaseElementPath(String baseElementPath) {

        this.baseElementPath = baseElementPath;

    }

    private String findBaseElementPath(XMLInfoImpl xmlinfo) {

        String possibleMemberPath = null;

        for (String path : xmlinfo.getTagsPaths()) {

            XMLAttributeInfoImpl tag = xmlinfo.getTag(path);

            if (StringUtils.isBlank(possibleMemberPath)

                    && !tag.isAttr() 

                    && !StringUtils.equalsIgnoreCase(tag.getNs(), "gml")

                    && !StringUtils.equalsIgnoreCase(path, "FeatureCollection/boundedBy")

                    ) {

                String[] ss = path.split("/");

                if(ss.length == 2){

                    possibleMemberPath = path;

                }

            }

            if (path.equalsIgnoreCase("FeatureCollection/member")) {

                return path;

            } else if (path.equalsIgnoreCase("FeatureCollection/featureMember")) {

                return path;

            }

        }

        return possibleMemberPath;

    }

    private List<String> findGeometryElementSrss(XMLInfoImpl xmlinfo, List<String> elementPaths) {

        List<String> result = new ArrayList<>();

        if(elementPaths != null) {

            for (String elementPath : elementPaths) {

                XMLAttributeInfoImpl x = xmlinfo.getTag(elementPath);

                if(x==null){

                    result.add(null);

                } else {

                    result.add(x.getSrs());

                }

            }

        }

        return result;

    }

    private List<String> findGeometryElementPaths(XMLInfoImpl xmlinfo) {

        List<String> result = new ArrayList<>();

        List<String> paths = new ArrayList<>();

        for (String path : xmlinfo.getTagsPaths()) {

            XMLAttributeInfoImpl tag = xmlinfo.getTag(path);

            if(tag.isAttr()){

                continue;

            }

            paths.add(path);

        }

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

            String path = paths.get(i);

            XMLAttributeInfoImpl tag = xmlinfo.getTag(path);

            if(i == paths.size()-1){

                continue;

            }

            XMLAttributeInfoImpl nextTag = xmlinfo.getTag(paths.get(i+1));

            String p = null;

            switch(nextTag.getName().toUpperCase()){

                case "POINT":

                case "MULTIPOINT":

                case "LINESTRING":

                    p=path;

                    this.gmlVersion = 0;

                    break;

                case "POLYGON":

                case "MULTIPOLYGON":

                    p=path;

                    this.gmlVersion = 2;

                    break;

                case "SURFACE":

                case "MULTISURFACE":

                case "CURVE":

                case "MULTICURVE":

                    p=path;

                    this.gmlVersion = 3;

            }

            if(p!=null){

                for (String s : result) {

                    if(StringUtils.startsWithIgnoreCase(p, s)){

                        p=null;

                        break;

                    }

                }

                if (p != null) {

                    result.add(p);

//                    tag.setSrs(nextTag.getSrs());

                }

            }

        }

        if(result.isEmpty()){

            return null;

        }

        return result;

    }

    @Override

    public String toString() {

        try {

            DataTypesManager datatypesManager = ToolsLocator.getDataTypesManager();

            StringBuilder builder = new StringBuilder();

            builder.append("<GMLFeatureClassList>\n"

                    + "  <GMLFeatureClass>\n"

                    + "    <Name>"+getName()+"</Name>\n"

                    + "    <ElementPath>"+getBaseElementPath()+"</ElementPath>\n"

            );

            for (String geometryElementPath : getGeometryElementPaths()) {

                builder.append("    <GeometryElementPath>"+geometryElementPath+"</GeometryElementPath>\n");

            }

            for (String geometryElementSrs : getGeometryElementSrss()) {

                builder.append("    <GeometryElementSrs>"+geometryElementSrs+"</GeometryElementSrs>\n");

            }

            for (PropertyDefn property : properties.values()) {

                int type = property.getType();

                String propertyType = datatypesManager.getTypeName(type);

                builder.append("    <PropertyDefn>\n");

                builder.append("      <Name>");

                builder.append(property.getName());

                builder.append( "</Name>\n");

                builder.append("      <ElementPath>");

                builder.append(property.getElementPath());

                if (property.isAttr()) {

                    //cambiamos el ?ltimo | por @

                    int lastIndex = builder.lastIndexOf(PROPERTY_PATH_SEPARATOR);

                    builder.replace(lastIndex, PROPERTY_PATH_SEPARATOR.length() + lastIndex, PROPERTY_ATTRIBUTE_SEPARATOR);

                }

                builder.append("</ElementPath>\n");

                builder.append("      <Type>");

                builder.append(propertyType);

                builder.append("</Type>\n");

                if(type == DataTypes.STRING){

                    builder.append("      <Width>");

                    builder.append(property.getWidth());

                    builder.append("</Width>\n");

                }

                builder.append("    </PropertyDefn>\n");

            }

            builder.append("  </GMLFeatureClass>\n"

                    + "</GMLFeatureClassList>");

            return builder.toString();

        } catch (Exception ex) {

            LOGGER.warn("Can't generate gfs file", ex);

            return null;

        }

    }

    private void removeBaseInGeometryPaths() {

        if(geometryElementPaths == null){

            return;

        }

        List<String> l = new ArrayList<>();

        for (String geometryElementPath : geometryElementPaths) {

            if (geometryElementPath.startsWith(baseElementPath + "/")) {

                geometryElementPath = geometryElementPath.substring(baseElementPath.length() + 1);

            }

            l.add(geometryElementPath);

        }

        this.geometryElementPaths = l;

    }

    public void fetch(File gmlFile) {

        this.properties = new LinkedMap<>();

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("GML");

        status.setAutoremove(true);

        try {

            status.add();

            StructureExtractorImpl extractor = new StructureExtractorImpl();

             //Ojo con defaultCharset

            XMLInfoImpl xmlinfo = extractor.extractStructure(gmlFile, null, Locale.getDefault(), status);

            this.name = FilenameUtils.getBaseName(gmlFile.getName());

            this.baseElementPath = findBaseElementPath(xmlinfo);

            this.geometryElementPaths = findGeometryElementPaths(xmlinfo);

            this.geometryElementSrss = findGeometryElementSrss(xmlinfo,this.geometryElementPaths);

            removeBaseInGeometryPaths();

            for (String path : xmlinfo.getTagsPaths()) {

                XMLAttributeInfoImpl tag = xmlinfo.getTag(path);

                if (tag.hasChilds()) {

                    continue;

                }

                if (path.startsWith(baseElementPath+"/")) {

                    path = path.substring(baseElementPath.length()+1);

                } else {

                    continue;

                }

                boolean found = false;

                if(geometryElementPaths != null){

                    for (String geometryElementPath : geometryElementPaths) {

                        if (path.equals(geometryElementPath)) {

                            found = true;

                            break;

                        }

                        if (path.startsWith(geometryElementPath+"/")) {

                            if(tag.getNs().equalsIgnoreCase("gml")){

                                found = true;

                                break;

                            }

                        }

                    }

                    if(found){

                        continue;

                    }

                }

                if(path.indexOf('/') < 0 && tag.isAttr()){

                    continue;

                }

                String[] path_ss = path.split("/");

                String lastName = path_ss[path_ss.length -1];

                String propertyName = StringUtils.replace(path, "/", PROPERTY_NAME_SEPARATOR);

                if(StringUtils.endsWith(path, "$v")){

                    propertyName = StringUtils.replace(propertyName, PROPERTY_NAME_SEPARATOR+lastName+"$v", "");

                }

                String propertyPath = StringUtils.replace(path, "/", PROPERTY_PATH_SEPARATOR);

                if(StringUtils.endsWith(path, "$v")){

                    propertyPath = StringUtils.replace(propertyPath, PROPERTY_PATH_SEPARATOR+lastName+"$v", "");

                }

                propertyPath = StringUtils.replace(propertyPath, "$v", "");

                this.properties.put(propertyName, new PropertyDefn(propertyName, propertyPath, tag.getType(), tag.getSize(), tag.isAttr()));

            }

            status.terminate();

        } catch (Exception ex) {

            LOGGER.warn("Can't generate gfs file", ex);

            status.abort();

            throw new RuntimeException("", ex);

        }

    }

    public void load(File gfsFile) {

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("GML");

        status.setAutoremove(true);

        this.setName(null);

        this.setBaseElementPath(null);

        this.setGeometryElementPaths(null);

        this.properties = new LinkedMap<>();

        try {

            status.add();

            InputSource is = XmlCommons.openReader(gfsFile,null);

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(true);

            List<String> path = new ArrayList<>();

            DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

            SAXParser saxParser = spf.newSAXParser();

            saxParser.parse(gfsFile, new DefaultHandler() {

                private Locator locator;

                int refreshInterval = 1;

                StringBuilder chars = new StringBuilder();

                PropertyDefn property = null;

//                boolean readingProperty = false;

//                String propertyName = null;

//                String propertyElementPath = null;

//                Integer propertyType = null;

//                Integer propertyWidth = null;

                @Override

                public void setDocumentLocator(Locator locator) {

                    this.locator = locator;

                }

                @Override

                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                    int line = this.locator.getLineNumber();

//                    int column = this.locator.getColumnNumber()-2-localName.length();

                    if(line % refreshInterval == 0) {

                        status.setCurValue(line);

                    }

                    if(line > 100000){

                        refreshInterval = 10000;

                    } else if(line > 10000){

                        refreshInterval = 1000;

                    } else if(line > 1000){

                        refreshInterval = 100;

                    } else if(line > 100){

                        refreshInterval = 10;

                    }

                    if(StringUtils.equals(localName, "PropertyDefn")){

                        property = new PropertyDefn();

//                        readingProperty = true;

                    }

                    path.add(localName);

                    chars.setLength(0);

                }

                @Override

                public void endElement(String uri, String localName, String qName) throws SAXException {

                    if(StringUtils.equals(localName, "PropertyDefn")){

                        properties.put(this.property.getName(), property);

                        property = null;

                    } else if(this.property != null){

                        if(StringUtils.equals(localName, "Name")){

                            String value = this.chars.toString();

                            this.property.setName(value);

                        } else if(StringUtils.equals(localName, "ElementPath")){

                            String value = this.chars.toString();

                            if(value.indexOf(PROPERTY_ATTRIBUTE_SEPARATOR)>=0){

                                this.property.setIsAttr(true);

                                value = value.replace(PROPERTY_ATTRIBUTE_SEPARATOR, PROPERTY_PATH_SEPARATOR);

                            }

                            this.property.setElementPath(value);

                        } else if(StringUtils.equals(localName, "Type")){

                            String value = this.chars.toString();

                            this.property.setType(dataTypesManager.getType(value));

                        } else if(StringUtils.equals(localName, "Width")){

                            int value = Integer.valueOf(this.chars.toString());

                            this.property.setWidth(value);

                        }

                    } else {

                        if(StringUtils.equals(localName, "Name")){

                            String value = this.chars.toString();

                            setName(value);

                        } else if(StringUtils.equals(localName, "ElementPath")){

                            String value = this.chars.toString();

                            setBaseElementPath(value);

                        } else if(StringUtils.equals(localName, "GeometryElementPath")){

                            String value = this.chars.toString();

                            addGeometryElementPath(value);

                        } else if(StringUtils.equals(localName, "GeometryElementSrs")){

                            String value = this.chars.toString();

                            addGeometryElementSrs(value);

                        }

                    }

                    chars.setLength(0);

                }

                @Override

                public void characters(char[] ch, int start, int length) throws SAXException {

                    this.chars.append(ch, start, length);

                }

            }

            );

            status.terminate();

        } catch (Exception ex) {

            status.abort();

            throw new RuntimeException("Can't load gfs file '"+gfsFile.getAbsolutePath()+"'", ex);

        }

    }

    public void save(File gfsFile) throws IOException {

        BufferedWriter writer = null;

        try {

            writer = new BufferedWriter(new FileWriter(gfsFile));

            writer.append(this.toString());

        } finally {

            IOUtils.closeQuietly(writer);

        }

    }

    @Override

    public Iterator<PropertyDefn> iterator() {

        return this.properties.values().iterator();

    }

    @Override

    public boolean isEmpty() {

        return this.properties.isEmpty();

    }

    @Override

    public int size() {

        return this.properties.size();

    }

    public List<String> getPropertiesPaths() {

        List<String> res = new ArrayList<>();

        for (PropertyDefn property : this.properties.values()) {

            res.add(property.getElementPath().replace(PROPERTY_PATH_SEPARATOR, "/"));

        }

        return res;

    }

    public PropertyDefn get(String propertyName) {

        return this.properties.get(propertyName);        

    }

    @Override

    public boolean equals(Object obj) {

        if(!(obj instanceof GfsFile)) {

            return false;

        }

        GfsFile other = (GfsFile)obj;

        if(!this.name.equals(other.getName())){

            return false;

        }

        if(!this.baseElementPath.equals(other.getBaseElementPath())){

            return false;

        }

        if(!this.geometryElementPaths.equals(other.getGeometryElementPaths())){

            return false;

        }

        if(this.size() != other.size()){

            return false;

        }

        for (PropertyDefn property : this) {

            PropertyDefn otherProperty = other.get(property.getName());

            if(!property.equals(otherProperty)){

                System.out.println("MY :"+property.getElementPath());

                System.out.println("OT :"+otherProperty.getElementPath());

                return false;

            }

        }

        return true;

    }

    public static void main(String[] args) throws Exception {

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/1075305YJ2717N.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/Recinto.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/FG-GML-543863-AdmBdry-20190101-0001.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/Municipis.gml";

        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/navarra.gml";

        new DefaultLibrariesInitializer().fullInitialize();

        GfsFile gfs = new GfsFile();

        gfs.fetch(new File(XMLFILE1));

        System.out.println(gfs.toString());

        System.out.println(StringUtils.join(gfs.getPropertiesPaths(), "\n"));

        File gfsFile = new File(FilenameUtils.removeExtension(XMLFILE1)+".gfs");

        gfs.save(gfsFile);

        GfsFile gfs2 = new GfsFile();

        gfs2.load(gfsFile);

        System.out.println("=========================================");

        System.out.println(gfs.toString());

        System.out.println(StringUtils.join(gfs.getPropertiesPaths(), "\n"));

        System.out.println("Los gfs "+(gfs.equals(gfs2)?"S?":"NO")+" son iguales");

    }

}