using System;
using System.Text;
using System.Collections.Generic;
using System.IO;
using Aleeda.Specialized.Encoding;

namespace Aleeda.Net.Messages
{
    public class ServerMessage
    {
        #region Fields
        /// <summary>
        /// The ID of this message as an unsigned 32 bit integer.
        /// </summary>
        private uint fID;
        /// <summary>
        ///The MemoryStream creates streams that have memory as a backing store instead of a disk or a network connection.
        /// </summary>
        private MemoryStream Body;
        #endregion

        #region Properties
        /// <summary>
        /// Gets the ID of this message as an unsigned 32 bit integer.
        /// </summary>
        public uint ID
        {
            get { return fID; }
        }
        /// <summary>
        /// Gets the header of this message, by Base64 encoding the message ID to a 2 byte string.
        /// </summary>
        public string Header
        {
            get
            {
                return AleedaEnvironment.GetDefaultEncoding().GetString(Base64Encoding.Encodeuint(ID, 2));
            }
        }
        /// <summary>
        /// Gets the length of the content in this message.
        /// </summary>
        public int contentLength
        {
            get
            {
                return (int)Body.Length;
            }
        }
        #endregion

        #region Constructors
        /// <summary>
        /// Constructs a weak OutgoingMessage, which is not useable until Initialize() is called.
        /// </summary>
        public ServerMessage()
        {
            // Requires a call to Initialize before usage
        }
        /// <summary>
        /// Constructs a OutgoingMessage object with a given ID and no content.
        /// </summary>
        /// <param name="ID">The ID of this message as an unsigned 32 bit integer.</param>
        public ServerMessage(uint ID)
        {
            Initialize(ID);
        }
        #endregion

        #region Methods
        /// <summary>
        /// Clears all the content in the message and sets the message ID.
        /// </summary>
        /// <param name="ID">The ID of this message as an unsigned 32 bit integer.</param>
        public void Initialize(uint ID)
        {
            this.fID = ID;
            this.Body = new MemoryStream();
        }
        /// <summary>
        /// Clears the message content.
        /// </summary>
        public void Clear()
        {
            Body.Dispose();
        }
        /// <summary>
        /// Returns the total content of this message as a string.
        /// </summary>
        /// <returns>String</returns>
        public string GetContentString()
        {
            return AleedaEnvironment.GetDefaultEncoding().GetString(Body.ToArray());
        }

        /// <summary>
        /// Appends a single byte to the message content.
        /// </summary>
        /// <param name="i">The byte to append.</param>
        public void Append(byte b)
        {
            this.Body.WriteByte(b);
        }
        public void AppendChar(byte b)
        {
            this.Body.WriteByte(b);
        }
        /// <summary>
        /// Appends a byte array to the message content.
        /// </summary>
        /// <param name="bzData">The byte array to append.</param>
        public void Append(byte[] bzData)
        {
            if (bzData != null && bzData.Length > 0)
                this.Body.Write(bzData, 0, bzData.Length);
        }
        /// <summary>
        /// Encodes a string with the environment's default text encoding and appends it to the message content.
        /// </summary>
        /// <param name="s">The string to append.</param>
        public void Append(string s)
        {
            Append(s, AleedaEnvironment.GetDefaultEncoding());
        }
        /// <summary>
        /// Encodes a string with a given text encoding and appends it to the message content.
        /// </summary>
        /// <param name="s">The string to append.</param>
        /// <param name="pEncoding">A System.Text.Encoding to use for encoding the string.</param>
        public void Append(string s, Encoding Encoding)
        {
            if (!string.IsNullOrEmpty(s))
            {
                if (Encoding == null)
                    Encoding = AleedaEnvironment.GetDefaultEncoding();

                Append(Encoding.GetBytes(s));
            }
        }
        /// <summary>
        /// Appends a 32 bit integer in it's string representation to the message content.
        /// </summary>
        /// <param name="i">The 32 bit integer to append.</param>
        public void Append(Int32 i)
        {
            Append(i.ToString(), Encoding.UTF8);
        }
        /// <summary>
        /// Appends a 32 bit unsigned integer in it's string representation to the message content.
        /// </summary>
        /// <param name="i">The 32 bit unsigned integer to append.</param>
        public void Append(uint i)
        {
            Append((Int32)i);
        }

        /// <summary>
        /// Appends a wire encoded boolean to the message content.
        /// </summary>
        /// <param name="i">The boolean to encode and append.</param>
        public void AppendBoolean(bool b)
        {
            if (b == true)
                Body.WriteByte(WireEncoding.POSITIVE);
            else
                Body.WriteByte(WireEncoding.NEGATIVE);
        }
        /// <summary>
        /// Appends a wire encoded 32 bit integer to the message content.
        /// </summary>
        /// <param name="i">The 32 bit integer to encode and append.</param>
        public void AppendInt32(Int32 i)
        {
            Append(WireEncoding.EncodeInt32(i));
        }
        /// <summary>
        /// Appends a wire encoded 32 bit unsigned integer to the message content.
        /// </summary>
        /// <param name="i">The 32 bit unsigned integer to encode and append.</param>
        /// <seealso>AppendInt32</seealso>
        public void AppendUInt32(uint i)
        {
            AppendInt32((Int32)i);
        }

        /// <summary>
        /// Appends a string with the default string breaker byte to the message content.
        /// </summary>
        /// <param name="s">The string to append.</param>
        public void AppendString(string s)
        {
            AppendString(s, 2);
        }

        /// <summary>
        /// Appends a string with a given string breaker byte to the message content.
        /// </summary>
        /// <param name="s">The string to append.</param>
        /// <param name="Breaker">The byte used to mark the end of the string.</param>
        public void AppendString(string s, byte Breaker)
        {
            Append(s); // Append string with default encoding
            Append(Breaker); // Append breaker
        }

        public void AppendObject(ISerializableObject obj)
        {
            obj.Serialize(this);
        }

        public void AppendRawInt32(Int32 i)
        {
            Append(i.ToString(), Encoding.ASCII);
        }
        //        public void AppendRawInt32WithBreak(Int32 i, byte b)
        //        {
        //            AppendString(i.ToString(), b);
        //        }
        public void AppendRawInt32WithBreak(Int32 i, byte b)
        { 
            AppendString(i.ToString(), b);
        }
        public void AppendRawUInt(uint i)
        {
            Int32 _i = (Int32)i;
            AppendRawInt32(_i);
        }

        public byte[] GetBytes()
        {
            byte[] Data = new byte[contentLength + 3];
            byte[] Header = Base64Encoding.Encodeuint(ID, 2);
            byte[] realData = Body.ToArray();
            Data[0] = Header[0];
            Data[1] = Header[1];

            for (int i = 0; i < contentLength; i++)
            {
                Data[i + 2] = realData[i];
            }

            Data[Data.Length - 1] = 1;

            return Data;
        }
        #endregion

    }
}
//    public class ServerMessage : IHabboMessage
//    {
//        #region Fields
//        /// <summary>
//        /// The ID of this message as an unsigned 32 bit integer.
//        /// </summary>
//        private uint mID;
//        //private string B64Header;
//        /// <summary>
//        /// The content of this message as a System.Collections.Generic.List(byte).
//        /// </summary>
//        private List<byte> mContent;
//        #endregion

//        #region Properties
//        /// <summary>
//        /// Gets the ID of this message as an unsigned 32 bit integer.
//        /// </summary>
//        public uint ID
//        {
//            get { return mID; }
//        }
//        /// <summary>
//        /// Gets theheader of this message, by Base64 encoding the message ID to a 3 byte string.
//        /// </summary>
//        public string Header
//        {
//            get
//            {
//                return AleedaEnvironment.GetDefaultTextEncoding().GetString(Base64Encoding.Encodeuint(mID, 2));
//            }
//        }
//        /// <summary>
//        /// Gets the length of the content in this message.
//        /// </summary>
//        public int contentLength
//        {
//            get { return mContent.Count; }
//        }
//        #endregion

//        #region Constructors
//        /// <summary>
//        /// Constructs a weak ServerMessage, which is not useable until Initialize() is called.
//        /// </summary>
//        public ServerMessage()
//        {
//            // Requires a call to Initialize before usage
//        }
//        /// <summary>
//        /// Constructs a ServerMessage object with a given ID and no content.
//        /// </summary>
//        /// <param name="ID">The ID of this message as an unsigned 32 bit integer.</param>
//        public ServerMessage(uint ID)
//        {
//            Initialize(ID);
//        }
//        #endregion

//        #region Methods
//        /// <summary>
//        /// Clears all the content in the message and sets the message ID.
//        /// </summary>
//        /// <param name="ID">The ID of this message as an unsigned 32 bit integer.</param>
//        public void Initialize(uint ID)
//        {
//            mID = ID;
//            mContent = new List<byte>();
//        }
//        /// <summary>
//        /// Clears the message content.
//        /// </summary>
//        public void Clear()
//        {
//            mContent.Clear();
//        }
//        /// <summary>
//        /// Returns the total content of this message as a string.
//        /// </summary>
//        /// <returns>String</returns>
//        public string GetContentString()
//        {
//            return AleedaEnvironment.GetDefaultTextEncoding().GetString(mContent.ToArray());
//        }

//        /// <summary>
//        /// Appends a single byte to the message content.
//        /// </summary>
//        /// <param name="b">The byte to append.</param>
//        public void Append(byte b)
//        {
//            mContent.Add(b);
//        }
//        public void Append(object b)
//        {
//            Append(b);
//        }
//        /// <summary>
//        /// Appends a byte array to the message content.
//        /// </summary>
//        /// <param name="bzData">The byte array to append.</param>
//        public void Append(byte[] bzData)
//        {
//            if (bzData != null && bzData.Length > 0)
//                mContent.AddRange(bzData);
//        }
//        /// <summary>
//        /// Encodes a string with the environment's default text encoding and appends it to the message content.
//        /// </summary>
//        /// <param name="s">The string to append.</param>
//        public void Append(string s)
//        {
//            Append(s, null);
//        }
//        /// <summary>
//        /// Encodes a string with a given text encoding and appends it to the message content.
//        /// </summary>
//        /// <param name="s">The string to append.</param>
//        /// <param name="pEncoding">A System.Text.Encoding to use for encoding the string.</param>
//        public void Append(string s, Encoding pEncoding)
//        {
//            if (s != null && s.Length > 0)
//            {
//                if (pEncoding == null)
//                    pEncoding = AleedaEnvironment.GetDefaultTextEncoding();

//                Append(pEncoding.GetBytes(s));
//            }
//        }
//        /// <summary>
//        /// Appends a 32 bit integer in it's string representation to the message content.
//        /// </summary>
//        /// <param name="i">The 32 bit integer to append.</param>
//        public void Append(Int32 i)
//        {
//            Append(i.ToString());
//        }
//        /// <summary>
//        /// Appends a 32 bit unsigned integer in it's string representation to the message content.
//        /// </summary>
//        /// <param name="i">The 32 bit unsigned integer to append.</param>
//        public void Append(uint i)
//        {
//            Append((Int32)i);
//        }

//        /// <summary>
//        /// Appends a wire encoded boolean to the message content.
//        /// </summary>
//        /// <param name="b">The boolean to encode and append.</param>
//        public void AppendBoolean(bool b)
//        {
//            if (b == true)
//                mContent.Add(WireEncoding.POSITIVE);
//            else
//                mContent.Add(WireEncoding.NEGATIVE);
//        }
//        /// <summary>
//        /// Appends a wire encoded 32 bit integer to the message content.
//        /// </summary>
//        /// <param name="i">The 32 bit integer to encode and append.</param>
//        public void AppendInt32(Int32 i)
//        {
//            Append(WireEncoding.EncodeInt32(i));
//        }
//        public void AppendInt32(Int32 i, byte b)
//        {
//            Append(WireEncoding.EncodeInt32(i));
//            Append(b);
//        }
//        /// <summary>
//        /// Appends a wire encoded 32 bit unsigned integer to the message content.
//        /// </summary>
//        /// <param name="i">The 32 bit unsigned integer to encode and append.</param>
//        /// <seealso>AppendInt32</seealso>
//        public void AppendUInt32(uint i)
//        {
//            AppendInt32((Int32)i);
//        }
//        /// <summary>
//        /// Appends a string with the default string breaker byte to the message content.
//        /// </summary>
//        /// <param name="s">The string to append.</param>
//        public void AppendString(string s)
//        {
//            AppendString(s, 2);
//        }
//        public void AppendRawInt32WithBreak(Int32 i, byte b)
//        {
//            AppendString(i.ToString(), b);
//        }
//        public void AppendRawInt32(Int32 i)
//        {
//            AppendString(i.ToString(), Encoding.ASCII);
//        }
//        public void AppendBytes(byte[] Data)
//        {
//            if (Data == null || Data.Length == 0)
//            {
//                return;
//            }

//            mContent.AddRange(Data);
//        }

//        public void AppendString(string s, Encoding Encoding)
//        {
//            if (s == null || s.Length == 0)
//            {
//                return;
//            }

//            AppendBytes(Encoding.GetBytes(s));
//        }
//        /// <summary>
//        /// Appends a string with a given string breaker byte to the message content.
//        /// </summary>
//        /// <param name="s">The string to append.</param>
//        /// <param name="Breaker">The byte used to mark the end of the string.</param>
//        public void AppendString(string s, byte Breaker)
//        {
//            Append(s); // Append string with default encoding
//            Append(Breaker); // Append breaker
//        }
//        public void AppendChar(byte Breaker)
//        {
//            Append(Breaker); // Append breaker
//        }
//        public void AppendObject(ISerializableObject obj)
//        {
//            obj.Serialize(this);
//        }

//        public byte[] GetBytes()
//        {
//            byte[] Data = new byte[contentLength + 2 + 1];
            
//            byte[] Header = Base64Encoding.Encodeuint(mID, 2);
//            Data[0] = Header[0];
//            Data[1] = Header[1];

//            for (int i = 0; i < this.contentLength; i++)
//            {
//                Data[i + 2] = mContent[i]; 
//            }

//            Data[Data.Length - 1] = 1;

//            return Data;
//        }
//        #endregion
//    }