package com.ximple.eofms.filter;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateList;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.PrecisionModel;
import com.vividsolutions.jts.util.Assert;
import com.ximple.eofms.util.*;
import com.ximple.io.dgn7.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.IllegalAttributeException;
import org.geotools.feature.SchemaException;
import org.geotools.feature.simple.SimpleFeatureBuilder;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.geometry.jts.JTSFactoryFinder;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;

import javax.swing.event.EventListenerList;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Iterator;
import java.util.List;
import java.util.TreeMap;

public class CreateMultiSymbolStrategy implements CreateFeatureTypeStrategy {
    static final Log logger = LogFactory.getLog(CreateMultiSymbolStrategy.class);
    GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory(null);
    TreeMap<String, SimpleFeatureType> typeBuilders = new TreeMap<String, SimpleFeatureType>();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateMultiSymbolStrategy() {
    }

    protected FrammeAttributeData getFeatureLinkage(Element element) {
        if (!element.hasUserAttributeData())
            return null;

        List<UserAttributeData> usrDatas = element.getUserAttributeData();
        for (UserAttributeData anUsrData : usrDatas) {
            if (anUsrData instanceof FrammeAttributeData) {
                return (FrammeAttributeData) anUsrData;
            }
        }
        return null;
    }

    public SimpleFeatureType createFeatureElement(String featureName) throws SchemaException {
        if (!typeBuilders.containsKey(featureName)) {
            SimpleFeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createMultiSymbolFeatureTypeBuilder(featureName);
            SimpleFeatureType featureType = typeBuilder.buildFeatureType();
            typeBuilders.put(featureName, featureType);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, featureType));
        }
        return typeBuilders.get(featureName);
    }

    public SimpleFeature createFeature(SimpleFeatureType featureType, Element element,
                                       boolean useTransform) throws IllegalAttributeException {
        DefaultColorTable colorTable = (DefaultColorTable) DefaultColorTable.getInstance();
        FrammeAttributeData fLinkage = getFeatureLinkage(element);
        SimpleFeature feature = null;
        if (fLinkage == null) return null;
        if (element instanceof TextElement) {
            TextElement txtElement = (TextElement) element;
            double angle = txtElement.getRotationAngle();
            angle = BigDecimal.valueOf(angle).setScale(3, RoundingMode.HALF_UP).doubleValue();
            String content = txtElement.getText().trim();
            if (content.length() == 0) {
                logger.info("CreateMultiSymbolStrategy cannot conver " + element.toString() +
                        "to Feature - getText() is empty.");
                return null;
            }
            StringBuilder sb = new StringBuilder();
            sb.append("OCT");
            char id = content.toCharArray()[0];
            sb.append(Integer.toOctalString((int) id));
            sb.append("-");
            sb.append(txtElement.getFontIndex());

            Geometry gobj;
            if (useTransform) {
                GeometryConverterDecorator convertDecorator = FeatureTypeBuilderUtil.lookupDefaultGeometryConverter();
                convertDecorator.setConverter(txtElement);
                gobj = convertDecorator.toGeometry(geometryFactory);
            } else {
                gobj = txtElement.toGeometry(geometryFactory);
            }
            if (gobj != null)
                gobj.setSRID(FeatureTypeBuilderUtil.getDefaultFeatureSRID());
                feature = SimpleFeatureBuilder.build(featureType, new Object[]{
                        gobj,
                        fLinkage.getFsc(),
                        (long) fLinkage.getUfid(),
                        (short) fLinkage.getComponentID(),
                        fLinkage.getOccID(),
                        (short) txtElement.getLevelIndex(),
                        colorTable.getColorCode(txtElement.getColorIndex()),
                        (short) txtElement.getWeight(),
                        (short) txtElement.getLineStyle(),
                        (short) txtElement.getJustification(),
                        (float) txtElement.getTextHeight(),
                        (float) txtElement.getTextWidth(),
                        (float) angle,
                        sb.toString()
                }, null);
        } else if (element instanceof TextNodeElement) {
            TextNodeElement nodeElement = (TextNodeElement) element;


            double angle = nodeElement.getRotationAngle();
            angle = BigDecimal.valueOf(angle).setScale(3, RoundingMode.HALF_UP).doubleValue();
            if (nodeElement.size() == 0) {
                logger.info("CreateMultiSymbolStrategy cannot conver " + element.toString() +
                        "to Feature - getText() is empty.");
                return null;
            }

            Iterator<Element> txtElement = nodeElement.iterator();

            while (txtElement.hasNext()) {
                if (txtElement instanceof TextElement) {
                    TextElement txtChildElement = (TextElement) element;
                    char[] charArray = txtChildElement.getText().toCharArray();


                    if (charArray.length == 0) {
                        logger.info("CreateMultiSymbolStrategy cannot conver " + element.toString() +
                                "to Feature - getText() is empty.");
                        return null;
                    }


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

                        StringBuilder sb = new StringBuilder();
                        sb.append("OCT");
                        char id = charArray[i];
                        sb.append(Integer.toOctalString((int) id));
                        sb.append("-");
                        sb.append(txtChildElement.getFontIndex());

                        Geometry gobj;
                        if (useTransform) {
                            GeometryConverterDecorator convertDecorator = FeatureTypeBuilderUtil.lookupDefaultGeometryConverter();
                            convertDecorator.setConverter(txtChildElement);
                            gobj = convertDecorator.toGeometry(geometryFactory);
                        } else {
                            gobj = txtChildElement.toGeometry(geometryFactory);
                        }

                        if (gobj != null)
                            gobj.setSRID(FeatureTypeBuilderUtil.getDefaultFeatureSRID());
                            feature = SimpleFeatureBuilder.build(featureType, new Object[]{
                                    gobj,
                                    fLinkage.getFsc(),
                                    (long) fLinkage.getUfid(),
                                    (short) fLinkage.getComponentID(),
                                    fLinkage.getOccID(),
                                    (short) txtChildElement.getLevelIndex(),
                                    colorTable.getColorCode(nodeElement.getColorIndex()),
                                    (short) txtChildElement.getWeight(),
                                    (short) txtChildElement.getLineStyle(),
                                    (short) txtChildElement.getJustification(),
                                    (float) txtChildElement.getTextHeight(),
                                    (float) txtChildElement.getTextWidth(),
                                    (float) angle,
                                    sb.toString()
                            }, null);
                    }
                } else {
                    logger.info("CreateMultiSymbolStrategy cannot conver " + element.toString() + "to Feature");
                    return null;
                }
            }
        } else {
            logger.info("CreateMultiSymbolStrategy cannot conver " + element.toString() + "to Feature");
            return null;
        }
        return feature;
    }


    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener) {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener) {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt) {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2) {
            if (listeners[i] == CreateFeatureTypeEventListener.class) {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }

    private static class EPSG3826AnchorGeometryConverterDecorator extends EPSG3826GeometryConverterDecorator {
        public Geometry toGeometry(GeometryFactory factory) {
            if (getConverter() == null) Assert.shouldNeverReachHere();

            getCoordinatesFilter().reset();

            GeometryConverter converter = getConverter();
            Geometry geom = null;
            try {
                if (converter instanceof TextElement) {
                    geom = ((TextElement) converter).toAnchorGeometry(factory);
                } else if (converter instanceof TextNodeElement) {
                    geom = ((TextNodeElement) converter).toAnchorGeometry(factory);
                }
            } catch (ArrayStoreException e) {
                logger.warn(e.getMessage(), e);
                if (converter instanceof TextNodeElement) {
                    TextNodeElement node = (TextNodeElement) converter;
                    CoordinateList pts = new CoordinateList();
                    for (int i = 0; i < node.size(); i++) {
                        TextElement txtElm = (TextElement) node.get(i);
                        Coordinate[] coords = txtElm.toAnchorCoordinates();
                        logger.warn("-coords=[" + coords.length + "]");
                        for (int j = 0; j < coords.length; j++) {
                            logger.warn("[" + j + "]-" + coords.toString());
                        }
                    }
                }
            }
            if (geom == null) return null;
            geom.apply(getCoordinatesFilter());
            return geom;
        }
    }

    private static class EPSG3825AnchorGeometryConverterDecorator extends EPSG3825GeometryConverterDecorator {
        public Geometry toGeometry(GeometryFactory factory) {
            if (getConverter() == null) Assert.shouldNeverReachHere();

            getCoordinatesFilter().reset();

            GeometryConverter converter = getConverter();
            Geometry geom = null;
            try {
                if (converter instanceof TextElement) {
                    geom = ((TextElement) converter).toAnchorGeometry(factory);
                } else if (converter instanceof TextNodeElement) {
                    geom = ((TextNodeElement) converter).toAnchorGeometry(factory);
                }
            } catch (ArrayStoreException e) {
                logger.warn(e.getMessage(), e);
                if (converter instanceof TextNodeElement) {
                    TextNodeElement node = (TextNodeElement) converter;
                    CoordinateList pts = new CoordinateList();
                    for (int i = 0; i < node.size(); i++) {
                        TextElement txtElm = (TextElement) node.get(i);
                        Coordinate[] coords = txtElm.toAnchorCoordinates();
                        logger.warn("-coords=[" + coords.length + "]");
                        for (int j = 0; j < coords.length; j++) {
                            logger.warn("[" + j + "]-" + coords.toString());
                        }
                    }
                }
            }
            if (geom == null) return null;
            geom.apply(getCoordinatesFilter());
            return geom;
        }
    }
}