package com.ximple.eofms;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.FileChannel;
import java.util.HashMap;
import java.util.List;

import org.apache.commons.collections.map.MultiValueMap;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
import org.xml.sax.SAXException;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.ximple.eofms.filter.AbstractFLinkageDispatchableFilter;
import com.ximple.eofms.filter.ElementDispatcher;
import com.ximple.eofms.jobs.context.postgis.FeatureDgnConvertPostGISJobContext;
import com.ximple.io.dgn7.ComplexElement;
import com.ximple.io.dgn7.Dgn7fileException;
import com.ximple.io.dgn7.Dgn7fileReader;
import com.ximple.io.dgn7.Element;
import com.ximple.io.dgn7.ElementType;
import com.ximple.io.dgn7.FrammeAttributeData;
import com.ximple.io.dgn7.Lock;

public class XElementParser implements Runnable
{
    static Log logger = LogFactory.getLog(XElementParser.class);
    static final GeometryFactory geometryFactory = new GeometryFactory();

    static final boolean isCompactMode = true;

    private HashMap<String, String> dataConfig;
    private ElementDispatcher elementDispatcher;
    private MultiValueMap featuresContext = new MultiValueMap();

    public static void main(String[] args)
    {
        XElementParser parser = new XElementParser();
        parser.run();
    }

    public XElementParser()
    {
        initializeDataConfig();
    }

    private void initializeDataConfig()
    {
        dataConfig = new HashMap<String, String>();
        dataConfig.put("DATAPATH", "G:\\Temp\\JobData\\tctpc\\elmout");
        
        elementDispatcher = createElementDispatcher();
    }

    private ElementDispatcher createElementDispatcher()
    {
        try
        {
            URL rulesURL = ElementDispatcher.class.getResource("ElementDispatcherRules.xml");
            assert rulesURL != null;
            Digester digester = DigesterLoader.createDigester(rulesURL);
            URL filterURL;

            filterURL = FeatureDgnConvertPostGISJobContext.class.getResource("/conf/DefaultConvertShpFilter.xml");

            assert filterURL != null;
            return (ElementDispatcher) digester.parse(filterURL);
        } catch (UnsupportedEncodingException e)
        {
            logger.info(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        } catch (MalformedURLException e)
        {
            logger.info(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        } catch (IOException e)
        {
            logger.info(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        } catch (SAXException e)
        {
            logger.info(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    public void run()
    {
        File dataDir = new File(dataConfig.get("DATAPATH"));
        if ((!dataDir.exists()) || (!dataDir.isDirectory()))
        {
            return;
        }

        File[] dataFiles = dataDir.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name)
            {
                return name.toLowerCase().endsWith(".dgn");
            }
        });

        for (File dataFile : dataFiles)
        {
            try
            {
                FileInputStream fs = new FileInputStream(dataFile);
                FileChannel fc = fs.getChannel();
                Dgn7fileReader reader = new Dgn7fileReader(fc, new Lock());
                int count = 0;
                Element lastComplex = null;
                while (reader.hasNext())
                {
                    Dgn7fileReader.Record record = reader.nextElement();
                    if (record.element() != null)
                    {
                        Element element = (Element) record.element();
                        ElementType type = element.getElementType();

                        if ((!type.isComplexElement()) && (!element.isComponentElement()))
                        {
                            if (lastComplex != null)
                            {
                                processFeatureElement(lastComplex);
                                lastComplex = null;
                            }

                            processFeatureElement(element);
                        } else if (element.isComponentElement())
                        {
                            if (lastComplex != null)
                            {
                                ((ComplexElement) lastComplex).add(element);
                            }
                        } else if (type.isComplexElement())
                        {
                            if (lastComplex != null)
                            {
                                processFeatureElement(lastComplex);
                            }
                            lastComplex = element;
                        }
                    }
                    count++;
                }

                if (lastComplex != null)
                {
                    processFeatureElement(lastComplex);
                }
                logger.debug("ElementRecord Count=" + count);

            } catch (Dgn7fileException e)
            {
                logger.warn(e.getMessage(), e);
            } catch (FileNotFoundException e)
            {
                logger.warn(e.getMessage(), e);
            } catch (IOException e)
            {
                logger.warn(e.getMessage(), e);
            }
        }

        postProcessFeatureContext();
    }

    private void processFeatureElement(Element element)
    {
        if (element == null)
        {
            logger.warn("Unknown Element:" + null);
            return;
        }

        // 判斷是否符和條件
        Feature feature = elementDispatcher.execute(element);
        if (feature == null)
        {
            FrammeAttributeData linkage =
                    AbstractFLinkageDispatchableFilter.getFeatureLinkage(element);
            if ((isCompactMode) && (linkage != null))
            {
                logger.warn("Unknown Element:" + element.getElementType().toString() +
                        ":type=" + element.getType() + ":lv=" + element.getLevelIndex() + ":id=" +
                        (linkage.getFsc() + "|" + linkage.getComponentID()));
                if (element instanceof ComplexElement)
                {
                    ComplexElement complex = (ComplexElement) element;
                    logger.warn("----Complex Element size=" + complex.size());
                }

                manualElementProcess(element);
            } else if (!isCompactMode) {
                logger.warn("Unknown Element:" + element.getElementType().toString() +
                        ":type=" + element.getType() + ":lv=" + element.getLevelIndex() + ":id=" +
                        (linkage == null ? "NULL" : (linkage.getFsc() + "|" + linkage.getComponentID())));

                if (element instanceof ComplexElement)
                {
                    ComplexElement complex = (ComplexElement) element;
                    logger.warn("----Complex Element size=" + complex.size());
                }
            }

            return;
        }

        featuresContext.put(feature.getFeatureType(), feature);
    }

    private void manualElementProcess(Element element)
    {
    }

    private void postProcessFeatureContext()
    {
        if (featuresContext.size() == 0) return;
        for (Object key : featuresContext.keySet())
        {
            List elements = (List) featuresContext.get(key);
        }
    }
}