package com.ximple.io.dgn7;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.apache.log4j.Logger;

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

/**
 * ComplexChainElement
 *
 * @author Ulysses
 * @version 0.1
 * @since 2006/5/18 下午 03:44:56
 */
public class ComplexChainElement extends Element implements ComplexElement, GeometryConverter
{
    private static final Logger logger = Logger.getLogger(ComplexChainElement.class);

    protected ArrayList<Element> list = new ArrayList<Element>();

    public ComplexChainElement(byte[] raw)
    {
        super(raw);
        attrOffset = 4;
    }

    public int size()
    {
        return list.size();
    }

    public boolean isEmpty()
    {
        return list.isEmpty();
    }

    public boolean contains(Object o)
    {
        return list.contains(o);
    }

    public Iterator iterator()
    {
        return list.iterator();
    }

    public Object[] toArray()
    {
        return list.toArray();
    }

    public boolean add(Object o)
    {
        return list.add((Element) o);
    }

    public boolean remove(Object o)
    {
        return list.remove(o);
    }

    public boolean addAll(Collection c)
    {
        return list.addAll(c);
    }

    public boolean addAll(int index, Collection c)
    {
        return list.addAll(index, c);
    }

    public void clear()
    {
        list.clear();
    }

    public Object get(int index)
    {
        return list.get(index);
    }

    public Object set(int index, Object element)
    {
        return list.set(index, (Element) element);
    }

    public void add(int index, Object element)
    {
        list.add(index, (Element) element);
    }

    public Object remove(int index)
    {
        return list.remove(index);
    }

    public int indexOf(Object o)
    {
        return list.indexOf(o);
    }

    public int lastIndexOf(Object o)
    {
        return list.lastIndexOf(o);
    }

    public ListIterator listIterator()
    {
        return list.listIterator();
    }

    public ListIterator listIterator(int index)
    {
        return list.listIterator(index);
    }

    public List subList(int fromIndex, int toIndex)
    {
        return list.subList(fromIndex, toIndex);
    }

    public boolean retainAll(Collection c)
    {
        return list.retainAll(c);
    }

    public boolean removeAll(Collection c)
    {
        return list.removeAll(c);
    }

    public boolean containsAll(Collection c)
    {
        return list.containsAll(c);
    }

    public Object[] toArray(Object[] a)
    {
        return list.toArray(a);
    }

    public Geometry toGeometry(GeometryFactory factory)
    {
        if (size() == 1)
        {
            Element element = (Element) get(0);

            if (element instanceof LineStringElement)
            {
                if (((LineStringElement) element).getVerticeSize() == 0 || ((LineStringElement) element).getVerticeSize() > 1)
                {
                    return ((LineStringElement) element).toGeometry(factory);
                }

            } else if (element instanceof LineElement)
            {
                if (((LineElement) element).getVertices().length == 0 || ((LineElement) element).getVertices().length > 1)
                {
                    return ((LineElement) element).toGeometry(factory);
                }

            } else
            {
                if (element instanceof GeometryConverter)
                {
                    return ((GeometryConverter) element).toGeometry(factory);
                }

                return null;
            }
        }

        CoordinateList pts = new CoordinateList();
        for (ListIterator it = listIterator(); it.hasNext();)
        {
            Element element = (Element) it.next();

            if (element instanceof LineStringElement)
            {
                if (((LineStringElement) element).getVerticeSize() == 0 || ((LineStringElement) element).getVerticeSize() > 1)
                {
                    pts.add(((LineStringElement) element).toGeometry(factory).getCoordinates(), true);
                }

            } else if (element instanceof LineElement)
            {

                if (((LineElement) element).getVertices().length == 0 || ((LineElement) element).getVertices().length > 1)
                {
                    pts.add(((LineElement) element).toGeometry(factory).getCoordinates(), true);
                }
            } else if (element instanceof ArcElement)
            {
                pts.add(((ArcElement) element).toGeometry(factory).getCoordinates(), true);
            }
        }

        return factory.createLineString(pts.toCoordinateArray());
    }

    public double getElementSize()
    {
        return raw[18];
    }

    public boolean isClosed()
    {
        if (isEmpty())
        {
            return false;
        }

        return false;
    }

    public static class ElementHandler extends Element.ElementHandler
    {
        private static ElementHandler instance = null;

        public ElementHandler()
        {
            super(ElementType.COMPLEXCHAIN);
        }

        public static IElementHandler getInstance()
        {
            if (instance == null)
            {
                instance = new ElementHandler();
            }

            return instance;
        }

        protected Element createElement(byte[] raw)
        {
            return new ComplexChainElement(raw);
        }
    }
}