/*
    *  Copyright 2006 Simon Raess
    *
    *  Licensed under the Apache License, Version 2.0 (the "License");
    *  you may not use this file except in compliance with the License.
    *  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    * 
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  package net.sf.beep4j.internal;
  
  import java.nio.ByteBuffer;
  import java.nio.charset.Charset;
  
  import net.sf.beep4j.ProtocolException;
  import net.sf.beep4j.internal.util.Assert;
  import net.sf.beep4j.internal.util.ByteUtil;
  
  /**
   * Represents a data header as specified by the BEEP specification.
   * 
   * @author Simon Raess
   */
  public class DataHeader {
  	
  	private static final String EOL = "\r\n";
  
  	private static final char FINAL = '.';
  
  	private static final char INTERMEDIATE = '*';
  
  	private static final String SPACE = " ";
  
  	private static final Charset charset = Charset.forName("US-ASCII");
  	
  	/**
  	 * The message type of the frame.
  	 */
  	protected MessageType type;
  	
  	/**
  	 * The size of the frame's payload.
  	 */
  	protected int payloadSize;
  	
  	/**
  	 * The channel number of the frame.
  	 */
  	protected int channel;
  	
  	/**
  	 * The message number of the frame.
  	 */
  	protected int messageNumber;
  	
  	/**
  	 * Whether this is an intermediate frame.
  	 */
  	protected boolean intermediate;
  	
  	/**
  	 * The sequence number of the first byte in the frame's payload.
  	 */
  	protected long sequenceNumber;
  	
  	/**
  	 * Creates a new DataHeader.
  	 * 
  	 * @param type the message type of the frame
  	 * @param channel the channel number, must be greater or equal than zero
  	 * @param messageNumber the message number of the frame
  	 * @param intermediate whether this is an intermediate frame
  	 * @param sequenceNumber the sequence number of the frame
  	 * @param size the payload size of the frame
  	 */
  	public DataHeader(MessageType type, int channel, int messageNumber, boolean intermediate, long sequenceNumber, int size) {
  		Assert.notNull("type", type);
  		this.type = type;
  		this.channel = channel;
  		this.messageNumber = messageNumber;
  		this.intermediate = intermediate;
  		this.sequenceNumber = sequenceNumber;
  		this.payloadSize = size;
  	}
  	
  	/**
  	 * Parses the passed in tokenized header line into a DataHeader.
  	 * 
  	 * @param tokens the tokenized header line
  	 * @return the parsed header
  	 */
  	public static final DataHeader parseHeader(String[] tokens) {
  		if (tokens.length == 0) {
 			throw new ProtocolException("header has 0 tokens");
 		}
 		
 		MessageType type = parseMessageType(tokens[0]);
 		
 		if (type == MessageType.ANS && tokens.length != 7) {
 			throw new ProtocolException("expecting 7 tokens in ANS header, was " + tokens.length);
 		} else if (type != MessageType.ANS && tokens.length != 6) {
 			throw new ProtocolException("expecting 6 tokens in header, was " + tokens.length);
 		}
 		
 		int channel = ByteUtil.parseUnsignedInt("channel number", tokens[1]);
 		int messageNumber = ByteUtil.parseUnsignedInt("message number", tokens[2]);
 		boolean intermediate = parseIntermediate(tokens[3]);
 		long sequenceNumber = ByteUtil.parseUnsignedLong("sequence number", tokens[4]);
 		int payloadSize = ByteUtil.parseUnsignedInt("size", tokens[5]);
 		
 		if (MessageType.ANS == type) {
 			int answerNumber = ByteUtil.parseUnsignedInt("answer number", tokens[6]);
 			return new ANSHeader(channel, messageNumber, intermediate, sequenceNumber, payloadSize, answerNumber);
 		} else {
 			return new DataHeader(type, channel, messageNumber, intermediate, sequenceNumber, payloadSize);
 		}
 	}
 	
 	private static MessageType parseMessageType(String s) {
 		try {
 			return MessageType.valueOf(s);
 		} catch (IllegalArgumentException e) {
 			throw new ProtocolException("'" + s + "' is an invalid message type");
 		}
 	}
 		
 	private static boolean parseIntermediate(String s) {
 		if ("*".equals(s)) {
 			return true;
 		} else if (".".equals(s)) {
 			return false;
 		} else {
 			throw new ProtocolException("'" + s + "' is an invalid intermediate indicator");
 		}
 	}
 	
 	public MessageType getType() {
 		return type;
 	}
 
 	public int getChannel() {
 		return channel;
 	}
 
 	public int getMessageNumber() {
 		return messageNumber;
 	}
 
 	public boolean isIntermediate() {
 		return intermediate;
 	}
 
 	public int getPayloadSize() {
 		return payloadSize;
 	}
 
 	public long getSequenceNumber() {
 		return sequenceNumber;
 	}
 	
 	/**
 	 * Splits the header into two parts. The first part's size is set
 	 * to the passed in parameter. It has the intermediate flag set to
 	 * true. The second part has the remaining
 	 * size plus its sequence number adapted.
 	 *  
 	 * @param size the size of the first part
 	 * @return an array of two elements
 	 */
 	public DataHeader[] split(int size) {
 		MessageType type = getType();
 		
 		DataHeader[] result = new DataHeader[2];
 		result[0] = new DataHeader(type, channel, messageNumber, true, sequenceNumber, size);
 		result[1] = new DataHeader(type, channel, messageNumber, false, sequenceNumber + size, payloadSize - size);
 		
 		return result;
 	}
 	
 	/**
 	 * Converts the header into a ByteBuffer.
 	 * 
 	 * @return the converted ByteBuffer 
 	 */
 	public ByteBuffer asByteBuffer() {
 		StringBuilder builder = new StringBuilder(type.name());
 		
 		builder.append(SPACE);
 		builder.append(channel);
 		builder.append(SPACE);
 		builder.append(messageNumber);
 		builder.append(SPACE);
 		builder.append(intermediate ? INTERMEDIATE : FINAL);
 		builder.append(SPACE);
 		builder.append(sequenceNumber);
 		builder.append(SPACE);
 		builder.append(payloadSize);
 		builder.append(EOL);
 		
 		return charset.encode(builder.toString());
 	}
 	
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj) {
 			return true;
 		} else if (obj == null) {
 			return false;
 		} else if (getClass() == obj.getClass()) {
 			DataHeader header = (DataHeader) obj;
 			return type == header.type
 			    && channel == header.channel
 			    && messageNumber == header.messageNumber
 			    && intermediate == header.intermediate
 			    && sequenceNumber == header.sequenceNumber
 			    && payloadSize == header.payloadSize;
 		} else {
 			return false;
 		}
 	}
 	
 	@Override
 	public int hashCode() {
 		int result = 17;
 		result = result * 23 + type.hashCode();
 		result = result * 23 + channel;
 		result = result * 23 + messageNumber; 
 		result = result * 23 + (intermediate ? 1 : 0);
 		result = result * 23 + payloadSize;
 		result = result * 23 + new Long(sequenceNumber).hashCode();
 		return result;
 	}
 	
 	@Override
 	public String toString() {
 		return type.name() + " " 
 			 + channel + " "
 			 + messageNumber + " " 
 		     + (intermediate ? "*" : ".") + " " 
 		     + sequenceNumber + " "
 		     + payloadSize;
 	}
 	
 	/**
 	 * Header for messages of type ANS. This header type has an additional
 	 * property <code>answerNumber</code>.
 	 * 
 	 * @author Simon Raess
 	 */
 	public static class ANSHeader extends DataHeader {
 		
 		private final int answerNumber;
 		
 		public ANSHeader(int channel, int messageNumber, boolean intermediate, long sequenceNumber, int payloadSize, int answerNumber) {
 			super(MessageType.ANS, channel, messageNumber, intermediate, sequenceNumber, payloadSize);
 			this.answerNumber = answerNumber;
 		}
 		
 		public int getAnswerNumber() {
 			return answerNumber;
 		}
 		
 		@Override
 		public DataHeader[] split(int size) {
 			DataHeader[] result = new DataHeader[2];
 			result[0] = new ANSHeader(channel, messageNumber, true, sequenceNumber, size, answerNumber);
 			result[1] = new ANSHeader(channel, messageNumber, false, sequenceNumber + size, payloadSize - size, answerNumber);
 			return result;
 		}
 		
 		@Override
 		public ByteBuffer asByteBuffer() {
 			StringBuilder builder = new StringBuilder();
 			
 			builder.append(type.name());
 			builder.append(SPACE);
 			builder.append(channel);
 			builder.append(SPACE);
 			builder.append(messageNumber);
 			builder.append(SPACE);
 			builder.append(intermediate ? INTERMEDIATE : FINAL);
 			builder.append(SPACE);
 			builder.append(sequenceNumber);
 			builder.append(SPACE);
 			builder.append(payloadSize);
 			builder.append(SPACE);
 			builder.append(answerNumber);
 			builder.append(EOL);
 			
 			return charset.encode(builder.toString());
 		}		
 
 		@Override
 		public boolean equals(Object obj) {
 			if (!super.equals(obj)) {
 				return false;
 			} else if (obj.getClass().equals(obj)) {
 				ANSHeader header = (ANSHeader) obj;
 				return answerNumber == header.answerNumber;
 			} else {
 				return false;
 			}
 		}
 
 		@Override
 		public int hashCode() {
 			int result = super.hashCode();
 			result = result * 23 + answerNumber;
 			return result;
 		}
 		
 		 @Override
 		public String toString() {
 			 return super.toString() + " " + answerNumber;
 		}
 		 
 	}
 		
 }