package com.ximple.io.dgn7;

//~--- JDK imports ------------------------------------------------------------

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.Coordinate;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;

import com.ximple.util.DgnUtility;

/**
 * TextNodeElement
 *
 * @author Ulysses
 * @version 0.1
 * @since 2006/5/18 下午 04:02:58
 */
public class TextNodeElement extends Element implements ComplexElement, GeometryConverter
{
    private static final Logger logger = Logger.getLogger(TextElement.class);

    private ArrayList list = new ArrayList();

    public TextNodeElement(byte[] raw)
    {
        super(raw);
    }

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

    public void add(int index, Object element)
    {
        list.add(index, 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 String[] getTextArray()
    {
        ArrayList list = new ArrayList();

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

            if (element instanceof TextElement)
            {
                list.add(((TextElement) element).getText());
            }
        }

        return (String[]) list.toArray(new String[list.size()]);
    }

    public Geometry toGeometry(GeometryFactory factory)
    {
        /*
         * CoordinateList coords = new CoordinateList();
         * for (ListIterator it = listIterator(); it.hasNext(); )
         * {
         *   Element element = (Element) it.next();
         *   if (element instanceof TextElement)
         *   {
         *       coords.add(((TextElement) element).getUserOrigin());
         *   }
         * }
         */
        return factory.createPoint(getOrigin());

        // return factory.createMultiPoint(coords.toCoordinateArray());
    }

    public int getNumString()
    {
        return (int) (raw[19] & 0x0000ffff);
    }

    public int getNodeNumber()
    {
        return (int) (raw[20] & 0x0000ffff);
    }

    public int getMaxLength()
    {
        return (int) (raw[21] & 0x00ff);
    }

    public int getMaxUsed()
    {
        return (int) ((raw[21] >> 8) & 0x00ff);
    }

    public int getJustification()
    {
        return (int) ((raw[22] >> 8) & 0x00ff);
    }

    public int getFontIndex()
    {
        return (int) (raw[22] & 0x00ff);
    }

    public double getLineSpacing()
    {
        int lineSpace;

        lineSpace = (int) ((raw[23] << 16) & 0xffff0000);
        lineSpace += (raw[24] & 0x0000ffff);

        return lineSpace;
    }

    public double getTextNodeLength()
    {
        int lengthMult = -1;

        lengthMult = (int) ((raw[25] << 16) & 0xffff0000);
        lengthMult += (raw[26] & 0x0000ffff);

        return DgnUtility.converIntToDouble(lengthMult);
    }

    public double getTextNodeHeight()
    {
        int heightMult = -1;

        heightMult = (int) ((raw[27] << 16) & 0xffff0000);
        heightMult += (raw[28] & 0x0000ffff);

        return DgnUtility.converIntToDouble(heightMult);
    }

    public double getRotationAngle()
    {
        int rotation = (int) (raw[29] << 16 & 0xffff0000);

        rotation += raw[30];

        return DgnUtility.converIntToRotation(rotation);
    }

    public Coordinate getOrigin()
    {
        int x = (int) ((raw[31] << 16) & 0xffff0000);

        x += raw[32] & 0x0000ffff;

        // return DgnUtility.convertFromDGN(x);
        double dx = DgnUtility.converUnitToCoord(x);
        int    y  = (int) ((raw[33] << 16) & 0xffff0000);

        y += (raw[34] & 0x0000ffff);

        double dy = DgnUtility.converUnitToCoord(y);

        return new Coordinate(dx, dy);
    }

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

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

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

            return instance;
        }

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