using JsonRPC4.Common;
using JsonRPC4.Router.Abstractions;
using JsonRPC4.Router.Utilities;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace JsonRPC4.Router
{
	public class RpcRequestHandler : IRpcRequestHandler
	{
		// Token: 0x17000032 RID: 50
		// (get) Token: 0x06000096 RID: 150 RVA: 0x000032A5 File Offset: 0x000014A5
		private IOptions<RpcServerConfiguration> serverConfig { get; }

		// Token: 0x17000033 RID: 51
		// (get) Token: 0x06000097 RID: 151 RVA: 0x000032AD File Offset: 0x000014AD
		private IRpcInvoker invoker { get; }

		// Token: 0x17000034 RID: 52
		// (get) Token: 0x06000098 RID: 152 RVA: 0x000032B5 File Offset: 0x000014B5
		private IRpcParser parser { get; }

		// Token: 0x17000035 RID: 53
		// (get) Token: 0x06000099 RID: 153 RVA: 0x000032BD File Offset: 0x000014BD
		private ILogger<RpcRequestHandler> logger { get; }

		// Token: 0x17000036 RID: 54
		// (get) Token: 0x0600009A RID: 154 RVA: 0x000032C5 File Offset: 0x000014C5
		private IRpcResponseSerializer responseSerializer { get; }

		// Token: 0x0600009B RID: 155 RVA: 0x000032D0 File Offset: 0x000014D0
		public RpcRequestHandler(IOptions<RpcServerConfiguration> serverConfig, IRpcInvoker invoker, IRpcParser parser, IRpcResponseSerializer responseSerializer, ILogger<RpcRequestHandler> logger)
		{
			if (serverConfig == null)
			{
				throw new ArgumentNullException("serverConfig");
			}
			this.serverConfig = serverConfig;
			if (invoker == null)
			{
				throw new ArgumentNullException("invoker");
			}
			this.invoker = invoker;
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			this.parser = parser;
			if (responseSerializer == null)
			{
				throw new ArgumentNullException("responseSerializer");
			}
			this.responseSerializer = responseSerializer;
			this.logger = logger;
		}

		// Token: 0x0600009C RID: 156 RVA: 0x00003344 File Offset: 0x00001544
		public async Task<bool> HandleRequestAsync(RpcPath requestPath, Stream requestBody, IRouteContext routeContext, Stream responseBody)
		{
			try
			{
				ParsingResult result = parser.ParseRequests(requestBody);
				logger.ProcessingRequests(result.RequestCount);
				int? batchRequestLimit = serverConfig.Value.BatchRequestLimit;
				new List<RpcResponse>();
				List<RpcResponse> list;
				if (batchRequestLimit > 0 && result.RequestCount > batchRequestLimit)
				{
					string text = $"Request count exceeded batch request limit ({batchRequestLimit}).";
					list = new List<RpcResponse>
				{
					new RpcResponse(null, new RpcError(RpcErrorCode.InvalidRequest, text))
				};
					logger.LogError(text + " Returning error response.");
				}
				else
				{
					list = ((!result.Requests.Any()) ? new List<RpcResponse>() : (await invoker.InvokeBatchRequestAsync(result.Requests, routeContext, requestPath)));
					foreach (var error in result.Errors)
					{
						RpcId item = error.Id;
						RpcError item2 = error.Error;
						if (item == default(RpcId))
						{
							logger.ResponseFailedWithNoId(item2.Code, item2.Message);
						}
						else
						{
							list.Add(new RpcResponse(item, item2));
						}
					}
				}
				if (list == null || !list.Any())
				{
					logger.NoResponses();
					return false;
				}
				logger.Responses(list.Count);
				if (!result.IsBulkRequest)
				{
					await responseSerializer.SerializeAsync(list.Single(), responseBody);
				}
				else
				{
					await responseSerializer.SerializeBulkAsync(list, responseBody);
				}
			}
			catch (RpcException ex)
			{
				logger.LogException(ex, "Error occurred when proccessing Rpc request. Sending Rpc error response");
				RpcResponse response = new RpcResponse(null, ex.ToRpcError(serverConfig.Value.ShowServerExceptions));
				await responseSerializer.SerializeAsync(response, responseBody);
			}
			return true;
		}
	}
}