using System;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Messaging;
using System.Collections;
using System.IO;

namespace CustomChannelSink {
   internal static class Helper {
     public static Stream GetStreamLength(Stream inStream,out long length){
        // Does 'inStream' support seek access?
        if (inStream.CanSeek) {
           length = inStream.Length;
           return inStream;
        }
        // Here 'seek acces' is not supported. We must copy 'inStream'
        // to 'outStream' to obtain the stream length.
        Stream outStream = new MemoryStream();
        byte[] buffer = new Byte[1024];
        int tmp, nBytesRead = 0;
        while ( ( tmp = inStream.Read( buffer, 0, 1024 ) ) > 0 ) {
           outStream.Write( buffer, nBytesRead, tmp );
           nBytesRead += tmp;
        }
        outStream.Seek( 0, SeekOrigin.Begin );
        length = nBytesRead;
        return outStream;
     }
   }

   //
   // Custom Client Sink.
   //
   public class CustomClientSink : BaseChannelSinkWithProperties,
                                   IClientChannelSink {
      private IClientChannelSink m_NextSink;
      public CustomClientSink( IClientChannelSink nextSink ) { 
         m_NextSink = nextSink; 
      }
      public IClientChannelSink NextChannelSink { 
         get { return m_NextSink; } 
      }
      public void AsyncProcessRequest( IClientChannelSinkStack sinkStack,
                                       IMessage msgIn,
                                       ITransportHeaders headers,
                                       Stream msgStream ) {
         long length;
         msgStream = Helper.GetStreamLength( msgStream, out length );
         Console.WriteLine(
            "CustomClientSink:Async, length of the request stream {0}",
            length );
         // Chaining message sink for async return processing.
         sinkStack.Push( this, null );
         m_NextSink.AsyncProcessRequest(sinkStack,msgIn,headers,msgStream);
      }
      public void AsyncProcessResponse(
                           IClientResponseChannelSinkStack sinkStack,
                           Object state,
                           ITransportHeaders headers,
                           Stream msgStream) {
         long length;
         msgStream = Helper.GetStreamLength( msgStream, out length );
         Console.WriteLine(
            "CustomClientSink:Async, length of the response stream {0}",
            length);
         m_NextSink.AsyncProcessResponse(
                                     sinkStack, state, headers, msgStream);
      }
      public Stream GetRequestStream(IMessage msg,
                                     ITransportHeaders headers) {
         return m_NextSink.GetRequestStream( msg, headers );
      }

      public void ProcessMessage( IMessage msg,
                                  ITransportHeaders headersIn,
                                  Stream msgInStream,
                                  out ITransportHeaders headersOut,
                                  out Stream msgOutStream) {
         long length;
         msgInStream = Helper.GetStreamLength( msgInStream, out length );
         Console.WriteLine(
            "CustomClientSink:Sync, length of the request stream {0}",
            length);
         m_NextSink.ProcessMessage(msg, headersIn, msgInStream,
                                   out headersOut, out msgOutStream);
         msgOutStream = Helper.GetStreamLength( msgOutStream, out length );
         Console.WriteLine(
            "CustomClientSink:Sync, length of the response stream {0}",
            length);
      }
   }

   //
   // Custom Server Sink.
   //
   public class CustomServerSink : BaseChannelSinkWithProperties,
                                   IServerChannelSink {
      private IServerChannelSink m_NextSink;
      public CustomServerSink( IServerChannelSink nextSink ) {
         m_NextSink = nextSink;
      }
      public IServerChannelSink NextChannelSink { 
         get { return m_NextSink; } 
      }
      public void AsyncProcessResponse(
                        IServerResponseChannelSinkStack sinkStack,
                        object state,
                        IMessage msg,
                        ITransportHeaders headers,
                        Stream msgStream) {
         long length;
         msgStream = Helper.GetStreamLength( msgStream, out length );
         Console.WriteLine(
            "CustomServerSink:Async, length of the response stream {0}",
            length);
         m_NextSink.AsyncProcessResponse(
                             sinkStack, state, msg, headers, msgStream);
      }

      public Stream GetResponseStream(
                        IServerResponseChannelSinkStack sinkStack,
                        object state,
                        IMessage msg,
                        ITransportHeaders headers) {
         return null;
      }

      public ServerProcessing ProcessMessage(
                        IServerChannelSinkStack sinkStack,
                        IMessage msgIn,
                        ITransportHeaders headersIn,
                        Stream msgInStream,
                        out IMessage msgOut,
                        out ITransportHeaders headersOut,
                        out Stream msgOutStream) {
         long length;
         msgInStream = Helper.GetStreamLength(msgInStream, out length);
         Console.WriteLine(
            "CustomServerSink:Sync, length of the request stream {0}",
            length);
         // Chaining message sink for return processing.          
         sinkStack.Push( this, null );
         ServerProcessing svrProc = m_NextSink.ProcessMessage(
                        sinkStack, msgIn, headersIn, msgInStream,
                        out msgOut, out headersOut, out msgOutStream);
         msgOutStream = Helper.GetStreamLength(msgOutStream,out length);
         Console.WriteLine(
            "CustomServerSink:Sync, length of the response stream {0}",
            length);
         return svrProc;
      }
   }

   //
   // Custom Client Sink Provider.
   //
   public class CustomClientSinkProvider : IClientChannelSinkProvider {
      private IClientChannelSinkProvider m_NextProvider;
      public CustomClientSinkProvider(IDictionary prop,
         ICollection providerData) { }
      public IClientChannelSinkProvider Next {
         get { return m_NextProvider; }  set { m_NextProvider = value; }
      }
      public IClientChannelSink CreateSink(
                           IChannelSender channel,
                           string url,
                           object remoteChannelData ) {
         IClientChannelSink next =
            m_NextProvider.CreateSink( channel, url, remoteChannelData );
         Console.WriteLine(        
            "CustomClientSinkProvider:Creating a message sink.");
         return new CustomClientSink( next );
      }
   }

   //
   // Custom Server Sink Provider.
   //
   public class CustomServerSinkProvider : IServerChannelSinkProvider {
      private IServerChannelSinkProvider m_NextProvider;
      public CustomServerSinkProvider( IDictionary prop,
                                       ICollection providerData) { }
      public IServerChannelSinkProvider Next {
         get { return m_NextProvider; } set { m_NextProvider = value; }
      }
      public IServerChannelSink CreateSink(IChannelReceiver canal) {
         IServerChannelSink next = m_NextProvider.CreateSink(canal);
         Console.WriteLine(
            "CustomServerSinkProvider:Creating a message sink.");
         return new CustomServerSink( next );
      }
      public void GetChannelData( IChannelDataStore channelData ) { }
   }
}