/***
    * Java DAB EPG API - Serialize/Deserialize To/From POJOs to XML/Binary as per
    * ETSI specifications TS 102 818 (XML Specification for DAB EPG) and TS 102 
    * 371 (Transportation and Binary Encoding Specification for EPG).
    * 
    * Copyright (C) 2007 GCap Media PLC
    *
    * 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, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package com.gcapmedia.dab.epg.binary;
  
  import java.util.*;
  
  /***
   * Element binary encoding
   */
  public class Element implements Encodable {
  
  	/***
  	 * Element tag uniquely identifies the element.
  	 */
  	private final ElementTag tag;
  	
  	/***
  	 * Element attributes
  	 */
  	private final Collection<Attribute> attributes;
  	
  	/***
  	 * Child elements
  	 */
  	private final Collection<Element> children;
  	
  	/***
  	 * Element CDATA content
  	 */
  	private CData cdata;
  	
  	/***
  	 * Token table
  	 */
  	private TokenTable tokens;
  	
  	/***
  	 * 
  	 * @param tag
  	 */
  	public Element(ElementTag tag) {
  		this.tag = tag;
  		this.attributes = new ArrayList<Attribute>();
  		this.children = new ArrayList<Element>();
  	}
  	
  	/***
  	 * @return Returns the element tag
  	 */
  	public ElementTag getTag() {
  		return tag;
  	}
  	
  	public void setTokenTable(TokenTable tokens) {
  		this.tokens = tokens;
  	}
  	
  	/***
  	 * Add an attribute to this element 
  	 * @param attribute Attribute to add
  	 */
  	public void addAttribute(Attribute attribute) {
  		this.attributes.add(attribute);
  	}
  	
  	/***
  	 * @return Returns any element attributes
  	 */
  	public Collection<Attribute> getAttributes() {
  		return Collections.unmodifiableCollection(attributes);
  	}
  	
  	/***
  	 * Returns a specific attribute
  	 * @param tag Tag of attribute to retrieve
  	 * @return Returns the attribute if found, null otherwise
  	 */
  	public Attribute getAttribute(AttributeTag tag) {
  		Attribute result = null;
  		for(Attribute attribute : attributes) {
 			if(attribute.getTag() == tag) {
 				result = attribute;
 				break;
 			}
 		}
 		return result;
 	}
 	
 	/***
 	 * Returns whether a specific attribute is defined for this element
 	 * @param tag Tag of attribute to test for
 	 * @return Returns true if the attribute is defined for this element
 	 */
 	public boolean hasAttribute(AttributeTag tag) {
 		return getAttribute(tag) != null;
 	}
 	
 	/***
 	 * Add a child to this element
 	 * @param child Child to add
 	 */
 	public void addChild(Element child) {
 		this.children.add(child);
 	}
 	
 	/***
 	 * @return Returns all child elements
 	 */
 	public Collection<Element> getChildren() {
 		return Collections.unmodifiableCollection(children);
 	}
 	
 	/***
 	 * Returns child elements of the specified type
 	 * @param tag Element tag to return
 	 * @return
 	 */
 	public Collection<Element> getChildren(ElementTag tag) {
 		List<Element> result = new ArrayList<Element>();
 		for(Element child : children) {
 			if(child.getTag() == tag) {
 				result.add(child);
 			}
 		}
 		return Collections.unmodifiableCollection(result);
 	}
 	
 	/***
 	 * Returns whether any elements of the specified type are children to this element
 	 * @param tag Element tag to test for
 	 * @return True if any elements of the specified type are children to this element
 	 */
 	public boolean hasChildren(ElementTag tag) {
 		return getChildren(tag).size() > 0;
 	}
 	
 	/***
 	 * Set this elements CDATA
 	 * @param cdata CDATA to set
 	 */
 	public void setCData(CData cdata) {
 		this.cdata = cdata;
 	}
 	
 	/***
 	 * @return Returns any associated CData
 	 */
 	public CData getCData() {
 		return cdata;
 	}
 
 	/***
 	 * @see com.gcapmedia.dab.epg.binary.Encodable#getBytes()
 	 */
 	public byte[] getBytes() {
 		
 		// need to shove the 3 things together: attributes, child, CDATA
 		byte[] databytes = new byte[0];
 		for(Attribute attribute : attributes) {
 			byte[] tmp = attribute.getBytes();
 			byte[] bytes = new byte[databytes.length + tmp.length];
 			System.arraycopy(databytes, 0, bytes, 0, databytes.length);
 			System.arraycopy(tmp, 0, bytes, databytes.length, tmp.length);
 			databytes = bytes;
 		}
 		for(Element child : children) {
 			byte[] tmp = child.getBytes();
 			byte[] bytes = new byte[databytes.length + tmp.length];
 			System.arraycopy(databytes, 0, bytes, 0, databytes.length);
 			System.arraycopy(tmp, 0, bytes, databytes.length, tmp.length);
 			databytes = bytes;
 		}
 		if(cdata != null) {
 			byte[] tmp = cdata.getBytes();
 			byte[] bytes = new byte[databytes.length + tmp.length];
 			System.arraycopy(databytes, 0, bytes, 0, databytes.length);
 			System.arraycopy(tmp, 0, bytes, databytes.length, tmp.length);
 			databytes = bytes;
 		}
 		BitBuilder bits = new BitBuilder(8);
 		
 		// b0-b7: element tag
 		bits.put(0, 8, tag.getBytes());
 		
 		// b8-15: element data length (0-253 bytes)
 		// b16-31: extended element length (256-65536 bytes)
 		// b16-39: extended element length (65537-16777216 bytes)
 		int datalength = databytes.length;
 		if(datalength <= 253) {
 			bits.setSize(16 + datalength * 8);
 			bits.put(8, 8, datalength);
 		} else if(datalength >= 1<<8 && datalength <= 1<<16) {
 			bits.setSize(32 + datalength * 8);
 			bits.put(8, 8, 0xFE);
 			bits.put(16, 16, datalength);
 		} else if(datalength > 1<<16 && datalength <= 1<<24) { 
 			bits.setSize(40 + datalength * 8);
 			bits.put(8, 8, 0xFF);
 			bits.put(16, 24, datalength);
 		} else {
 			throw new IndexOutOfBoundsException("Element data length exceeds the maximum allowed by the extended element length (24bits): " + datalength + " > " + (1<<24));
 		}
 		
 		// b16/32/40-(16/32/40 + bytes*8): attribute data bytes
 		bits.put(bits.position(), databytes.length * 8, databytes);
 		
 		byte[] result = bits.toByteArray();
 		
 		return result;
 	}
 
 	/***
 	 * @see com.gcapmedia.dab.epg.binary.Encodable#getLength()
 	 */
 	public int getLength() {
 		return getBytes().length;
 	}
 	
 	/***
 	 * Parse an object from its byte array representation
 	 * @param bytes Byte array representation
 	 */
 	public static Element fromBytes(byte[] bytes) {
 		return fromBytes(bytes, null);
 	}
 	
 	/***
 	 * Parse an object from its byte array representation
 	 * @param bytes Byte array representation
 	 */
 	public static Element fromBytes(byte[] bytes, TokenTable tokens) {
 		
 		BitParser parser = new BitParser(bytes);
 		
 		int position = 0;
 		
 		// b0-7: element tag
 		ElementTag tag = ElementTag.fromBytes(parser.getByteArray(position, 8));
 		Element element = new Element(tag);
 		position += 8;
 		
 		// b8-15: element value length
 		int length = parser.getInt(position, 8);
 		position += 8;
 		if(length == 0xFE) {
 			// b16-31: extended attribute length (16bits)
 			length = parser.getInt(position, 16);
 			position += 16;
 		} else if(length == 0xFE) {
 			// b16-39: extended attribute length (24bits)
 			length = parser.getInt(position, 24);
 			position += 24;
 		}
 		int dataend = position + length * 8;
 		
 		// b16/32/40-end: element value data (attributes, children, CDATA)
 		while(position < dataend) {
 
 			int t = parser.getInt(position, 8);
 			
 			// get the correct data length and end position
 			int datalength = parser.getInt(position + 8, 8);
 			int datastart = position + 8;
 			if(datalength == 0xFE) {
 				// b16-31: extended attribute length (16bits)
 				datalength = parser.getInt(position + 16, 16);
 				datastart += 16;
 			} else if(datalength == 0xFE) {
 				// b16-39: extended attribute length (24bits)
 				datalength = parser.getInt(position + 16, 24);
 				datastart += 24;
 			}	
 			
 			// pass the complete data to the correct decoder based on the tag
 			byte[] data = parser.getByteArray(position, 8 + (datastart - position) + datalength * 8);
 			
 			if(t == CData.TAG) { // CDATA
 				CData cdata = CData.fromBytes(data, tokens);
 				element.setCData(cdata);
 				//System.out.println("CDATA: " + cdata);
 			} else if(t == TokenTable.TAG && (tag == ElementTag.epg || tag == ElementTag.serviceInformation)) { // Token Table
 				tokens = TokenTable.fromBytes(data);
 				//System.out.println("token table: " + tokens);
 			} else if(t == 0x05 && tag == ElementTag.epg) {
 				// TODO parse the default content ID
 			} else if(t >= 0x10 && t <=0x7E) { // Standard Elements
 				Element child = Element.fromBytes(data, tokens);
 				element.addChild(child);
 				//System.out.println("element: " + element);
 			} else if((t & 0xFF) >= 0x80 && (t & 0xFF) <=0xFF) { // Attributes
 				Attribute attribute = Attribute.fromBytes(tag, data, tokens);
 				element.addAttribute(attribute);
 				//System.out.println("attribute: " + attribute);
 			} else { // unknown
 				throw new IllegalArgumentException("Unknown child tag found at " + position + " (byte " + (position / 8) + ") : " + t);
 			}
 			position = 8 + datastart + (datalength * 8);
 		}
 		
 		return element;
 	}
 		
 	/***
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof Element)) {
 			return false;
 		}
 		Element that = (Element)obj;
 		
 		// tag
 		if(this.tag != that.tag) {
 			return false;
 		}
 		
 		// attributes
 		if(!this.attributes.equals(that.attributes)) {
 			return false;
 		}
 		
 		// children
 		if(!this.children.equals(that.children)) {
 			return false;
 		}
 		
 		// CDATA
 		if((this.cdata != null && that.cdata == null) ||
 		   (this.cdata == null && that.cdata != null)) {
 			return false;
 		}
 		if((this.cdata != null && that.cdata != null) &&
 		   !(this.cdata.equals(that.cdata))) {
 			return false;
 		}
 		
 		return true;
 	}  
 
 	/***
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString() {
 		List<String> subs = new ArrayList<String>();
 		if(children.size() > 0) {
 			StringBuilder tmp = new StringBuilder();
 			tmp.append("elements=[");
 			for(Element element : children) {
 				tmp.append(element.getTag() + ",");
 			}
 			tmp.append("]");
 			subs.add(tmp.toString());
 		}
 		if(attributes.size() > 0) {
 			subs.add("attributes=" + attributes.toString());
 		}
 		if(cdata != null) {
 			subs.add("data=" + cdata + "}");
 		}
 		return tag.toString() + "{" + subs.toString() + "}";
 	}
 	
 }