using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.Library.Internal.IncentiveApiModels.Requests;
using LCU.Library.Internal.IncentiveApiModels.Results;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using Microsoft.Extensions.DependencyInjection;
using LCU.API.Internal.Operations.IncentiveApi.Services.NightlyIncentiveProcesses;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.Library.Internal.IncentiveApiModels.Common;
using LCU.Library.Internal.IncentiveApiModels.Entities;

namespace LCU.API.Internal.Operations.IncentiveApi.Services.NightlyDecisionServices;

public class LICActivityDecisionService : NightlyIncentiveProcessesService, INightlyIncentiveProcessesService
{
    private readonly IServiceScopeFactory _serviceScopeFactory;
    private readonly ProcessResult _processResult;
    private const int PageItemLimit = 1000;

    public LICActivityDecisionService(ServicesFactoryConfiguration servicesFactoryConfiguration,
                                      IServiceScopeFactory serviceScopeFactory)
                                      : base(servicesFactoryConfiguration)
    {
        _serviceScopeFactory = serviceScopeFactory;
        _processResult = new ProcessResult();
    }

    public async Task<ProcessResult> RunProductDecisionProcess(NightlyIncentiveProcessRequest request)
    {
        try
        {
            var result = await UpdateAndDecideActivities();
            var message = $"{result.Count()} LIC activities were updated";
            Log.Information(message);
            _processResult.MessageStack.Add(message);
        }
        catch (Exception exception)
        {
            var message = $"There was an issue with the LIC Product Update process. Exception Message: {exception.Message}.";
            _processResult.MessageStack.Add(message);
            _processResult.Success = false;
        }
        return _processResult;
    }

    public async Task<IReadOnlyCollection<ActivityStateChange>> UpdateAndDecideActivities()
    {
        using var scope = _serviceScopeFactory.CreateScope();
        var changes = new List<ActivityStateChange>();
        var allItemsProcessed = false;
        var page = 0;
        var processedItemCount = 0;

        while (!allItemsProcessed)
        {
            try
            {
                var activityPage = await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IActivityService>().ListByFilterAsync(new ActivityFilter
                {
                    Limit = PageItemLimit,
                    Page = page += 1,
                    State = new List<ActivityState> { ActivityState.ManualReview },
                    Product = new List<Product> { Product.LIC }
                }));

                if (activityPage?.Items == null)
                {
                    return new List<ActivityStateChange>();
                }

                var activities = activityPage.Items.ToList();
                var updatedActivities = await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IActivityDetailService>().TryUpdateLicReferralStationDetail(activities));

                changes.AddRange(await Task.Run(async () => await scope.ServiceProvider.GetRequiredService<IActivityDecisionService>().AutoDecideActivities(updatedActivities)));
                processedItemCount += activities.Count;
                allItemsProcessed = processedItemCount == activityPage.Total;
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failed to process all LIC Referral updates");
                allItemsProcessed = true;
            }
        }

        return changes;
    }
}