using System;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Activation;
using System.Runtime.Remoting.Services;
using System.Runtime.Remoting.Contexts;
using System.Threading;
using System.Diagnostics;

namespace MsgAsMethodCalls
{
    public interface ICaculator
    {
        double Add(double x, double y);
        double Multiply(double x, double y);
    }

    public class MyProxy : RealProxy
    {
        public MyProxy() : base(typeof(ICaculator)) { }

        public override IMessage Invoke(IMessage msg)
        {
            if (msg as IMethodCallMessage != null)
            {
                IMessage response = Program.ProcessMessage(msg as IMethodCallMessage);
                return response;
            }
            return null;
        }
    }

    public class PriorityProxy : RealProxy
    {
        readonly MarshalByRefObject target;
        readonly ThreadPriority level;

        public PriorityProxy(MarshalByRefObject target,
            Type type,
            ThreadPriority level)
            : base(type)
        {
            this.target = target;
            this.level = level;
        }

        public override IMessage Invoke(IMessage request)
        {
            IMethodCallMessage call = (IMethodCallMessage)request;

            Program.WireTap(call);

// step 1: adjust priority
            Thread here = Thread.CurrentThread;
            ThreadPriority old = here.Priority;
            here.Priority = level;
// step 2: forward call
            IMessage response = null;

            IConstructionCallMessage ctor = call as IConstructionCallMessage;

            if (ctor != null)
            {
                // we are holding a TP, so grab its RP
                RealProxy defaultProxy = RemotingServices.GetRealProxy(target);
                // as intermediatoe RP to invoke constructor
                defaultProxy.InitializeServerObject(ctor);
                // get OUR TP
                MarshalByRefObject tp = (MarshalByRefObject)this.GetTransparentProxy();
                // return a message containing our TP as the result of the constuctor call
                response = EnterpriseServicesHelper.CreateConstructionReturnMessage(ctor, tp);
            }
            else
            {
                response = RemotingServices.ExecuteMessage(target, call);
            }

// step 3: restore old priority
            here.Priority = old;
// step 4: return response message to TP
            return response;
        }
    }

    [AttributeUsage(AttributeTargets.Class)]
    public class PriorityProxyAttribute : ProxyAttribute
    {
        ThreadPriority level;
        public PriorityProxyAttribute(ThreadPriority level)
        {
            this.level = level;
        }

        public override MarshalByRefObject CreateInstance(Type t)
        {
// note that we delegate to our base to get an
// uninitialized instance!
            MarshalByRefObject target = base.CreateInstance(t);
            PriorityProxy rp = new PriorityProxy(target, t, level);
            return (MarshalByRefObject)rp.GetTransparentProxy();
        }
    }

    public class PriorityProperty : IContextProperty
    {
        ThreadPriority level;
        public ThreadPriority Level { get { return level; } }
        internal PriorityProperty(ThreadPriority level)
        { this.level = level; }

// IContextProperty members
        public string Name { get { return "ThreadPriority"; } }
        public bool IsNewContextOK(Context ctx)
        {
            return true;
        }

        public void Freeze(Context ctx) { }
    }

    public class PriorityAttribute : Attribute, IContextAttribute
    {
        ThreadPriority level;
        internal PriorityAttribute(ThreadPriority level)
        { this.level = level; }

// IContextAttribute members
        public bool IsContextOK(Context current,
            IConstructionCallMessage ctor)
        {
// Our property must be present!
            object prop = current.GetProperty("ThreadPriority");
            if (prop == null) return false;
// and its level must match the attribute's
            PriorityProperty pp = (PriorityProperty)prop;
            return pp.Level == this.level;
        }

        public void GetPropertiesForNewContext(
            IConstructionCallMessage ctor)
        {
// create new properties
            IContextProperty prop = new PriorityProperty(this.level);
// associate property with constructor call
            ctor.ContextProperties.Add(prop);

            ctor.ContextProperties.Add(new TimingProperty());

            ctor.ContextProperties.Add(new BoostProperty());

            ctor.LogicalCallContext.SetData("clientpriority", new EnvoyData(Thread.CurrentThread.Priority));
        }
    }

    public abstract class DefaultSink : IMessageSink
    {
        readonly protected IMessageSink next;
        public DefaultSink(IMessageSink next)
        {
            this.next = next;
        }

        public IMessageSink NextSink { get { return next; } }

        public virtual IMessage SyncProcessMessage(IMessage request)
        {
            IMessage response = next.SyncProcessMessage(request);
            return response;
        }

        public virtual IMessageCtrl AsyncProcessMessage(IMessage request,
            IMessageSink upcall)
        {
            IMessageCtrl ctrl = next.AsyncProcessMessage(request, upcall);
            return ctrl;
        }
    }

    public class ServerTimingSink : DefaultSink
    {
        public ServerTimingSink(IMessageSink next)
            : base(next)
        { }

        [ContextStatic]
        static internal long totalTicks = 0;

        public override IMessage SyncProcessMessage(IMessage r)
        {
            long start = DateTime.Now.Ticks;
            IMessage p = next.SyncProcessMessage(r);
            long end = DateTime.Now.Ticks;
            totalTicks += end - start;
            return p;
        }
    }

    public class ClientTimingSink : DefaultSink
    {
        public ClientTimingSink(IMessageSink next)
            : base(next)
        { }

        public override IMessage SyncProcessMessage(IMessage r)
        {
            long start = DateTime.Now.Ticks;
            IMessage p = next.SyncProcessMessage(r);
            long end = DateTime.Now.Ticks;
            ServerTimingSink.totalTicks += end - start;
            return p;
        }
    }

    public class TimingProperty
        : IContextProperty,
        IContributeClientContextSink,
        IContributeServerContextSink
    {
        IContributeClientContextSink Members#region IContributeClientContextSink Members

        public IMessageSink GetClientContextSink(IMessageSink nextSink)
        {
             return new ClientTimingSink(nextSink);
        }

        #endregion

        IContributeServerContextSink Members#region IContributeServerContextSink Members

        public IMessageSink GetServerContextSink(IMessageSink nextSink)
        {
           return new ServerTimingSink(nextSink);
        }

        #endregion

        IContextProperty Members#region IContextProperty Members

        public void Freeze(Context newContext)
        {

        }

        public bool IsNewContextOK(Context newCtx)
        {
            return true;
        }

        public string Name
        {
            get { return "TimingProperty"; }
        }

        #endregion
    }

    internal class EnvoyData : ILogicalThreadAffinative
    {
        internal ThreadPriority clientPriority;
        internal EnvoyData(ThreadPriority level)
        {
            this.clientPriority = level;
        }
    }

    public class PriorityEnvoySink : DefaultSink
    {
        public PriorityEnvoySink(IMessageSink next) : base(next) { }

        public override IMessage SyncProcessMessage(IMessage request)
        {
            IMethodCallMessage call = (IMethodCallMessage)request;
            ThreadPriority p = Thread.CurrentThread.Priority;
            EnvoyData ed = new EnvoyData(p);
            call.LogicalCallContext.SetData("clientpriority", ed);
            return next.SyncProcessMessage(call);
        }
    }

    public class PriorityServerSink : DefaultSink
    {
        public PriorityServerSink(IMessageSink next) : base(next) { }

        public override IMessage SyncProcessMessage(IMessage request)
        {
// grab caller's priority from call context
            IMethodCallMessage call = (IMethodCallMessage)request;
            LogicalCallContext cc = call.LogicalCallContext;
            EnvoyData ed = (EnvoyData)cc.GetData("clientpriority");
            cc.FreeNamedDataSlot("clientpriority");
// proceed to boost-dispatch-unboost
            Thread here = Thread.CurrentThread;
            ThreadPriority old = here.Priority;
            if (ed.clientPriority != ThreadPriority.Highest)
                here.Priority = ed.clientPriority + 1;
            IMessage resp = next.SyncProcessMessage(call);
            if (ed.clientPriority != ThreadPriority.Highest)
                here.Priority = old;
            return resp;
        }
    }

    public class BoostProperty :
        IContextProperty,
        IContributeServerContextSink,
        IContributeEnvoySink
    {
        IContextProperty Members#region IContextProperty Members

        public void Freeze(Context newContext)
        {
            
        }

        public bool IsNewContextOK(Context newCtx)
        {
            return true;
        }

        public string Name
        {
            get { return "Boost"; }
        }

        #endregion

        IContributeServerContextSink Members#region IContributeServerContextSink Members

        public IMessageSink GetServerContextSink(IMessageSink nextSink)
        {
            return new PriorityServerSink(nextSink);
        }

        #endregion

        IContributeEnvoySink Members#region IContributeEnvoySink Members

        public IMessageSink GetEnvoySink(MarshalByRefObject obj, IMessageSink nextSink)
        {
            return new PriorityEnvoySink(nextSink);
        }

        #endregion
}

    public class MyCalc : ContextBoundObject, ICaculator
    {
        public static MyCalc Create(ThreadPriority level)
        {
            MyCalc target = new MyCalc();
            PriorityProxy rp = new PriorityProxy(target, typeof(MyCalc), level);
            return (MyCalc)rp.GetTransparentProxy();
        }

        private MyCalc() { }

        public double Add(double x, double y) { return x + y; }
        public double Multiply(double x, double y) { return x * y; }
    }


    [PriorityProxy(ThreadPriority.Highest)]
    public class MyCalc3 : ContextBoundObject, ICaculator
    {
        public double Add(double x, double y) {
            Console.WriteLine(Thread.CurrentThread.Priority);
            return x + y; 
        }
        public double Multiply(double x, double y) { return x * y; }
    }

    [Priority(ThreadPriority.Highest)]
    public class MyCalc5 : ContextBoundObject, ICaculator
    {
        public double Add(double x, double y) { 
// grab the object's context
            Context here = Thread.CurrentContext;
// fecth the priority property
            IContextProperty p = here.GetProperty("ThreadPriority");
            PriorityProperty pp = (PriorityProperty)p;
            Debug.Assert(pp.Level == ThreadPriority.Highest);

            Console.WriteLine(Thread.CurrentThread.Priority);

            return x + y; 
        }
        public double Multiply(double x, double y) { return x * y; }
    }

    class Program
    {
        public static void WireTap(IMethodMessage msg){
            IMethodCallMessage call = (IMethodCallMessage)msg;
            Console.WriteLine("<{0}>",call.MethodName);
            for(int i=0;i<call.ArgCount;++i)
                Console.WriteLine("<{0}>{1}</{0}>",
                    call.GetArgName(i),
                    call.GetArg(i));

            Console.WriteLine("</{0}>",call.MethodName);
        }

        public static IMethodReturnMessage ProcessMessage(IMethodCallMessage request)
        {
            switch (request.MethodName)
            {
                case "Add":
                    {
                        double x = (double)request.GetInArg(0);
                        double y = (double)request.GetInArg(1);
                        double result = x + y;
                        return new ReturnMessage(result, null, 0, null, request);
                    }
                case "Multiply":
                    {
                        double x = (double)request.GetInArg(0);
                        double y = (double)request.GetInArg(1);
                        double result = x * y;
                        return new ReturnMessage(result, null, 0, null, request);
                    }
                default:
                    {
                        string exm = string.Format("{0} not implemented",
                            request.MethodName);
                        Exception ex = new NotImplementedException(exm);
                        return new ReturnMessage(ex, request);
                    }
            }
        }

        static void Main(string[] args)
        {
// isinst
            MyProxy rp = new MyProxy();
            object tp = rp.GetTransparentProxy();
            ICaculator calc = tp as ICaculator;

            Debug.Assert(calc != null);

            double result = calc.Add(3, 4);

            Debug.Assert(result == 7);

// factory method
            calc = MyCalc.Create(ThreadPriority.Highest);
            result = calc.Add(3, 4);

            Debug.Assert(result == 7);

 // ProxyAttribute
            calc = new MyCalc3();
            result = calc.Add(3, 4);

            Debug.Assert( result == 7);

// ContextProperty
            calc = new MyCalc5();
            result = calc.Add(3, 4);

            Debug.Assert(result == 7);
        }
    }
}