package com.ximple.eofms.filter;

import java.util.List;
import java.util.TreeMap;
import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
import org.geotools.feature.FeatureType;
import org.geotools.feature.FeatureTypeBuilder;
import org.geotools.feature.IllegalAttributeException;
import org.geotools.feature.SchemaException;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;

import com.ximple.eofms.util.DefaultColorTable;
import com.ximple.eofms.util.FeatureTypeBuilderUtil;
import com.ximple.eofms.util.TWD97GeometryConverterDecorator;
import com.ximple.io.dgn7.ComplexShapeElement;
import com.ximple.io.dgn7.Element;
import com.ximple.io.dgn7.FrammeAttributeData;
import com.ximple.io.dgn7.ShapeElement;
import com.ximple.io.dgn7.UserAttributeData;

public class CreateShapeStrategy implements CreateFeatureTypeStrategy
{
    static final Log logger = LogFactory.getLog(CreateShapeStrategy.class);
    GeometryFactory geometryFactory = new GeometryFactory();
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

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

    public CreateShapeStrategy()
    {
    }

    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 FeatureType createFeatureElement(String featureName) throws SchemaException
    {
        if (!typeBuilders.containsKey(featureName))
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createPolygonFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }

    public Feature createFeature(FeatureType featureType, Element element, boolean useTransform) throws IllegalAttributeException
    {
        DefaultColorTable colorTable = (DefaultColorTable) DefaultColorTable.getInstance();
        FrammeAttributeData fLinkage = getFeatureLinkage(element);
        Feature feature = null;
        if (fLinkage == null) return null;
        if (element instanceof ShapeElement)
        {
            ShapeElement shapeElement = (ShapeElement) element;
            Geometry gobj;
            if (useTransform)
            {
                convertDecorator.setConverter(shapeElement);
                gobj = convertDecorator.toGeometry(geometryFactory);
            } else
            {
                gobj = shapeElement.toGeometry(geometryFactory);
            }

            if (gobj != null)
                feature = featureType.create(new Object[]{
                        gobj,
                        fLinkage.getFsc(),
                        (long) fLinkage.getUfid(),
                        (short) fLinkage.getComponentID(),
                        fLinkage.getOccID(),
                        (short) shapeElement.getLevelIndex(),
                        colorTable.getColorCode(shapeElement.getColorIndex()),
                        (short) shapeElement.getWeight(),
                        (short) shapeElement.getLineStyle()
                });
        } else if (element instanceof ComplexShapeElement)
        {
            ComplexShapeElement complexShape = (ComplexShapeElement) element;
            Geometry gobj;
            if (useTransform)
            {
                convertDecorator.setConverter(complexShape);
                gobj = convertDecorator.toGeometry(geometryFactory);
            } else
            {
                gobj = complexShape.toGeometry(geometryFactory);
            }
            if (gobj != null)
                feature = featureType.create(new Object[]{
                        gobj,
                        fLinkage.getFsc(),
                        (long) fLinkage.getUfid(),
                        (short) fLinkage.getComponentID(),
                        fLinkage.getOccID(),
                        (short) complexShape.getLevelIndex(),
                        colorTable.getColorCode(complexShape.getColorIndex()),
                        (short) complexShape.getWeight(),
                        (short) complexShape.getLineStyle()
                });
        }
        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);
            }
        }
    }
}