using Serilog;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using LCU.Library.Internal.ApiResponse.Models;
using LCU.Library.Internal.DispatcherModels.Entities;
using LCU.Library.Internal.DispatcherModels.Models;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Api.Internal.DispatcherSharedLib.Utilities;
using LCU.Api.Internal.DispatcherSharedLib.Configurations;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using System.Net.Http;
using System.Threading.Tasks;
namespace LCU.Api.Internal.DispatcherSharedLib.BuilderServices;

public class RequestBuilderService : IRequestBuilderService
{
    private readonly IPostRequest _postRequest;
    private readonly IActionBuilderService _actionBuilderService;
    private readonly DispatcherRequestBuilderConfiguration _requestBuilderConfiguration;
    private Job JobRequest;

    public RequestBuilderService(IPostRequest postRequest,
                                 IActionBuilderService actionBuilderService,
                                 DispatcherRequestBuilderConfiguration requestBuilderConfiguration)
    {
        _postRequest = postRequest;
        _actionBuilderService = actionBuilderService;
        _requestBuilderConfiguration = requestBuilderConfiguration;
    }

    public void ClearJob()
    {
        JobRequest = null;
    }

    public void CreateJob(JobDetails jobDetails)
    {
        ClearJob();

        JobRequest = new Job
        {
            JobId = jobDetails.JobId,
            RequestingApplication = jobDetails.RequestingApplication,
            Name = jobDetails.Name,
            Description = jobDetails.Description,
            CreatedBy = jobDetails.CreatedBy,
            CreatedAt = jobDetails.CreatedAt,
            ModifiedBy = jobDetails.ModifiedBy,
            ModifiedDate = jobDetails.ModifiedDate,
            CronSchedule = jobDetails.CronSchedule,
            NextRunTime = jobDetails.NextRunTime,
            SkipHolidays = jobDetails.SkipHolidays,
            JobErrorRecipients = CreateJobErrorRecipients(jobDetails),
            WorkItems = new List<WorkItem>(),
            JobTags = jobDetails.JobTags,
            JobStatus = jobDetails.JobStatus
        };

        CronHelpers.SetNextScheduledRunTime(ref JobRequest);
    }

    public List<JobErrorRecipient> CreateJobErrorRecipients(JobDetails jobDetails)
    {
        var jobErrorRecipients = new List<JobErrorRecipient>();

        foreach (var recipient in jobDetails.ErrorRecipients)
        {
            if (string.IsNullOrEmpty(recipient))
            {
                continue;
            }

            var newJobErrorRecipient = new JobErrorRecipient()
            {
                JobId = jobDetails.JobId,
                Recipient = recipient
            };
            jobErrorRecipients.Add(newJobErrorRecipient);
        }

        return jobErrorRecipients;
    }

    public async Task<bool> SendDispatcherRequest(ReturnResponse returnResponse = null)
    {
        try
        {
            if (JobRequest == null)
            {
                Log.Error("Cannot send null Job.");
                return false;
            }

            JobRequest.ReturnResponse = returnResponse;
            var serializedJobRequest = JsonConvert.SerializeObject(JobRequest); 

            var result = await _postRequest.AsyncWithNewtonSerializedNoThrow(new Uri(_requestBuilderConfiguration.Url), serializedJobRequest);

            if (result.IsSuccessStatusCode)
            {
                ClearJob();
            }

            return result.IsSuccessStatusCode;
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failure to send job request");
            return false;
        }
    }

    public Type GetDispatcherTypeByString(string type)
    {
        var actionBuilder = _actionBuilderService.BuildAction(type);
        return actionBuilder.GetActionType();
    }

    public void AddWorkItem(object request, WorkItemDetails workItemDetails, ActionType actionType)
    {
        var actionBuilder = _actionBuilderService.BuildAction(actionType);
        AddWorkItemToJob(request, workItemDetails, actionBuilder);
    }

    public void AddWorkItem(object request, WorkItemDetails workItemDetails, string actionType)
    {
        var actionBuilder = _actionBuilderService.BuildAction(actionType);
        AddWorkItemToJob(request, workItemDetails, actionBuilder);
    }

    private void AddWorkItemToJob(object request, WorkItemDetails workItemDetails, IActionService actionBuilder)
    {
        try
        {
            var newWorkitem = actionBuilder.CreateNewWorkitem(request, workItemDetails);
            if (JobRequest == null)
            {
                Log.Error("Cannot add workitem to null Job.");
                throw new InvalidOperationException("Cannot add workitem to null Job.");
            }

            JobRequest.WorkItems.Add(newWorkitem);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Error creating WorkItem.");
            ClearJob();
            throw;
        }
    }
}