/**

  *  @author : Paul Taylor

  *  @author : Eric Farng

  *

  *  Version @version:$Id: NumberVariableLength.java 836 2009-11-12 15:44:07Z paultaylor $

  *

  *  MusicTag Copyright (C)2003,2004

  *

  *  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser

  *  General Public  License as published by the Free Software Foundation; either version 2.1 of the License,

  *  or (at your option) any later version.

  *

  *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even

  *  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  *  See the GNU Lesser General Public License for more details.

  *

  *  You should have received a copy of the GNU Lesser General Public License along with this library; if not,

  *  you can get a copy from http://www.opensource.org/licenses/lgpl-license.php or write to the Free Software

  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  *

  * Description:

  *

  */

 package org.jaudiotagger.tag.datatype;

 import org.jaudiotagger.tag.InvalidDataTypeException;

 import org.jaudiotagger.tag.id3.AbstractTagFrameBody;

 import org.jaudiotagger.tag.id3.ID3Tags;

 /**

  * Represents a number which may span a number of bytes when written to file depending what size is to be represented.

  * <p/>

  * The bitorder in ID3v2 is most significant bit first (MSB). The byteorder in multibyte numbers is most significant

  * byte first (e.g. $12345678 would be encoded $12 34 56 78), also known as big endian and network byte order.

  * <p/>

  * In ID3Specification would be denoted as $xx xx xx xx (xx ...) , this denotes at least four bytes but may be more.

  * Sometimes may be completely optional (zero bytes)

  */

 public class NumberVariableLength extends AbstractDataType

 {

     private static final int MINIMUM_NO_OF_DIGITS = 1;

     private static final int MAXIMUM_NO_OF_DIGITS = 8;

     int minLength = MINIMUM_NO_OF_DIGITS;

     /**

      * Creates a new ObjectNumberVariableLength datatype, set minimum length to zero

      * if this datatype is optional.

      *

      * @param identifier

      * @param frameBody

      * @param minimumSize

      */

     public NumberVariableLength(String identifier, AbstractTagFrameBody frameBody, int minimumSize)

     {

         super(identifier, frameBody);

         //Set minimum length, which can be zero if optional

         this.minLength = minimumSize;

     }

     public NumberVariableLength(NumberVariableLength copy)

     {

         super(copy);

         this.minLength = copy.minLength;

     }

     /**

      * Return the maximum number of digits that can be used to express the number

      *

      * @return the maximum number of digits that can be used to express the number

      */

     public int getMaximumLenth()

     {

         return MAXIMUM_NO_OF_DIGITS;

     }

     /**

      * Return the  minimum  number of digits that can be used to express the number

      *

      * @return the minimum number of digits that can be used to express the number

      */

     public int getMinimumLength()

     {

         return minLength;

     }

     /**

      * @param minimumSize

      */

     public void setMinimumSize(int minimumSize)

     {

         if (minimumSize > 0)

         {

             this.minLength = minimumSize;

         }

     }

     /**

      * @return the number of bytes required to write this to a file

      */

     public int getSize()

     {

         if (value == null)

         {

             return 0;

         }

         else

         {

             int current;

             long temp = ID3Tags.getWholeNumber(value);

             int size = 0;

             for (int i = MINIMUM_NO_OF_DIGITS; i <= MAXIMUM_NO_OF_DIGITS; i++)

             {

                 current = (byte) temp & 0xFF;

                 if (current != 0)

                 {

                     size = i;

                 }

                 temp >>= MAXIMUM_NO_OF_DIGITS;

             }

             return (minLength > size) ? minLength : size;

         }

     }

     /**

      * @param obj

      * @return

      */

     public boolean equals(Object obj)

     {

         if (!(obj instanceof NumberVariableLength))

         {

             return false;

         }

         NumberVariableLength object = (NumberVariableLength) obj;

         return this.minLength == object.minLength && super.equals(obj);

     }

     /**

      * Read from Byte Array

      *

      * @param arr

      * @param offset

      * @throws NullPointerException

      * @throws IndexOutOfBoundsException

      */

     public void readByteArray(byte[] arr, int offset) throws InvalidDataTypeException

     {

         //Coding error, should never happen

         if (arr == null)

         {

             throw new NullPointerException("Byte array is null");

         }

         //Coding error, should never happen as far as I can see

         if (offset < 0)

         {

             throw new IllegalArgumentException("negativer offset into an array offset:" + offset);

         }

         //If optional then set value to zero, this will mean that if this frame is written back to file it will be created

         //with this additional datatype wheras it didnt exist but I think this is probably an advantage the frame is

         //more likely to be parsed by other applications if it contains optional fields.

         //if not optional problem with this frame

         if (offset >= arr.length)

         {

             if (minLength == 0)

             {

                 value = (long) 0;

                 return;

             }

             else

             {

                 throw new InvalidDataTypeException("Offset to byte array is out of bounds: offset = " + offset + ", array.length = " + arr.length);

             }

         }

         long lvalue = 0;

         //Read the bytes (starting from offset), the most significant byte of the number being constructed is read first,

         //we then shift the resulting long one byte over to make room for the next byte

         for (int i = offset; i < arr.length; i++)

         {

             lvalue <<= 8;

             lvalue += (arr[i] & 0xff);

         }

         value = lvalue;

     }

     /**

      * @return String representation of the number

      */

     public String toString()

     {

         if (value == null)

         {

             return "";

         }

         else

         {

             return value.toString();

         }

     }

     /**

      * Write to Byte Array

      *

      * @return the datatype converted to a byte array

      */

     public byte[] writeByteArray()

     {

         int size = getSize();

         byte[] arr;

         if (size == 0)

         {

             arr = new byte[0];

         }

         else

         {

             long temp = ID3Tags.getWholeNumber(value);

             arr = new byte[size];

             //keeps shifting the number downwards and masking the last 8 bist to get the value for the next byte

             //to be written

             for (int i = size - 1; i >= 0; i--)

             {

                 arr[i] = (byte) (temp & 0xFF);

                 temp >>= 8;

             }

         }

         return arr;

     }

 }