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 Microsoft.Extensions.Options;

namespace Dpz.Core.Web.Jobs.Hangfire;

public class TaskListHandleActivator : JobActivator
{
    private readonly IObjectStorageOperation _objectStorageService;
    private readonly IWaitExecutionService _waitExecutionService;
    private readonly ILogger<TaskListHandleActivator> _logger;
    private readonly string _host;
    private readonly CrawlerOptions _crawlerOptions;

    public TaskListHandleActivator(
        IObjectStorageOperation objectStorageService,
        IWaitExecutionService waitExecutionService,
        IConfiguration configuration,
        ILogger<TaskListHandleActivator> logger,
        IOptions<CrawlerOptions> crawlerOptions
    )
    {
        _objectStorageService = objectStorageService;
        _waitExecutionService = waitExecutionService;
        _logger = logger;
        _crawlerOptions = crawlerOptions.Value;

        _host =
            configuration.GetSection("upyun")["Host"] ?? throw new Exception("upyun Host is null");
    }

    [ProlongExpirationTime]
    public async Task HandleAsync()
    {
        var taskList = await _waitExecutionService.GetNotExecuteTaskAsync();
        // foreach (var item in taskList.Where(x => x.Category == ExecuteCategory.Delete))
        // {
        //     await DeleteAsync(item);
        // }

        // 限制并发度
        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;
        }
    }
}