using Fake.Application;
using Fake.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using Oms.Application.Dtos.Orders;
using Oms.Application.Messaging;
using Oms.Domain.OrdersAggregate.Consts;

namespace Oms.Application.Services.Orders.Batch;

/// <summary>
/// 创建类批量操作（Excel 导入行、小包批量创建）执行器。
/// </summary>
public sealed class OrderBatchCreateActionHandler(IServiceScopeFactory scopeFactory) : IScopedDependency
{
    public async Task<OrderBatchActionExecuteResult> ExecuteImportRowAsync(
        OrderBatchJobMessage message,
        CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(message.PayloadJson))
        {
            return OrderBatchActionExecuteResult.BusinessFail("导入行消息体为空");
        }

        var payload = JsonConvert.DeserializeObject<OrderBatchImportRowPayload>(message.PayloadJson);
        if (payload == null)
        {
            return OrderBatchActionExecuteResult.BusinessFail("导入行消息体无效");
        }

        try
        {
            using var scope = scopeFactory.CreateScope();
            var orderService = scope.ServiceProvider.GetRequiredService<OrderService>();
            var output = await orderService.ImportRowForBatchAsync(payload, message.OperatorUserId, cancellationToken);
            return OrderBatchActionExecuteResult.Ok(
                createdOrderId: output.OrderId,
                serviceNo: output.ServiceNo,
                clientNo: output.ClientNo,
                trackNo: output.TrackNo,
                labelUrl: output.LabelUrl);
        }
        catch (BusinessException ex)
        {
            using var scope = scopeFactory.CreateScope();
            var orderService = scope.ServiceProvider.GetRequiredService<OrderService>();
            var createdOrderId = await orderService.TryResolveImportOrderIdAsync(payload, cancellationToken);
            return OrderBatchActionExecuteResult.BusinessFail(ex.Message, createdOrderId);
        }
        catch (Exception ex)
        {
            return OrderBatchActionExecuteResult.SystemFail(ex.Message);
        }
    }

    public async Task<OrderBatchActionExecuteResult> ExecuteParcelCreateAsync(
        OrderBatchJobMessage message,
        CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(message.PayloadJson))
        {
            return OrderBatchActionExecuteResult.BusinessFail("小包创建消息体为空");
        }

        var input = JsonConvert.DeserializeObject<OrderParcelCreateInput>(message.PayloadJson);
        if (input == null)
        {
            return OrderBatchActionExecuteResult.BusinessFail("小包创建消息体无效");
        }

        try
        {
            using var scope = scopeFactory.CreateScope();
            var orderService = scope.ServiceProvider.GetRequiredService<OrderService>();
            var output = await orderService.CreateParcelForBatchAsync(
                input,
                message.OperatorUserId,
                cancellationToken);

            return OrderBatchActionExecuteResult.Ok(
                createdOrderId: null,
                serviceNo: output.ServiceNo,
                clientNo: output.ClientNo,
                trackNo: output.TrackNo,
                labelUrl: output.LabelUrl);
        }
        catch (BusinessException ex)
        {
            return OrderBatchActionExecuteResult.BusinessFail(ex.Message);
        }
        catch (Exception ex)
        {
            return OrderBatchActionExecuteResult.SystemFail(ex.Message);
        }
    }
}