//------------------------------------------------------------------------------
//  <copyright file="SqlSer.cs" company="Microsoft Corporation">
//     Copyright (c) Microsoft Corporation. All Rights Reserved.
//     Information Contained Herein is Proprietary and Confidential.
//  </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="true">daltudov</owner>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">beysims</owner>
// <owner current="true" primary="false">Microsoft</owner>
// <owner current="true" primary="false">vadimt</owner>
// <owner current="false" primary="false">venkar</owner>
// <owner current="false" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.Data;
using System.Data.Common;
using System.Data.Sql;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Runtime.CompilerServices;

namespace Microsoft.SqlServer.Server {

    internal class SerializationHelperSql9 {
        // Don't let anyone create an instance of this class.
        private SerializationHelperSql9() {}

        // Get the m_size of the serialized stream for this type, in bytes.
        // This method creates an instance of the type using the public
        // no-argument constructor, serializes it, and returns the m_size
        // in bytes.
        // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
        [MethodImpl(MethodImplOptions.NoInlining)]
        internal static int SizeInBytes(Type t) {
            return SizeInBytes(Activator.CreateInstance(t));
        }

        // Get the m_size of the serialized stream for this type, in bytes.
        internal static int SizeInBytes(object instance) {
            Type t = instance.GetType();
            Format k = GetFormat(t);
            DummyStream stream = new DummyStream();
            Serializer ser = GetSerializer(instance.GetType());
            ser.Serialize(stream, instance);
            return (int) stream.Length;
        }

        internal static void Serialize(Stream s, object instance) {
            GetSerializer(instance.GetType()).Serialize(s, instance);
        }

        internal static object Deserialize(Stream s, Type resultType) {
            return GetSerializer(resultType).Deserialize(s);
        }

        private static Format GetFormat(Type t) {
            return GetUdtAttribute(t).Format;
        }

        //cache the relationship between a type and its serializer
        //this is expensive to compute since it involves traversing the
        //custom attributes of the type using reflection.
        //
        //use a per-thread cache, so that there are no synchronization
        //issues when accessing cache entries from multiple threads.
        [ThreadStatic]
        private static Hashtable m_types2Serializers;

        private static Serializer GetSerializer(Type t) {
            if (m_types2Serializers == null)
                m_types2Serializers = new Hashtable();

            Serializer s = (Serializer) m_types2Serializers[t];
            if (s == null) {
                s = (Serializer) GetNewSerializer(t);
                m_types2Serializers[t] = s;
            }
            return s;
        }

        internal static int GetUdtMaxLength(Type t) {
            SqlUdtInfo udtInfo = SqlUdtInfo.GetFromType(t);
            
            if (Format.Native == udtInfo.SerializationFormat) {
                //In the native format, the user does not specify the
                //max byte size, it is computed from the type definition
                return SerializationHelperSql9.SizeInBytes(t);
            }
            else {
                //In all other formats, the user specifies the maximum size in bytes.
                return udtInfo.MaxByteSize;
            }
        }

        private static object[] GetCustomAttributes (Type t) {
            return t.GetCustomAttributes(typeof(SqlUserDefinedTypeAttribute), false);
        }

        internal static SqlUserDefinedTypeAttribute GetUdtAttribute(Type t) {
            SqlUserDefinedTypeAttribute udtAttr = null;
            object[] attr = GetCustomAttributes (t);

            if (attr != null && attr.Length == 1) {
                udtAttr = (SqlUserDefinedTypeAttribute) attr[0];
            }
            else {
                throw InvalidUdtException.Create(t, Res.SqlUdtReason_NoUdtAttribute);
            }
            return udtAttr;
        }

        // Create a new serializer for the given type.
        private static Serializer GetNewSerializer(Type t) {
            SqlUserDefinedTypeAttribute udtAttr = GetUdtAttribute(t);
            Format k = GetFormat(t);

            switch (k) {
                case Format.Native:
                    return new NormalizedSerializer(t);
                case Format.UserDefined:
                    return new BinarySerializeSerializer(t);
                case Format.Unknown: // should never happen, but fall through
                default:
                    throw ADP.InvalidUserDefinedTypeSerializationFormat(k);
            }
        }
    }

    // The base serializer class.
    internal abstract class Serializer {
        public abstract object Deserialize(Stream s);
        public abstract void Serialize(Stream s, object o);
        protected Type m_type;

        protected Serializer(Type t) {
            this.m_type = t;
        }
    }

    internal sealed class NormalizedSerializer: Serializer {
        BinaryOrderedUdtNormalizer m_normalizer;
        bool m_isFixedSize;
        int m_maxSize;

        internal NormalizedSerializer(Type t): base(t) {
            SqlUserDefinedTypeAttribute udtAttr = SerializationHelperSql9.GetUdtAttribute(t);
            this.m_normalizer = new BinaryOrderedUdtNormalizer(t, true);
            this.m_isFixedSize = udtAttr.IsFixedLength;
            this.m_maxSize = this.m_normalizer.Size;
        }

        public override void Serialize(Stream s, object o) {
            m_normalizer.NormalizeTopObject(o, s);
        }

        public override object Deserialize(Stream s) {
            object result = m_normalizer.DeNormalizeTopObject(this.m_type, s);
            return result;
        }
    }

    internal sealed class BinarySerializeSerializer: Serializer {
        internal BinarySerializeSerializer(Type t): base(t) {
        }

        public override void Serialize(Stream s, object o) {
            BinaryWriter w = new BinaryWriter(s);
            ((IBinarySerialize)o).Write(w);
        }

        // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
        [MethodImpl(MethodImplOptions.NoInlining)]
        public override object Deserialize(Stream s) {
            object instance = Activator.CreateInstance(m_type);
            BinaryReader r = new BinaryReader(s);
            ((IBinarySerialize)instance).Read(r);
            return instance;
        }
    }

    // A dummy stream class, used to get the number of bytes written
    // to the stream.
    internal sealed class DummyStream: Stream {
        private long m_size;

        public DummyStream() {
        }

        private void DontDoIt() {
            throw new Exception(Res.GetString(Res.Sql_InternalError));
        }

        public override bool CanRead {
            get {
                return false;
            }
        }

        public override bool CanWrite {
            get {
                return true;
            }
        }

        public override bool CanSeek {
            get {
                return false;
            }
        }

        public override long Position {
            get {
                return this.m_size;
            }
            set {
                this.m_size = value;
            }
        }

        public override long Length {
            get {
                return this.m_size;
            }
        }

        public override void SetLength(long value) {
            this.m_size = value;
        }

        public override long Seek(long value, SeekOrigin loc) {
            DontDoIt();
            return -1;
        }

        public override void Flush() {
        }

        public override int Read(byte[] buffer, int offset, int count) {
            DontDoIt();
            return -1;
        }

        public override void Write(byte[] buffer, int offset, int count) {
            this.m_size += count;
        }
    }
}