using Dpz.Core.EnumLibrary;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Service.ObjectStorage.Services;
using Dpz.Core.Service.RepositoryService;
using Hangfire;

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;

    public TaskListHandleActivator(
        IObjectStorageOperation objectStorageService,
        IWaitExecutionService waitExecutionService,
        IConfiguration configuration,
        ILogger<TaskListHandleActivator> logger)
    {
        _objectStorageService = objectStorageService;
        _waitExecutionService = waitExecutionService;
        _logger = logger;

        _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);
        // }

        await Parallel.ForEachAsync(taskList, async (item, _) =>
        {
            if (item.Category == ExecuteCategory.Delete)
            {
                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;
        }
    }
}