Application: gvSIG desktop

import org.gvsig.fmap.dal.store.csv.simplereaders.GMLReader;

        } else if (FilenameUtils.isExtension(filename, "gml")){

            reader= new GMLReader(in,parameters);

/*

 * To change this license theHeader, 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.csv.simplereaders;

import java.io.File;

import java.io.IOException;

import java.io.Reader;

import java.nio.charset.Charset;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.fmap.dal.store.csv.CSVStoreParameters;

import org.gvsig.fmap.dal.store.csv.xml.GfsFile;

import org.gvsig.fmap.dal.store.csv.xml.XMLFileAsList;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class GMLReader extends AbstractSimpleReader {

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

    private XMLFileAsList gml;

    private int columns;

    private String[] header;

    private int currentElement = 0;

    private final CSVStoreParameters parameters;

    private GfsFile gfs;

    public GMLReader(Reader reader, CSVStoreParameters csvParameters) throws IOException {

        File gmlFile = csvParameters.getFile();

        File gmlIdx = new File(FilenameUtils.removeExtension(gmlFile.getName())+".gmlidx");

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

        gfs = new GfsFile();

        if(gmlIdx.exists()){

            //TODO: Comparar fechas del gfs y gml

            gfs.load(gfsFile);

        } else {

            gfs.fetch(gmlFile);

            gfs.save(gfsFile);

        }

        this.gml = new XMLFileAsList(

                gmlFile, 

                gmlIdx, 

                Charset.forName(CSVStoreParameters.getCharset(csvParameters)), 

                gfs.getBaseElementPath(),

                gfs.getGeometryElementPaths(),

                gfs.getPropertiesPaths()

        );

        this.columns = -1;

        this.header = null;

        this.parameters = csvParameters;

    }

    @Override

    public String[] getHeader() throws IOException {

        if (this.header == null) {

            String[] theHeader = new String[gfs.size()];

            int i = 0;

            for (GfsFile.PropertyDefn item : gfs) {

                theHeader[i++] = item.getName();

            }

            this.header = theHeader;

        }

        return this.header;

    }

    @Override

    public int getColumnsCount() throws IOException {

        if (this.columns <= 0) {

            this.columns = this.getHeader().length;

        }

        return this.columns;

    }

    @Override

    public List<String> read() throws IOException {

        List<String> values = this.read(currentElement);

        if (values == null) {

            return null;

        }

        currentElement += 1;

        return values;

    }

    public List<String> read(int rowNumber) throws IOException {

        if (rowNumber < gml.size()) {

            List<String> values = gml.get(rowNumber);

            return values;

        }

        return null;

    }

    @Override

    public void close() throws IOException {

        this.gml.close();

        this.gml = null;

        this.gfs = null;

    }

    @Override

    public List<String> skip(int lines) throws IOException {

        this.currentElement += lines;

        if (this.currentElement > this.gml.size()) {

            return null;

        }

        return read(this.currentElement);

    }

    @Override

    public int getLine() {

        if (this.gml == null) {

            return 0;

        }

        return this.currentElement;

    }

    @Override

    public List<String> nextRowValues() {

        try {

            return this.read();

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

}

package org.gvsig.fmap.dal.store.csv.xml;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.Charset;

import org.apache.commons.io.IOUtils;

import org.apache.commons.io.input.BOMInputStream;

import org.apache.commons.lang3.StringUtils;

import org.apache.tika.detect.AutoDetectReader;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.xml.sax.InputSource;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class XmlCommons {

    public static Charset detectCharset(InputStream is) { 

        try {            

            AutoDetectReader reader = new AutoDetectReader(is);

            return reader.getCharset();

        } catch(Throwable t) {

            return null;

        }

    }

    public static String detectCharsetName(InputStream is) {        

        Charset charset = detectCharset(is);

        if( charset==null ) {

            return null;

        }

        return charset.name();

    }

    public static InputSource openReader(File xmlfile, Charset charset) {

        try {

            FileInputStream fis = new FileInputStream(xmlfile);

            InputSource is = new InputSource();

            is.setPublicId(xmlfile.getAbsolutePath());

            is.setByteStream(fis);

            if( charset!=null ) {

                is.setEncoding(charset.name());

            }            

            return openReader(is);

        } catch(Throwable t) {

            throw new RuntimeException("Can't open xml input stream.",t);

        }

    }

    public static InputSource openReader(InputStream xml, Charset charset) {

            InputSource is = new InputSource();

            is.setByteStream(xml);

            if( charset!=null ) {

                is.setEncoding(charset.name());

            }            

            return openReader(is);

    }

    public static InputSource openReader(InputSource is) {

        try {            

            if(StringUtils.isBlank(is.getEncoding())){

//                EncodingDetector encodingDetector = TikaConfig.getDefaultConfig().getEncodingDetector();

//                BufferedInputStream bis = new BufferedInputStream(is.getByteStream());

//                Charset charset = encodingDetector.detect(bis, new Metadata());

//                is.setEncoding(charset.name());

//                is.setByteStream(bis);

                AutoDetectReader reader = new AutoDetectReader(is.getByteStream());

                is.setCharacterStream(reader);

                is.setEncoding(reader.getCharset().name());

            } else {

                BOMInputStream bomIs = new BOMInputStream(is.getByteStream());

                is.setByteStream(bomIs);

                InputStreamReader reader = new InputStreamReader(

                        is.getByteStream(),

                        is.getEncoding()

                );

                is.setCharacterStream(reader);

            }

            return is;

        } catch(Throwable t) {

            throw new RuntimeException("Can't open xml input stream.",t);

        }

    }

    public static long countLines(File xml, Charset charset, SimpleTaskStatus status) {

        try {

            FileInputStream fis = new FileInputStream(xml);

            return countLines(fis, charset, status);

        } catch(Throwable t) {

            throw new RuntimeException("Can't count lines.",t);

        }

    }

    public static long countLines(InputStream xml, Charset charset, SimpleTaskStatus status) {

        try {

            long count = 0;

//            Reader reader = null;

            BufferedReader br = null;

            status.setIndeterminate();

            status.setCurValue(0);

            try {

                InputSource is = new InputSource(xml);

                if( charset!=null ) {

                    is.setEncoding(charset.name());

                }

                is = openReader(is);

                br = new BufferedReader(is.getCharacterStream());

                int n = 1;

                I18nManager i18n = ToolsLocator.getI18nManager();

                while( br.readLine()!=null ) {

                    if(count%n == 0){

                        status.message(i18n.getTranslation("_Calculating_lines"));

                        status.setCurValue(count);

                    }

//                    status.incrementCurrentValue();

                    count++;

                    if(count > 100000){

                        n = 10000;

                    } else if(count > 10000){

                        n = 1000;

                    } else if(count > 1000){

                        n = 100;

                    } else if(count > 100){

                        n = 10;

                    }

                }

            } finally {

                IOUtils.closeQuietly(br);

            }

            return count;

        } catch(Throwable t) {

            throw new RuntimeException("Can't count lines.",t);

        }

    }    

}

package org.gvsig.fmap.dal.store.csv.xml.xmlinfo;

import java.nio.charset.Charset;

import java.util.Collection;

import java.util.LinkedHashMap;

import java.util.Locale;

import java.util.Map;

/**

 *

 * @author jjdelcerro

 */

public class XMLInfoImpl {

    private final Map<String,XMLAttributeInfoImpl> tags;

    private long countLines;

    private Charset charset;

    private Locale locale;

    public XMLInfoImpl() {

        this.tags = new LinkedHashMap<>();

        this.countLines = -1;

    }

    public XMLAttributeInfoImpl getTag(String path) {

        return this.tags.get(path);

    }

    public Collection<String> getTagsPaths() {

        return this.tags.keySet();

    }

    public void addTag(XMLAttributeInfoImpl info) {

        tags.put(info.getPath(), info);

    }

    public XMLAttributeInfoImpl getTagInfo(String path) {

        return this.tags.get(path);

    }

    public void setCountLines(long countlines) {

        this.countLines = countlines;

    }

    public long getCountLines() {

        return this.countLines;

    }

    public Charset getCharset() {

        return this.charset;

    }

    public void setCharset(Charset charset) {

        this.charset = charset;

    }

    public Locale getLocale() {

        return this.locale;

    }

    public void setLocale(Locale locale) {

        this.locale = locale;

    }

}

/*

 * 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.csv.xml.xmlinfo;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import org.apache.commons.io.FilenameUtils;

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

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

/**

 *

 * @author jjdelcerro

 */

public class XMLAttributeInfoImpl {

    private String path;

    private String name;

    private int type;

    private Map<String, MutableInt> childCounts;

    private Map<String, Integer> childCountsMax;

    private Map<String, String> childIds;

    private DataTypeDetector dataTypeDetector;

    private boolean isAttr;

    private String ns;

    protected XMLAttributeInfoImpl(Locale locale) {

        this.path = null;

        this.name = null;

        this.type = DataTypes.STRING;

        this.childCounts = new HashMap<>();

        this.childIds = new HashMap<>();

        this.childCountsMax = new HashMap<>();

        this.dataTypeDetector = DALLocator.getDataManager().createDataTypeDetector(locale);

        this.isAttr = false;

    }

    public XMLAttributeInfoImpl(Locale locale, String path, String ns) {

        this(locale);

        this.path = path;

        this.name = FilenameUtils.getBaseName(path);

        this.ns = ns;

        //            if( StringUtils.contains(this.path, "/ALCOHOL/") ) {

        //                System.out.println("### TAG: "+this.path);

        //            }

    } //            if( StringUtils.contains(this.path, "/ALCOHOL/") ) {

    //                System.out.println("### TAG: "+this.path);

    //            }

    public XMLAttributeInfoImpl(Locale locale, String name, int type) {

        this(locale);

        this.name = name;

        this.setType(type);

    }

    public String getName() {

        return name;

    }

    public String getPath() {

        return path;

    }

    public void setType(int type) {

        this.type = type;

        this.dataTypeDetector = null;

    }

    public int getType() {

        if (this.dataTypeDetector == null) {

            return this.type;

        }

        int x = this.dataTypeDetector.getDataType().getType();

        if (x == DataTypes.UNKNOWN) {

            return DataTypes.STRING;

        }

        return x;

    }

    public int getPrecision() {

        if (this.dataTypeDetector == null) {

            return DataType.PRECISION_NONE;

        }

        return this.dataTypeDetector.getDataType().getPrecision();

    }

    public int getScale() {

        if (this.dataTypeDetector == null) {

            return DataType.SCALE_NONE;

        }

        return this.dataTypeDetector.getDataType().getScale();

    }

    public int getSize() {

        if (this.dataTypeDetector == null) {

            return 0;

        }

        if (this.getType() != DataTypes.STRING) {

            return 0;

        }

        int size = this.dataTypeDetector.getDataType().getDisplaySize();

        if (size > 0) {

            size = ((size + 10) / 10) * 10;

        }

        return size;

    }

    public GeometryType getGeometryType() {

        if (this.dataTypeDetector == null) {

            return null;

        }

        return this.dataTypeDetector.getDataType().getGeometryType();

    }

    public String getNs() {

        return ns;

    }

    @Override

    public String toString() {

        DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

        StringBuilder builder = new StringBuilder();

        builder.append(name);

        builder.append(" ");

        builder.append(dataTypeManager.getTypeName(this.getType()));

        switch (this.getType()) {

            case DataTypes.STRING:

                builder.append("(");

                builder.append(this.getSize());

                builder.append(")");

                break;

            case DataTypes.DECIMAL:

                builder.append("(");

                builder.append(this.getPrecision());

                builder.append(",");

                builder.append(this.getScale());

                builder.append(")");

                break;

            case DataTypes.GEOMETRY:

                builder.append("(");

                builder.append(this.getGeometryType().getFullName());

                builder.append(")");

                break;

        }

        return builder.toString();

    }

    public void incrChildCount(String childName) {

        MutableInt count = this.childCounts.get(childName);

        if (count == null) {

            count = new MutableInt(0);

            this.childCounts.put(childName, count);

        }

        count.increment();

    }

    public void setLastChildID(String childName, String idvalue) {

        this.childIds.put(childName, idvalue);

    }

    public String getLastChildID(String childName) {

        return this.childIds.get(childName);

    }

    public void consolidateChildCounters() {

        for (Map.Entry<String, MutableInt> entry : childCounts.entrySet()) {

            String childName = entry.getKey();

            MutableInt count = entry.getValue();

            int countmax = this.childCountsMax.getOrDefault(childName, -1);

            if (countmax < count.getValue() || countmax < 0) {

                this.childCountsMax.put(childName, count.getValue());

            }

            childCounts.get(childName).setValue(0);

        }

    }

    public int getMaxChildCount(String childName) {

        int countmax = this.childCountsMax.getOrDefault(childName, 0);

        return countmax;

    }

    public void setSize(int size) {

        if (this.dataTypeDetector == null) {

            return;

        }

        DataTypeDetector.DataTypeDetected detectedType = this.dataTypeDetector.getDataType();

        detectedType.setDisplaySize(size);

    }

    public void addValue(String value) {

        if (this.dataTypeDetector == null) {

            return;

        }

        this.dataTypeDetector.addValue(value);

    }

    public boolean hasChilds() {

        return  !this.childCounts.isEmpty();

    }

    public int getChildsCount(String name) {

        MutableInt count = this.childCounts.get(name);

        if(count == null){

            return 0;

        }

        return count.getValue();

    }

    public void setIsAttr(boolean isAttr) {

        this.isAttr = isAttr;

    }

    public boolean isAttr() {

        return this.isAttr;

    }

}

/*

 * 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.csv.xml;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.apache.commons.lang3.StringUtils;

import org.apache.tika.utils.CharsetUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.store.csv.xml.xmlinfo.XMLAttributeInfoImpl;

import org.gvsig.fmap.dal.store.csv.xml.xmlinfo.XMLInfoImpl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

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 jjdelcerro

 */

public class StructureExtractorImpl { //implements StructureExtractor {

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

    @SuppressWarnings("UseSpecificCatch")

    private void extractTags(XMLInfoImpl xmlinfo, Reader reader, SimpleTaskStatus status) {

        if( reader == null ) {

            throw new IllegalArgumentException("reader is null");

        }

        try {

            final DataManager dataManager = DALLocator.getDataManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            status.message(i18n.getTranslation("_Reading_xml")+" 1/5");

            status.setRangeOfValues(0, xmlinfo.getCountLines());

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(true);

            SAXParser saxParser = spf.newSAXParser();

            InputSource is = new InputSource(reader);

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

            saxParser.parse(is, new DefaultHandler() {

                private Locator locator;

                int size;

                int refreshInterval = 1;

                StringBuilder chars = new StringBuilder();

                @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;

                    }

                    String idvalue = dataManager.createUniqueID();

                    path.add(localName);

                    String path_s = StringUtils.join(path, "/");

                    XMLAttributeInfoImpl info = xmlinfo.getTag(path_s);

                    if( info == null ) {

                        info = new XMLAttributeInfoImpl(xmlinfo.getLocale(), path_s, getNs(qName));

                        xmlinfo.addTag(info);

                    }

                    if( path.size()>1 ) {

                        List<String> parentpath = path.subList(0, path.size()-1);

                        String parentpath_s = StringUtils.join(parentpath, "/");

                        XMLAttributeInfoImpl parentinfo = xmlinfo.getTag(parentpath_s);

                        parentinfo.incrChildCount(localName);

                        parentinfo.setLastChildID(localName, idvalue);

                    }

                    for (int i = 0; i < attributes.getLength(); i++) {

                        String name = attributes.getLocalName(i);                        

                        String value = attributes.getValue(i);

                        String idvalueChild = dataManager.createUniqueID();

                        XMLAttributeInfoImpl infoChild = xmlinfo.getTag(path_s+"/"+name);

                        if( infoChild == null ) {

                            infoChild = new XMLAttributeInfoImpl(xmlinfo.getLocale(), path_s+"/"+name, getNs(qName));

                            infoChild.setIsAttr(true);

                            xmlinfo.addTag(infoChild);

                        }

                        info.incrChildCount(infoChild.getName());

                        info.setLastChildID(infoChild.getName(), idvalueChild);

                        infoChild.addValue(value);

                    }

                    chars.setLength(0);

                }

                @Override

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

                    int line = this.locator.getLineNumber();

//                    status.setCurValue(line);

                    String path_s = StringUtils.join(path, "/");

                    XMLAttributeInfoImpl info = xmlinfo.getTag(path_s);

                    if( info == null ) {

                        info = new XMLAttributeInfoImpl(xmlinfo.getLocale(), path_s, getNs(qName));

                        xmlinfo.addTag(info);

                    }

                    XMLAttributeInfoImpl parentinfo = null;

                    if( path.size()>1 ) {

                        List<String> parentpath = path.subList(0, path.size()-1);

                        String parentpath_s = StringUtils.join(parentpath, "/");

                        parentinfo = xmlinfo.getTag(parentpath_s);

                    }

                    if( info.hasChilds() || (parentinfo != null && (parentinfo.getChildsCount(localName)>1))) {

                        String value = this.chars.toString();

                        if( StringUtils.isNotBlank(value) ) {

                            String name = info.getName()+"$v";                        

                            String idvalueChild = dataManager.createUniqueID();

                            XMLAttributeInfoImpl infoChild = xmlinfo.getTag(path_s+"/"+name);

                            if( infoChild == null ) {

                                infoChild = new XMLAttributeInfoImpl(xmlinfo.getLocale(), path_s+"/"+name, getNs(qName));

                                xmlinfo.addTag(infoChild);

                            }

                            info.incrChildCount(infoChild.getName());

                            info.setLastChildID(infoChild.getName(), idvalueChild);

                            infoChild.addValue(value);

                        }

                    } else {

                        String value = this.chars.toString();

                        info.addValue(value);

                    }

                    info.consolidateChildCounters();

                    path.remove(path.size()-1);

                    chars.setLength(0);

                }

                @Override

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

                    int line = this.locator.getLineNumber();

//                    status.setCurValue(line);

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

                }

            });

        } catch (Exception ex) {

            throw new RuntimeException("Can't extract tags.", ex);

        }

    }

    public XMLInfoImpl extractStructure(File xml, Charset charset, Locale locale, SimpleTaskStatus status) throws FileNotFoundException, IOException {

        XMLInfoImpl xmlinfo = new XMLInfoImpl();

        xmlinfo.setLocale(locale);

        long count = XmlCommons.countLines(xml, charset, status);

        xmlinfo.setCountLines(count);

        InputSource is = XmlCommons.openReader(xml,charset);

        return extractStructure(is, xmlinfo, status);

    }

    public XMLInfoImpl extractStructure(InputStream xml, Charset charset, Locale locale, SimpleTaskStatus status) throws IOException  {

        XMLInfoImpl xmlinfo = new XMLInfoImpl();

        xmlinfo.setLocale(locale);

        xmlinfo.setCountLines(-1);

        InputSource is = XmlCommons.openReader(xml, charset);

        return extractStructure(is, xmlinfo, status);

    }

    public XMLInfoImpl extractStructure(Reader reader, Locale locale, SimpleTaskStatus status) {

        XMLInfoImpl xmlinfo = new XMLInfoImpl();

        xmlinfo.setLocale(locale);

        InputSource is = new InputSource(reader);

        return extractStructure(is, xmlinfo, status);

    }

    public XMLInfoImpl extractStructure(InputSource is, XMLInfoImpl xmlinfo, SimpleTaskStatus status) {

        if( xmlinfo.getCharset()==null ) {

            xmlinfo.setCharset(CharsetUtils.forName(is.getEncoding()));

        }

        extractTags(xmlinfo, is.getCharacterStream(), status);

        return xmlinfo;

    }

    private String getNs(String s){

        String[] ss = s.split(":");

        if(ss.length == 1){

            return null;

        }

        return ss[0];

    }

}

/*

 * 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.csv.xml;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

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.csv.xml.GfsFile.PropertyDefn;

import org.gvsig.fmap.dal.store.csv.xml.xmlinfo.XMLAttributeInfoImpl;

import org.gvsig.fmap.dal.store.csv.xml.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;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    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 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> 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);

                }

            }

        }

        if(result.isEmpty()){

            return null;

        }

        return result;

    }