package com.ximple.io.dgn7;

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

import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

import com.vividsolutions.jts.geom.Envelope;

import com.ximple.util.DgnUtility;

/**
 * Record
 *
 * @author Ulysses
 * @version 0.1
 * @since 2006/5/18 上午 11:14:50
 */
public class Element
{
    public static final int CONSTRUCTION_CLASS = 0;
    public static final int CONSTRUCTION_RULE_CLASS = 0;
    public static final int DIMENSION_CLASS = 0;
    public static final int LINEAR_PATTERNED_CLASS = 0;
    public static final int MAX_ELEMENT_SIZE = 0;
    public static final int MAX_VERTICES = 100;
    public static final int PATTERN_AREA = 0;
    public static final int PATTERN_COMPONENT_CLASS = 0;
    public static final int PATTERN_CROSSHATCH = 0;
    public static final int PATTERN_HATCH = 0;
    public static final int PRIMARY_CLASS = 0;
    public static final int PRIMARY_RULE_CLASS = 0;

    protected short[] raw;
    protected byte attrOffset = 0;
    protected ByteBuffer rawBuffer;

    public Element(byte[] raw)
    {
        // this.raw = raw;
        this.raw = new short[raw.length / 2];
        rawBuffer = ByteBuffer.wrap(raw);
        rawBuffer.order(ByteOrder.LITTLE_ENDIAN);
        rawBuffer.asShortBuffer().get(this.raw);
    }

    public int getLineStyle()
    {
        return 0;
    }

    public Envelope getRange()
    {
        int lowCoorX = ((raw[3] << 16) & 0xffff0000) + (raw[2] & 0x0000ffff);
        lowCoorX = DgnUtility.convertFromDGN(lowCoorX);

        int lowCoorY = ((raw[5] << 16) & 0xffff0000) + (raw[4] & 0x0000ffff);
        lowCoorY = DgnUtility.convertFromDGN(lowCoorY);

        int highCoorX = ((raw[9] << 16) & 0xffff0000) + (raw[8] & 0x0000ffff);
        highCoorX = DgnUtility.convertFromDGN(highCoorX);

        int highCoorY = ((raw[11] << 16) & 0xffff0000) + (raw[10] & 0x0000ffff);
        highCoorY = DgnUtility.convertFromDGN(highCoorY);

        return new Envelope(DgnUtility.converUnitToCoord(lowCoorX), DgnUtility.converUnitToCoord(highCoorX),
                DgnUtility.converUnitToCoord(lowCoorY), DgnUtility.converUnitToCoord(highCoorY));
    }

    public boolean isComponentElement()
    {
        return (short) ((raw[0] >>> 7) & 0x0001) == 1;
    }

    public boolean removeUserAttributeData(int iLinkageId)
    {
        return true;
    }

    public boolean removeUserAttributeData(int iLinkageId, int iLinkageIndex)
    {
        return true;
    }

    public boolean isDeleted()
    {
        return (short) ((raw[0] >>> 15) & 0x0001) == 1;
    }

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

    public int getType()
    {
        return ((raw[0] >>> 8) & 0x007f);
    }

    public ElementType getElementType()
    {
        return ElementType.forID(getType());
    }

    public int getLevelIndex()
    {
        return (raw[0] & 0x003f);
    }

    public int getWeight()
    {
        return ((raw[17] >>> 3) & 0x001f);
    }

    public void addUserAttributeData(byte[] pDataBlock, Class dataClass, int iLinkageId) throws Element.Exception
    {
    }

    public void addUserAttributeData(byte[] pDataBlock, int iLinkageId, Object oDataDef) throws Element.Exception
    {
    }

    public boolean hasUserAttributeData()
    {
        if (raw[15] <= 0)
        {
            return false;
        }

        short index = (short) (raw[15] + 16);

        if (index == -1)
        {
            return false;
        }

        return true;
    }

    public List<UserAttributeData> getUserAttributeData()
    {
        short[] data;
        short length, nextAttribute;

        if (raw[15] <= 0)
        {
            return new ArrayList<UserAttributeData>();
        }

        short index = (short) (raw[15] + 16 + attrOffset);

        if (index == -1)
        {
            return null;
        }

        ArrayList<UserAttributeData> aLinkageSet = new ArrayList<UserAttributeData>();

        while (index < raw.length)
        {
            length = (short) (raw[index] & (short) 0x00ff);

            if (length == 0)
            {
                break;
            }

            nextAttribute = (short) (index + length + 1);
            data = new short[length];
            System.arraycopy(raw, index + 1, data, 0, length);

            if (data[0] == (short) 0x0020)
            {
                aLinkageSet.add(new FrammeAttributeData(data));
            } else
            {
                aLinkageSet.add(new UserAttributeData(data));
            }

            index = nextAttribute;
        }

        return aLinkageSet;
    }

    public void getUserAttributeData(byte[] pDataBlock, Class dataClass, int iLinkageId, int iLinkageIndex)
    {
    }

    public void getUserAttributeData(byte[] pDataBlock, int iLinkageId, Object oDataDef)
    {
    }


    public ByteBuffer getRawBuffer()
    {
        return rawBuffer.asReadOnlyBuffer();
    }

    public short[] getRawArray()
    {
        if (raw == null) return null;
        short[] result = new short[raw.length];
        System.arraycopy(raw, 0, result, 0, raw.length);
        return result;
    }

    public static class Exception extends java.lang.Exception
    {
        public Exception()
        {
        }

        // Constructs an Record.Exception with no detail message.
        public Exception(String oStrMessage)
        {
            super(oStrMessage);
        }
    }

    protected static int getOffsetPosition(int offset)
    {
        return offset * 2;
    }

    public static class ElementHandler implements IElementHandler
    {
        ElementType elementType;

        public ElementHandler(ElementType elementType)
        {
            this.elementType = elementType;
        }

        public ElementType getElementType()
        {
            return elementType;
        }

        public Object read(ByteBuffer buffer, short signature, int length)
        {
            byte[] dst = new byte[length];
            try
            {
                buffer.get(dst, 4, dst.length - 4);
            } catch (BufferUnderflowException exception)
            {
                throw exception;
            }

            ByteBuffer tmpBuffer = ByteBuffer.wrap(dst);
            tmpBuffer.order(ByteOrder.LITTLE_ENDIAN);
            tmpBuffer.position(0);
            tmpBuffer.putShort(signature);
            tmpBuffer.putShort((short) ((length / 2) - 2));

            /*
            ShortBuffer sbuffer = tmpBuffer.asShortBuffer();

            short[] rawMem = new short[(length / 2)];
            sbuffer.get(rawMem, 2, rawMem.length - 2);
            rawMem[0] = signature;
            rawMem[1] = (short) ((length / 2) - 2);
            */
            Element elm = createElement(dst);

            return elm;
        }

        public void write(ByteBuffer buffer, Object element)
        {
            buffer.put(((Element) element).rawBuffer);
        }

        public int getLength(Object element)
        {
            return ((Element) element).raw.length;
        }

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