// System.Runtime.Remoting.Channels.Simple.SimpleWireFormat.cs
//
// Author:
//	DietmarMaurer (dietmar@ximian.com)
//
// (C) 2002 Ximian, Inc.  http://www.ximian.com

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization;
using System.Reflection;
using System.Collections;
using System.IO;
using System.Runtime.Remoting.Messaging;

namespace System.Runtime.Remoting.Channels.Simple {

	public sealed class SimpleWireFormat 
	{
		enum TypeId : byte {
			Boolean,
			Byte,
			Char,
			Decimal,
			Double,
			Int16,
			Int32,
			Int64,
			SByte,
			String,
			Single,
			UInt16,
			UInt32,
			UInt64,
			NULL
		}

		public SimpleWireFormat ()
		{
		}		

		void SerializeObject (BinaryWriter writer, object obj)
		{
			if (obj == null) {
				writer.Write ((byte)TypeId.NULL);
				return;
			}
			
			Type type = obj.GetType ();

			if (type == typeof (String)) 
			{
				writer.Write ((byte)TypeId.String);
				writer.Write ((String)obj);
				return;
			}
			
			if (type == typeof (int)) {
				writer.Write ((byte)TypeId.Int32);
				writer.Write ((int)obj);
				return;
			}		

			if (type == typeof (long)) {
				writer.Write ((byte)TypeId.Int64);
				writer.Write ((long)obj);
				return;
			}		

			if (type == typeof (uint)) {
				writer.Write ((byte)TypeId.UInt32);
				writer.Write ((uint)obj);
				return;
			}		

			if (type == typeof (ulong)) {
				writer.Write ((byte)TypeId.UInt64);
				writer.Write ((ulong)obj);
				return;
			}		

			if (type == typeof (bool)) {
				writer.Write ((byte)TypeId.Boolean);
				writer.Write ((bool)obj);
				return;
			}		

			if (type == typeof (byte)) {
				writer.Write ((byte)TypeId.Byte);
				writer.Write ((byte)obj);
				return;
			}		

			if (type == typeof (sbyte)) {
				writer.Write ((byte)TypeId.SByte);
				writer.Write ((sbyte)obj);
				return;
			}		

			if (type == typeof (char)) {
				writer.Write ((byte)TypeId.Char);
				writer.Write ((char)obj);
				return;
			}		

			if (type == typeof (double)) {
				writer.Write ((byte)TypeId.Double);
				writer.Write ((double)obj);
				return;
			}		

			if (type == typeof (Single)) {
				writer.Write ((byte)TypeId.Single);
				writer.Write ((Single)obj);
				return;
			}
			
			if (type == typeof (Int16)) {
				writer.Write ((byte)TypeId.Int16);
				writer.Write ((Int16)obj);
				return;
			}		

			if (type == typeof (UInt16)) {
				writer.Write ((byte)TypeId.UInt16);
				writer.Write ((UInt16)obj);
				return;
			}		

			if (type == typeof (Decimal)) {
				writer.Write ((byte)TypeId.Decimal);
				writer.Write ((Decimal)obj);
				return;
			}

			throw new NotSupportedException (); 
		}

		object DeserializeObject (BinaryReader reader)
		{
			TypeId tid = (TypeId)reader.ReadByte ();

			if (tid == TypeId.NULL)
				return null;

			if (tid == TypeId.String) {
				return reader.ReadString ();
			}
			
			if (tid == TypeId.Int32) {
				return reader.ReadInt32 ();
			}
			
			if (tid == TypeId.Int64) {
				return reader.ReadInt64 ();
			}
			
			if (tid == TypeId.UInt32) {
				return reader.ReadUInt32 ();
			}
			
			if (tid == TypeId.UInt64) {
				return reader.ReadUInt64 ();
			}
			
			if (tid == TypeId.Boolean) {
				return reader.ReadBoolean ();
			}
			
			if (tid == TypeId.Byte) {
				return reader.ReadByte ();
			}
			
			if (tid == TypeId.SByte) {
				return reader.ReadSByte ();
			}
			
			if (tid == TypeId.Char) {
				return reader.ReadChar ();
			}
			
			if (tid == TypeId.Double) {
				return reader.ReadDouble ();
			}
			
			if (tid == TypeId.Single) {
				return reader.ReadSingle ();
			}
			
			if (tid == TypeId.Byte) {
				return reader.ReadByte ();
			}
			
			if (tid == TypeId.Int16) {
				return reader.ReadInt16 ();
			}
			
			if (tid == TypeId.UInt16) {
				return reader.ReadUInt16 ();
			}
			
			if (tid == TypeId.Decimal) {
				return reader.ReadDecimal ();
			}
			
			throw new NotSupportedException (); 
		}
		
		public IMethodCallMessage DeserializeRequest (Stream serializationStream, string uri)
		{
			if (serializationStream == null) {
				throw new ArgumentNullException ("serializationStream is null");
			}

			Type svr_type = RemotingServices.GetServerTypeForUri (uri);
			if (svr_type == null)
				throw new RemotingException ("no registered server for uri " + uri); 

			BinaryReader reader = new BinaryReader (serializationStream);
			
			string method_name = reader.ReadString ();
			int arg_count = reader.ReadInt32 ();

			object [] args = new object [arg_count];
			for (int i = 0; i < arg_count; i++) {
				args [i] = DeserializeObject (reader);
			}
			
			MonoMethodMessage msg = new MonoMethodMessage (svr_type, method_name, args);
			msg.Uri = uri;
			
			return msg;
		}

		public IMethodReturnMessage DeserializeResponse (Stream serializationStream,
								 IMethodCallMessage request) 
		{

			BinaryReader reader = new BinaryReader (serializationStream);

			object return_value = DeserializeObject (reader);
			
			int arg_count = reader.ReadInt32 ();
			object [] out_args = new object [arg_count];
			for (int i = 0; i < arg_count; i++)
				out_args [i] = DeserializeObject (reader);
			
			return new ReturnMessage (return_value, out_args, arg_count, null, request);
		}
		
		public void SerializeRequest (Stream serializationStream, object graph)
		{
			if (serializationStream == null) {
				throw new ArgumentNullException ("serializationStream is null");
			}

			BinaryWriter writer = new BinaryWriter (serializationStream);

			IMethodCallMessage msg = graph as IMethodCallMessage;
			if (msg != null) {			
				writer.Write (msg.MethodName);
				writer.Write ((int)msg.InArgCount);
				for (int i = 0; i < msg.InArgCount; i++)
					SerializeObject (writer, msg.GetInArg (i));
				return;
			}

			throw new NotSupportedException ();
		}

		public void SerializeResponse (Stream serializationStream, object graph)
		{
			if (serializationStream == null) {
				throw new ArgumentNullException ("serializationStream is null");
			}

			BinaryWriter writer = new BinaryWriter (serializationStream);

			IMethodReturnMessage res = graph as IMethodReturnMessage;
			if (res != null) {

				// this channel does not support serialization of exception,
				// so we simply let the transport decide what to do
				if (res.Exception != null)
					return;
				
				SerializeObject (writer, res.ReturnValue);
				writer.Write (res.OutArgCount);
			
				for (int i = 0; i < res.OutArgCount; i++)
					SerializeObject (writer, res.GetOutArg (i));

				return;
			}

			throw new NotSupportedException ();
		}
	}
}