#823 prep work with TODO comments

Author: justcoding121

src/Titanium.Web.Proxy/EventArguments/BeforeBodySendEventArgs.cs src/Titanium.Web.Proxy/EventArguments/BeforeBodyWriteEventArgs.cs

@@ -10,12 +10,12 @@ namespace Titanium.Web.Proxy.EventArguments
 
     public class BeforeBodyWriteEventArgs : ProxyEventArgsBase
     {
-        internal BeforeBodyWriteEventArgs(SessionEventArgs session, byte[] bodyBytes, bool isChunked, bool isFinalChunk) : base(session.Server, session.ClientConnection)
+        internal BeforeBodyWriteEventArgs(SessionEventArgs session, byte[] bodyBytes, bool isChunked, bool isLastChunk) : base(session.Server, session.ClientConnection)
         {
             Session = session;
             BodyBytes = bodyBytes;
             IsChunked = isChunked;
-            IsFinalChunk = isFinalChunk;
+            IsLastChunk = isLastChunk;
         }
 
 
@@ -34,7 +34,7 @@ internal BeforeBodyWriteEventArgs(SessionEventArgs session, byte[] bodyBytes, bo
         /// Indicates if this is the last chunk from client or server stream, when request is chunked.
         /// Override this property to true if there are more bytes to write.
         /// </summary>
-        public bool IsFinalChunk { get; set; }
+        public bool IsLastChunk { get; set; }
 
         /// <summary>
         /// The bytes about to be written. If IsChunked is true, this will be a chunk of the bytes to be written.

src/Titanium.Web.Proxy/Helpers/HttpStream.cs

@@ -1054,6 +1054,14 @@ public Task CopyBodyAsync(IHttpStreamWriter writer, bool isChunked, long content
             bool isRequest,
             SessionEventArgs args, CancellationToken cancellationToken)
         {
+
+#if DEBUG
+            if ((isRequest && args.HttpClient.Request.OriginalHasBody && !args.HttpClient.Request.IsBodyRead && server.ShouldCallBeforeRequestBodyWrite())
+                || (!isRequest && args.HttpClient.Response.OriginalHasBody && !args.HttpClient.Response.IsBodyRead && server.ShouldCallBeforeResponseBodyWrite()))
+            {
+                return handleBodyWrite(writer, isChunked, contentLength, isRequest, args, cancellationToken);
+            }
+#endif
             // For chunked request we need to read data as they arrive, until we reach a chunk end symbol
             if (isChunked)
             {
@@ -1070,6 +1078,20 @@ public Task CopyBodyAsync(IHttpStreamWriter writer, bool isChunked, long content
             return copyBytesToStream(writer, contentLength, isRequest, args, cancellationToken);
         }
 
+        private Task handleBodyWrite(IHttpStreamWriter writer, bool isChunked, long contentLength,
+            bool isRequest, SessionEventArgs args, CancellationToken cancellationToken)
+        {
+            var originalContentLength = isRequest ? args.HttpClient.Request.OriginalContentLength : args.HttpClient.Response.OriginalContentLength;
+            var originalIsChunked = isRequest ? args.HttpClient.Request.OriginalIsChunked : args.HttpClient.Response.OriginalIsChunked;
+
+            //1. Read bytes from original stream (max length of bytes will be equal to bufferPool.BufferSize).
+            //2. Call BeforeBodyWrite event handler with BeforeBodyWriteEventArgs.BodyBytes set to the bytes read from original stream.
+            //3. Write BeforeBodyWriteEventArgs.BodyBytes to the target stream when BeforeBodyWriteEventArgs.BodyBytes is not null or empty.
+            //4. Exit when 'long contentLength' parameter number of bytes are written to target stream (when not chunked) or
+            //when BeforeBodyWriteEventArgs.IsLastChunk is true after callback (when chunked).
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         ///     Copies the given input bytes to output stream chunked
         /// </summary>

src/Titanium.Web.Proxy/RequestHandler.cs

@@ -400,5 +400,23 @@ private async Task onBeforeRequest(SessionEventArgs args)
                 await BeforeRequest.InvokeAsync(this, args, ExceptionFunc);
             }
         }
+
+        internal bool ShouldCallBeforeRequestBodyWrite()
+        {
+            if (OnRequestBodyWrite != null)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        internal async Task OnBeforeRequestBodyWrite(BeforeBodyWriteEventArgs args)
+        {
+            if (OnRequestBodyWrite != null)
+            {
+                await OnRequestBodyWrite.InvokeAsync(this, args, ExceptionFunc);
+            }
+        }
     }
 }

src/Titanium.Web.Proxy/ResponseHandler.cs

@@ -150,5 +150,23 @@ private async Task onAfterResponse(SessionEventArgs args)
                 await AfterResponse.InvokeAsync(this, args, ExceptionFunc);
             }
         }
+
+        internal bool ShouldCallBeforeResponseBodyWrite()
+        {
+            if (OnResponseBodyWrite != null)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        internal async Task OnBeforeResponseBodyWrite(BeforeBodyWriteEventArgs args)
+        {
+            if (OnResponseBodyWrite != null)
+            {
+                await OnResponseBodyWrite.InvokeAsync(this, args, ExceptionFunc);
+            }
+        }
     }
 }