using ECMJobRunner.Application.Common.Constants;
using ECMJobRunner.Application.Common.Exceptions;
using ECMJobRunner.Application.Common.Options;
using ECMJobRunner.Application.DEXJob.Commands;
using MediatR;
using Microsoft.Extensions.Options;
using ReC.Client;
using ReC.Client.Api;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace ECMJobRunner.Application.Behaviors
{
    /// <summary>
    /// Pipeline behavior that sends ReC HTTP request for DEX jobs
    /// Runs after CheckQueryExecutionBehavior and invokes ReC API
    /// </summary>
    /// <typeparam name="TRequest">The request type</typeparam>
    /// <typeparam name="TResponse">The response type</typeparam>
    public class ReCRequestExecutionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
        where TRequest : notnull
    {
        private readonly ReCClient _reCClient;
        private readonly DexJobOptions _options;

        /// <summary>
        /// Initializes a new instance of ReCRequestExecutionBehavior
        /// </summary>
        /// <param name="reCClient">ReC client for HTTP requests</param>
        /// <param name="options">DEX job configuration options</param>
        public ReCRequestExecutionBehavior(ReCClient reCClient, IOptions<DexJobOptions> options)
        {
            _reCClient = reCClient;
            _options = options.Value;
        }

        /// <summary>
        /// Handles the pipeline behavior
        /// Sends ReC request if request is TriggeringDEXJobCommand
        /// </summary>
#if NET48
        public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
#else
        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
#endif
        {
            if (request is TriggeringDEXJobCommand command)
            {
                await SendReCRequestAsync(command, cancellationToken);
            }

            return await next();
        }

        private async Task SendReCRequestAsync(TriggeringDEXJobCommand command, CancellationToken cancel)
        {
            try
            {
                await _reCClient.RecActions.InvokeAsync(command.Job.ProfileId, new InvokeReferences()
                {
                    BatchId = command.BatchId,
                }, cancel);
            }
            catch (Exception ex)
            {
                if (_options.Error.ReCRequest.OnSending == ErrorAction.Stop)
                {
                    throw new JobHttpException(
                        jobName: "Triggering DEX",
                        processName: "ReC Http Request",
                        batchId: command.BatchId,
                        reason: null,
                        clientLibrary: "ReC.Client",
                        clientMethod: "RecActions.InvokeAsync",
                        innerException: ex);
                }
            }
        }
    }
}