using System.Diagnostics;
using System.Text;
using WCS.BLL;
using WCS.BLL.DbModels;
using WCS.DAL.Db;
using WCS.Model;

namespace WCS.WebApi.Controllers
{
    public class RequestResponseLoggingMiddleware
    {
        private readonly RequestDelegate _next;

        public RequestResponseLoggingMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            var stopwatch = Stopwatch.StartNew();

            var requestBody = string.Empty;
            var responseBody = string.Empty;
            var originalRequestBody = context.Request.Body;
            var requestTime = DateTime.Now;

            // 可以选择只记录特定的Content-RequestType //只记录json类型的请求
            if (context.Request.ContentType != null && !context.Request.ContentType.Contains("application/json", StringComparison.OrdinalIgnoreCase))
            {
                ;
            }
            try
            {
                ////读取Request Body
                //// 保存原始的Request Body
                var requestBodyStream = new MemoryStream();
                await originalRequestBody.CopyToAsync(requestBodyStream);
                originalRequestBody.Dispose();
                requestBodyStream.Position = 0; // 将流的位置重置回开始处  
                requestBody = await new StreamReader(requestBodyStream).ReadToEndAsync();
                // 替换Request.Body以便后续中间件可以读取  
                requestBodyStream.Position = 0;// 将流的位置重置回开始处  
                context.Request.Body = requestBodyStream;


                // 保存原始的Response Body
                var originalResponseBodyStream = context.Response.Body;
                using (var memStream = new MemoryStream())
                {
                    context.Response.Body = memStream;

                    // 继续处理请求
                    await _next(context);

                    memStream.Seek(0, SeekOrigin.Begin);
                    responseBody = await new StreamReader(memStream).ReadToEndAsync();

                    memStream.Seek(0, SeekOrigin.Begin);
                    await memStream.CopyToAsync(originalResponseBodyStream);
                }
            }
            catch (Exception e)
            {

                //return new ResponseCommon()
                //{
                //    Code = 300,
                //    Message = $"操作失败：{e.Message}"
                //};
            }

            finally
            {
                //TO DO如何将记日志的 和不记日志的分开 解耦
                if (!context.Request.Path.ToString().Contains("getInterfaceRecord"))
                    try
                    {
                        var logRecord = new SystemApiLogRecord()
                        {
                            DeviceIp = context?.Connection?.RemoteIpAddress?.ToString(),
                            RequestUrl = context.Request.Path,
                            RequestBody = requestBody,
                            QueryString = context.Request.QueryString.ToString(),
                            IsResponse = true,
                            ResponseJson = responseBody,
                            RequestTime = requestTime,
                            ResponseTime = DateTime.Now,
                            ExecutionTime = stopwatch.ElapsedMilliseconds
                        };
                        await DbHelp.dbLog.Insertable(logRecord).ExecuteCommandAsync();
                    }
                    catch (Exception e)
                    {
                        //TO DO txt记录失败的日志和响应实体
                    }
            }
        }
    }
}