#region Disclaimer / License
// Copyright (C) 2009, Kenneth Skovhede
// http://www.hexad.dk, opensource@hexad.dk
// 
// 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
// 
#endregion
using System;
using System.IO;

namespace OSGeo.MapGuide.MaestroAPI.Serialization
{
	/// <summary>
	/// A utility for serializing objects to the internal MapGuide Format
	/// </summary>
	public class MgBinaryDeserializer
	{
		private Stream m_stream;
		private byte[] m_buf = new byte[Math.Max(MgBinarySerializer.DoubleLen, MgBinarySerializer.UInt64Len)];
		private Version m_siteVersion;

        /// <summary>
        /// Gets the site version.
        /// </summary>
        /// <value>The site version.</value>
		public Version SiteVersion { get { return m_siteVersion; } }

        /// <summary>
        /// Initializes a new instance of the <see cref="MgBinaryDeserializer"/> class.
        /// </summary>
        /// <param name="stream">The stream.</param>
        /// <param name="siteversion">The siteversion.</param>
		public MgBinaryDeserializer(Stream stream, Version siteversion)
		{
			m_stream = stream;
			m_siteVersion = siteversion;
		}
        
        /*
		private MgStreamHeader ReadStreamHeader()
		{
			MgStreamHeader h = new MgStreamHeader();
			m_stream.Read(m_buf, 0, MgBinarySerializer.UInt32Len);
			h.StreamStart = (MgStreamHeaderValues)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			h.StreamVersion = BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			h.StreamDataHdr = (MgStreamHeaderValues)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			return h;
		}*/

		private MgArgumentPacket ReadArgumentPacket()
		{
			MgArgumentPacket p = new MgArgumentPacket();
			p.PacketHeader = (MgPacketHeader)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			p.ArgumentType = (MgArgumentType)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			if (p.ArgumentType == MgArgumentType.String)
				p.Length = BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			return p;
		}

		private MgBinaryStreamArgumentPacket ReadBinaryStreamArgumentPacket()
		{
			MgBinaryStreamArgumentPacket p = new MgBinaryStreamArgumentPacket();
			p.PacketHeader = (MgPacketHeader)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			p.ArgumentType = (MgArgumentType)BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			p.Version = BitConverter.ToUInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			p.Length = BitConverter.ToUInt64(ReadStream(MgBinarySerializer.UInt64Len), 0);
			return p;
		}

        /// <summary>
        /// Reads the string.
        /// </summary>
        /// <returns></returns>
		public string ReadString()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.String)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"string\" was expected");

			if (m_siteVersion >= SiteVersions.GetVersion(KnownSiteVersions.MapGuideOS1_2))
			{
				return ReadInternalString();
			}
			else
			{
				byte[] buf = ReadStreamRepeat((int)p.Length);

				string b = System.Text.Encoding.UTF8.GetString(buf);
				//Chop of C zero terminator... Why store it, when the length is also present?
				return b.Substring(0, b.Length - 1); 
			}
			
		}

        /// <summary>
        /// Reads the internal string.
        /// </summary>
        /// <returns></returns>
		public string ReadInternalString()
		{
			int charwidth = m_stream.ReadByte();
			System.Text.Encoding ec;
			switch(charwidth)
			{
				case 1:
					ec = System.Text.Encoding.UTF8;
					break;
				case 2:
					ec = System.Text.Encoding.GetEncoding("UTF-16");
					break;
				default:
					throw new Exception("Failed to get valid string char width");
			}

			byte[] t = ReadStreamRepeat(MgBinarySerializer.UInt32Len);
			int len = BitConverter.ToInt32(t, 0);
			string b = ec.GetString(ReadStreamRepeat(len * charwidth));
			//Chop of C zero terminator... Why store it, when the length is also present?
			return b.Substring(0, b.Length - 1);
		}

        /// <summary>
        /// Reads the resource identifier.
        /// </summary>
        /// <returns></returns>
		public string ReadResourceIdentifier()
		{
			int classId = ReadClassId();
			if (classId == 0)
				return null;

			if (m_siteVersion <= SiteVersions.GetVersion(KnownSiteVersions.MapGuideEP1_1) && classId != 12003)
				throw new Exception("Object was not a resourceidentifier");
			if (m_siteVersion > SiteVersions.GetVersion(KnownSiteVersions.MapGuideEP1_1) && classId != 11500)
				throw new Exception("Object was not a resourceidentifier");

			if (m_siteVersion >= SiteVersions.GetVersion(KnownSiteVersions.MapGuideOS1_2))
				return ReadInternalString();
			else
				return ReadString();
		}

        /// <summary>
        /// Reads the int64.
        /// </summary>
        /// <returns></returns>
		public long ReadInt64()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.INT64)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Int64\" was expected");

			return BitConverter.ToInt64(ReadStream(MgBinarySerializer.UInt64Len), 0);
		}

        /// <summary>
        /// Reads the int32.
        /// </summary>
        /// <returns></returns>
		public int ReadInt32()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.INT32)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Int32\" was expected");

			return BitConverter.ToInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
		}

        /// <summary>
        /// Reads the int16.
        /// </summary>
        /// <returns></returns>
		public short ReadInt16()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.INT16)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Int16\" was expected");

			return BitConverter.ToInt16(ReadStream(MgBinarySerializer.UInt16Len), 0);
		}

        /// <summary>
        /// Reads the bool.
        /// </summary>
        /// <returns></returns>
		public bool ReadBool()
		{
			return ReadByte() != 0;
		}

        /// <summary>
        /// Reads the byte.
        /// </summary>
        /// <returns></returns>
		public byte ReadByte()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.INT8)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Int8\" was expected");

			return (byte)m_stream.ReadByte();
		}

        /// <summary>
        /// Reads the single.
        /// </summary>
        /// <returns></returns>
		public float ReadSingle()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.Float)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Float\" was expected");

			return BitConverter.ToSingle(ReadStream(MgBinarySerializer.FloatLen), 0);
		}

        /// <summary>
        /// Reads the double.
        /// </summary>
        /// <returns></returns>
		public double ReadDouble()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.Double)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Double\" was expected");

			return BitConverter.ToDouble(ReadStream(MgBinarySerializer.DoubleLen), 0);
		}

        /// <summary>
        /// Reads the coordinates.
        /// </summary>
        /// <returns></returns>
		public double[] ReadCoordinates()
		{
			int classid = ReadClassId();
			if (m_siteVersion <= SiteVersions.GetVersion(KnownSiteVersions.MapGuideEP1_1) && classid != 18000)
				throw new Exception("Coordinate expected, but got object: " + classid.ToString());
			if (m_siteVersion > SiteVersions.GetVersion(KnownSiteVersions.MapGuideEP1_1) && classid != 20000)
				throw new Exception("Coordinate expected, but got object: " + classid.ToString());

			int count = ReadInt32();
			int dimensions = ReadInt32();
			if (dimensions == 0)
				dimensions = 2;
			else if (dimensions > 4)
				throw new Exception("Coordinate count reported: " + dimensions.ToString() + ", for a single coordinate");

			double[] args = new double[dimensions * count];
			for(int i = 0;i < (dimensions * count); i++)
				args[i] = ReadDouble();

			return args;
		}

        /// <summary>
        /// Reads the stream.
        /// </summary>
        /// <returns></returns>
		public Stream ReadStream()
		{
			MgBinaryStreamArgumentPacket p = ReadBinaryStreamArgumentPacket();
			if (p.ArgumentType != MgArgumentType.Stream)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"Stream\" was expected");

			if (ReadBool())
				return null;

			//TODO: If the stream is large, we use a lot of memory, perhaps the filebacked async stream could be used
			//Due to the annoying embedded buffer size markers, we cannot return the stream 'as is' Grrrrrr!

			int r;
			ulong remain = p.Length; 
			byte[] buf = new byte[1024 * 8];

			MemoryStream ms = new MemoryStream();
			do
			{
				int blocksize = ReadInt32();
				r = 1;

				while( r > 0 && blocksize > 0)
				{
					r = m_stream.Read(buf, 0, (int)Math.Min((ulong)remain, (ulong)buf.Length));
					blocksize -= r;
					remain -= (ulong)r;
					ms.Write(buf, 0, r);
				}

				if (blocksize != 0)
					throw new Exception("Stream ended prematurely");

			} while (remain > 0);

			ms.Position = 0;
			return ms;
		}

        /// <summary>
        /// Reads the class id.
        /// </summary>
        /// <returns></returns>
		public int ReadClassId()
		{
			MgArgumentPacket p = ReadArgumentPacket();
			if (p.ArgumentType != MgArgumentType.ClassId)
				throw new InvalidCastException("Data in stream had type: " + p.ArgumentType.ToString() + ", type \"ClassId\" was expected");

			return BitConverter.ToInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
		}

        /// <summary>
        /// Reads the stream end.
        /// </summary>
		public void ReadStreamEnd()
		{
			int v = BitConverter.ToInt32(ReadStream(MgBinarySerializer.UInt32Len), 0);
			if (v != (int)MgStreamHeaderValues.StreamEnd)
				throw new Exception("The read value was: " + v.ToString() + " while " + ((int)MgStreamHeaderValues.StreamEnd).ToString() + " was expected");
		}

        /// <summary>
        /// Reads the object.
        /// </summary>
        /// <returns></returns>
		public IBinarySerializable ReadObject()
		{
			int classId = ReadClassId();
			if (classId == 0)
				return null;

			IBinarySerializable obj = null;
			switch(classId)
			{
				case 0:
				break;
				default:
					throw new Exception("Unknown object type: " + classId.ToString());
			}
			obj.Deserialize(this);

			return obj;
		}

        /// <summary>
        /// Reads the stream repeat.
        /// </summary>
        /// <param name="len">The len.</param>
        /// <returns></returns>
		public byte[] ReadStreamRepeat(int len)
		{
			byte[] buf = new byte[len];
			ReadStreamRepeat(buf, 0, len);
			return buf;
		}

        /// <summary>
        /// Internal helper that will read from a potentially fragmented stream
        /// </summary>
        /// <param name="buf">The buf.</param>
        /// <param name="offset">The offset.</param>
        /// <param name="len">The number of bytes to read</param>
		public void ReadStreamRepeat(byte[] buf, int offset, int len)
		{
			int r;
			int _offset = 0;
			
			if (buf.Length < len + offset)
				throw new OverflowException("Buffer is too small");

			do
			{
				r = m_stream.Read(buf, offset + _offset, len - _offset);
				_offset += r;
			} while (r > 0);

			if (_offset != len)
				throw new Exception("Stream exhausted while reading " + len.ToString() + " bytes");
		}

		/// <summary>
		/// Helper function that will throw an exception if the stream is unexceptedly exhausted
		/// </summary>
		/// <param name="len">The number of bytes to read</param>
		/// <returns>The internal buffer object</returns>
		private byte[] ReadStream(int len)
		{
			ReadStreamRepeat(m_buf, 0, len); 
			return m_buf;
		}
	}
}