using Dpz.Core.EnumLibrary;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Service.ObjectStorage.Services;
using Dpz.Core.Service.RepositoryService;
using Dpz.Core.Web.Jobs.Configuration;
using Hangfire;
using JetBrains.Annotations;
using Microsoft.Extensions.Options;

namespace Dpz.Core.Web.Jobs.Hangfire;

[UsedImplicitly]
public class TaskListHandleActivator(
    IObjectStorageOperation objectStorageService,
    IWaitExecutionService waitExecutionService,
    IConfiguration configuration,
    ILogger<TaskListHandleActivator> logger,
    IOptions<CrawlerOptions> crawlerOptions
) : JobActivator
{
    private readonly string _host =
        configuration.GetSection("upyun")["Host"] ?? throw new Exception("upyun Host is null");
    private readonly CrawlerOptions _crawlerOptions = crawlerOptions.Value;

    [ProlongExpirationTime]
    public async Task HandleAsync()
    {
        var taskList = await waitExecutionService.GetNotExecuteTaskAsync();

        // 限制并发度
        var parallelOptions = new ParallelOptions
        {
            MaxDegreeOfParallelism = _crawlerOptions.MaxDegreeOfParallelism,
            CancellationToken = CancellationToken.None,
        };

        await Parallel.ForEachAsync(
            taskList,
            parallelOptions,
            async (item, cancellationToken) =>
            {
                if (item.Category == ExecuteCategory.Delete)
                {
                    await Task.Delay(
                        TimeSpan.FromMilliseconds(_crawlerOptions.RequestDelayMs),
                        cancellationToken
                    );
                    await DeleteAsync(item);
                }
            }
        );

        await waitExecutionService.ClearExpiredAsync();
    }

    private async Task DeleteAsync(VmWaitExecution task)
    {
        switch (task.Scheme)
        {
            case ExecuteScheme.DeleteUpyun:
                try
                {
                    if (
                        !string.IsNullOrEmpty(task.Relation)
                        && task.Relation.StartsWith(
                            _host,
                            StringComparison.CurrentCultureIgnoreCase
                        )
                    )
                    {
                        var relation = task.Relation[_host.Length..];
                        await objectStorageService.DeleteAsync(relation);
                    }
                }
                catch (Exception e)
                {
                    logger.LogError(e, "delete fail");
                    await waitExecutionService.UpdateStatusAsync(
                        task.Id,
                        ExecuteStatus.ExecuteFail
                    );
                }

                await waitExecutionService.UpdateStatusAsync(
                    task.Id,
                    ExecuteStatus.ExecuteComplete
                );
                break;
            case ExecuteScheme.None:
            default:
                logger.LogInformation("execute scheme:{ExecuteScheme}", task.Scheme.ToString());
                break;
        }
    }
}