/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

using System;
using System.IO;

namespace Apache.NMS.Util
{
	/// <summary>
	/// A BinaryWriter that switches the endian orientation of the write operations so that they
	/// are compatible across platforms.
	/// </summary>
	[CLSCompliant(false)]
	public class EndianBinaryWriter : BinaryWriter
	{
		public const int MAXSTRINGLEN = short.MaxValue;

		public EndianBinaryWriter(Stream output)
			: base(output)
		{
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">A  long</param>
		public override void Write(long value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">An ushort</param>
		public override void Write(ushort value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">An int</param>
		public override void Write(int value)
		{
			int x = EndianSupport.SwitchEndian(value);
			base.Write(x);
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="chars">A  char[]</param>
		/// <param name="index">An int</param>
		/// <param name="count">An int</param>
		public override void Write(char[] chars, int index, int count)
		{
			char[] t = new char[count];
			for(int i = 0; i < count; i++)
			{
				t[index + i] = EndianSupport.SwitchEndian(t[index + i]);
			}
			base.Write(t);
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="chars">A  char[]</param>
		public override void Write(char[] chars)
		{
			Write(chars, 0, chars.Length);
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">An uint</param>
		public override void Write(uint value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="ch">A  char</param>
		public override void Write(char ch)
		{
			base.Write((byte) ((ch >> 8) & 0xFF));
			base.Write((byte) (ch & 0xFF));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">An ulong</param>
		public override void Write(ulong value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">A  short</param>
		public override void Write(short value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write, writes a string to the output using the WriteString16
		/// method.
		/// </summary>
		/// <param name="text">A  string</param>
		public override void Write(String text)
		{
			WriteString16(text);
		}

		/// <summary>
		/// Method WriteString16, writes a string to the output using the Java 
		/// standard modified UTF-8 encoding with an unsigned short value written first to 
		/// indicate the length of the encoded data, the short is read as an unsigned 
		/// value so the max amount of data this method can write is 65535 encoded bytes.
		/// 
		/// Unlike the WriteString32 method this method does not encode the length
		/// value to -1 if the string is null, this is to match the behaviour of 
		/// the Java DataOuputStream class's writeUTF method.	
		/// 
		/// Because modified UTF-8 encding can result in a number of bytes greater that 
		/// the size of the String this method must first check that the encoding proces 
		/// will not result in a value that cannot be written becuase it is greater than
		/// the max value of an unsigned short.
		/// </summary>
		/// <param name="text">A  string</param>
		public void WriteString16(String text)
		{
			if(text != null)
			{
				if(text.Length > ushort.MaxValue)
				{
					throw new IOException(
						String.Format(
							"Cannot marshall string longer than: {0} characters, supplied string was: " +
							"{1} characters", ushort.MaxValue, text.Length));
				}

				char[] charr = text.ToCharArray();
				uint utfLength = CountUtf8Bytes(charr);

				if(utfLength > ushort.MaxValue)
				{
					throw new IOException(
						String.Format(
							"Cannot marshall an encoded string longer than: {0} bytes, supplied" +
							"string requires: {1} characters to encode", ushort.MaxValue, utfLength));
				}

				byte[] bytearr = new byte[utfLength];
				encodeUTF8toBuffer(charr, bytearr);

				Write((ushort) utfLength);
				Write(bytearr);
			}
		}

		/// <summary>
		/// Method WriteString32, writes a string to the output using the Openwire 
		/// standard modified UTF-8 encoding which an int value written first to 
		/// indicate the length of the encoded data, the int is read as an signed 
		/// value so the max amount of data this method can write is 2^31 encoded bytes.
		/// 
		/// In the case of a null value being passed this method writes a -1 to the 
		/// stream to indicate that the string is null.
		/// 
		/// Because modified UTF-8 encding can result in a number of bytes greater that 
		/// the size of the String this method must first check that the encoding proces 
		/// will not result in a value that cannot be written becuase it is greater than
		/// the max value of an int.
		/// </summary>
		/// <param name="text">A  string</param>
		public void WriteString32(String text)
		{
			if(text != null)
			{
				char[] charr = text.ToCharArray();
				uint utfLength = CountUtf8Bytes(charr);

				if(utfLength > int.MaxValue)
				{
					throw new IOException(
						String.Format(
							"Cannot marshall an encoded string longer than: {0} bytes, supplied" +
							"string requires: {1} characters to encode", int.MaxValue, utfLength));
				}

				byte[] bytearr = new byte[utfLength];
				encodeUTF8toBuffer(charr, bytearr);

				Write(utfLength);
				Write(bytearr);
			}
			else
			{
				Write((int) -1);
			}
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">A  double</param>
		public override void Write(float value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		/// <summary>
		/// Method Write
		/// </summary>
		/// <param name="value">A  double</param>
		public override void Write(double value)
		{
			base.Write(EndianSupport.SwitchEndian(value));
		}

		private static uint CountUtf8Bytes(char[] chars)
		{
			uint utfLength = 0;
			int c = 0;

			for(int i = 0; i < chars.Length; i++)
			{
				c = chars[i];
				if((c >= 0x0001) && (c <= 0x007F))
				{
					utfLength++;
				}
				else if(c > 0x07FF)
				{
					utfLength += 3;
				}
				else
				{
					utfLength += 2;
				}
			}

			return utfLength;
		}

		private static void encodeUTF8toBuffer(char[] chars, byte[] buffer)
		{
			int c = 0;
			int count = 0;

			for(int i = 0; i < chars.Length; i++)
			{
				c = chars[i];
				if((c >= 0x0001) && (c <= 0x007F))
				{
					buffer[count++] = (byte) c;
				}
				else if(c > 0x07FF)
				{
					buffer[count++] = (byte) (0xE0 | ((c >> 12) & 0x0F));
					buffer[count++] = (byte) (0x80 | ((c >> 6) & 0x3F));
					buffer[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
				}
				else
				{
					buffer[count++] = (byte) (0xC0 | ((c >> 6) & 0x1F));
					buffer[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
				}
			}
		}
	}
}