using System.Collections.Generic;
using System.Transactions;
using AutoMapper;
using Entity.Api.Req;
using Entity.Api.Resp;
using Entity.Constant;
using Entity.DbModel.Station;
using Entity.Dto;
using HybirdFrameworkCore.Entity;
using log4net;
using Magicodes.ExporterAndImporter.Excel;
using Microsoft.AspNetCore.Mvc;
using Repository.Station;
using Service.Init;
using Service.Station;
using Swapping.Business.Common;

namespace WebStarter.Controllers;

/// <summary>
/// 换电订单
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class SwapOrderController : ControllerBase
{
    private static readonly ILog Log = LogManager.GetLogger(typeof(SwapOrderController));
    private readonly SwapOrderService swapOrderService;
    private readonly SwapOrderBatteryService swapOrderBatteryService;
    private readonly SwapOrderStepService swapOrderStepService;
    private readonly SwapOrderReportCloudRepository swapOrderReportCloudRepository;
    private readonly VehicleService vehicleService;
    private readonly BaseVehicleRepository _baseVehicleRepository;

    public SwapOrderController(SwapOrderService swapOrderService, SwapOrderBatteryService swapOrderBatteryService,
        SwapOrderStepService swapOrderStepService, SwapOrderReportCloudRepository swapOrderReportCloudRepository,
        BaseVehicleRepository baseVehicleRepository
    )
    {
        this.swapOrderService = swapOrderService;
        this.swapOrderBatteryService = swapOrderBatteryService;
        this.swapOrderStepService = swapOrderStepService;
        this.swapOrderReportCloudRepository = swapOrderReportCloudRepository;
        _baseVehicleRepository = baseVehicleRepository;
    }

    /// <summary>
    /// 查询分页数据
    /// </summary>
    /// <returns></returns>
    [HttpPost("QueryPage")]
    public async Task<Result<PageResult<SwapOrderResp>>> QueryPage([FromBody] QuerySwapOrderPageReq req)
    {
        Log.Info($"SwapOrderController QueryPage req={req}");

        if (!string.IsNullOrEmpty(req.DownBatteryNo) || !string.IsNullOrEmpty(req.UpBatteryNo))
        {
            var result = BatteryCodeList(req);
            return Result<PageResult<SwapOrderResp>>.Success(result);
        }
        
        Log.Info($"查询换电订单 SwapOrderController start QueryPage  swapOrderService.QuerySwapOrder req={req}");
        var swapOrderResp = swapOrderService.QuerySwapOrder(req);
        Log.Info($"查询换电订单 SwapOrderController end QueryPage  swapOrderService.QuerySwapOrder req={req}");
        PackageSwapOrder(swapOrderResp);

        List<SwapOrderResp>? list = swapOrderResp.Rows;

        if (list!=null)
        {
            foreach (var swapOrder in list)
            {
                if (swapOrder.ServiceTotalFee.HasValue && swapOrder.ServiceTotalFee.Value != 0)
                {
                    swapOrder.ServiceTotalFee = swapOrder.ServiceTotalFee / 100;
                }
    
                if (swapOrder.ElectricityTotalFee.HasValue && swapOrder.ElectricityTotalFee.Value != 0)
                {
                    swapOrder.ElectricityTotalFee = swapOrder.ElectricityTotalFee / 100;
                }

                if (swapOrder.AppendTotalFee.HasValue && swapOrder.AppendTotalFee.Value != 0)
                {
                    swapOrder.AppendTotalFee = swapOrder.AppendTotalFee / 100;
                }

                if (swapOrder.TotalFee.HasValue && swapOrder.TotalFee.Value != 0)
                {
                    swapOrder.TotalFee = swapOrder.TotalFee / 100;
                }
            } 
        }
        
        
        List<string> vehicleNoList = list?.Select(resp => resp.VehicleNo).ToList() ?? new List<string>();
        // 查询车辆的部门
        List<BaseVehicle> vehicleList = await _baseVehicleRepository
            .Queryable()
            .In(vehicle => vehicle.VehicleNo, vehicleNoList)
            .ToListAsync();

        // 给换电订单赋值车的公司和部门
        foreach (var swapOrder in list)
        {
            if (swapOrder.SwapResult == 2)
            {
                swapOrder.ManualStep = swapOrder.Remark;
            }
            
            var matchingVehicle = vehicleList.FirstOrDefault(v => v.VehicleNo == swapOrder.VehicleNo);

            if (matchingVehicle != null)
            {
                swapOrder.Company = matchingVehicle.Company;
                swapOrder.Departments = matchingVehicle.Departments;
            }

            if (swapOrder.BatteryList != null && swapOrder.BatteryList.Count > 0)
            {
                SwapOrderBatteryResp swapOrderBatteryResp = swapOrder.BatteryList[0];
                swapOrder.UpBatteryBinNo = swapOrderBatteryResp.UpBatteryBinNo;
                swapOrder.UpBatteryNo = swapOrderBatteryResp.UpBatteryNo;
                swapOrder.UpBatterySoc = swapOrderBatteryResp.UpBatterySoc;
                swapOrder.DownBatteryBinNo = swapOrderBatteryResp.DownBatteryBinNo;
                swapOrder.UpBatteryNo = swapOrderBatteryResp.UpBatteryNo;
                swapOrder.DownBatteryNo = swapOrderBatteryResp.DownBatteryNo;
                swapOrder.DownBatterySoc = swapOrderBatteryResp.DownBatterySoc;
                try
                {
                    swapOrder.DownBatteryElectricQuantity = ((double)swapOrder.DownBatterySoc * 3.75).ToString();
                    swapOrder.UpBatteryElectricQuantity = ((double)swapOrder.UpBatterySoc * 3.75).ToString();
                    double ElectricQuantity = ((float)(swapOrder.UpBatterySoc - swapOrder.DownBatterySoc)) * 3.75;
                    swapOrder.ElectricQuantity = ElectricQuantity.ToString();
                }
                catch (Exception e)
                {
                }
            }

            if (swapOrder.StepList != null && swapOrder.StepList.Count > 0)
            {
                List<SwapOrderStepResp> swapOrderStepResps = swapOrder.StepList;

                swapOrder.ManualStep = string.Join(",",
                    swapOrderStepResps
                        .Where(step => step.StepType == (int)SwapConstant.StepType.MANUAL)
                        .Select(step => step.StepDesc)
                        .ToList());
            }
        }

        return Result<PageResult<SwapOrderResp>>.Success(swapOrderResp);
    }

    /// <summary>
    /// app查询换电订单
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    [HttpPost("AppSwapOrder")]
    public async Task<Result<PageResult<SwapOrderResp>>> AppSwapOrder([FromBody] QuerySwapOrderPageReq req)
    {
        Log.Info($"SwapOrderController QueryPage req={req}");

        Log.Info($"查询换电订单 SwapOrderController start QueryPage  swapOrderService.QuerySwapOrder req={req}");
        var swapOrderResp = swapOrderService.AppQuerySwapOrder(req);
        Log.Info($"查询换电订单 SwapOrderController end QueryPage  swapOrderService.QuerySwapOrder req={req}");

        PackageSwapOrder(swapOrderResp);
        List<SwapOrderResp>? list = swapOrderResp.Rows;

        if (list!=null)
        {
            foreach (var swapOrder in list)
            {
                if (swapOrder.ServiceTotalFee.HasValue && swapOrder.ServiceTotalFee.Value != 0)
                {
                    swapOrder.ServiceTotalFee = swapOrder.ServiceTotalFee / 100;
                }
    
                if (swapOrder.ElectricityTotalFee.HasValue && swapOrder.ElectricityTotalFee.Value != 0)
                {
                    swapOrder.ElectricityTotalFee = swapOrder.ElectricityTotalFee / 100;
                }

                if (swapOrder.AppendTotalFee.HasValue && swapOrder.AppendTotalFee.Value != 0)
                {
                    swapOrder.AppendTotalFee = swapOrder.AppendTotalFee / 100;
                }

                if (swapOrder.TotalFee.HasValue && swapOrder.TotalFee.Value != 0)
                {
                    swapOrder.TotalFee = swapOrder.TotalFee / 100;
                }
            } 
        }
        return Result<PageResult<SwapOrderResp>>.Success(swapOrderResp);
    }

    private void PackageSwapOrder(PageResult<SwapOrderResp> swapOrderResp)
    {
        //获取所有订单号
        var orderSns = swapOrderResp.Rows.Select(row => row.Sn).ToList();
        //查询上报云平台次数
        //Dictionary<string, int?> queryReportCloudNumBySn = swapOrderService.QueryReportCloudNumBySn(orderSns);

        ////查询订单电池数据
        List<SwapOrderBattery> batteryList =
            swapOrderBatteryService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));
        //映射
        var config =
            new MapperConfiguration(cfg => cfg.CreateMap<SwapOrderBatteryResp, SwapOrderBattery>().ReverseMap());
        IMapper mapper = config.CreateMapper();

        List<SwapOrderBatteryResp> swapOrderBattery = mapper.Map<List<SwapOrderBatteryResp>>(batteryList);

        List<SwapOrderReportCloud> swapOrderReportClouds =
            swapOrderReportCloudRepository.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));


        //将电池数据添加到换电订单数据中
        foreach (var row in swapOrderResp.Rows)
        {
            row.BatteryList = swapOrderBattery.Where(battery => battery.SwapOrderSn == row.Sn).ToList();


            var matchingReport = swapOrderReportClouds.FirstOrDefault(r => r.SwapOrderSn == row.Sn);
            if (matchingReport != null)
            {
                foreach (var battery in row.BatteryList)
                {
                    battery.Vtm = matchingReport.Vtm;
                }
            }
        }

        //查询订单步序数据
        var stepList = swapOrderStepService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));
        stepList = stepList.OrderBy(s => s.Sort).ToList();

        //映射
        var config2 = new MapperConfiguration(cfg => cfg.CreateMap<SwapOrderStep, SwapOrderStepResp>().ReverseMap());
        IMapper mapper2 = config2.CreateMapper();
        List<SwapOrderStepResp> swapOrderStep = mapper2.Map<List<SwapOrderStepResp>>(stepList);


        //将步序数据添加到换电订单数据中
        for (int i = 0; i < swapOrderResp.Rows.Count; i++)
        {
            swapOrderResp.Rows[i].StepList = new List<SwapOrderStepResp>();
            var swapOrderStepResps = swapOrderStep.Where(step => step.SwapOrderSn == swapOrderResp.Rows[i].Sn).ToList();
            swapOrderResp.Rows[i].StepList
                .AddRange(swapOrderStepResps);
            
            swapOrderResp.Rows[i].ManualStep = String.Join(",",
                swapOrderStepResps.Where(i => i.StepType == (int)SwapConstant.StepType.MANUAL).Select(i => i.StepDesc)
                    .ToList());
        }
    }

    private PageResult<SwapOrderResp> BatteryCodeList(QuerySwapOrderPageReq req)
    {
        PageResult<SwapOrderBatteryResp> batteryCodeList = swapOrderBatteryService.QuerySwapOrderBatteryList(req);

        var batteryOrderSn = batteryCodeList.Rows.Select(row => row.SwapOrderSn).ToList();


        List<SwapOrder> swapOrderRespList = swapOrderService.QueryListByClause(u => batteryOrderSn.Contains(u.Sn));
        //获取所有订单号
        var orderSns = swapOrderRespList.Select(row => row.Sn).ToList();


        ////查询订单电池数据
        List<SwapOrderBattery> batteryList =
            swapOrderBatteryService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));

        var config = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap<SwapOrderResp, SwapOrder>().ReverseMap();
            cfg.CreateMap<SwapOrderBatteryResp, SwapOrderBattery>().ReverseMap();
        });
        //映射
        IMapper mapper = config.CreateMapper();

        List<SwapOrderBatteryResp> swapOrderBattery = mapper.Map<List<SwapOrderBatteryResp>>(batteryList);

        List<SwapOrderResp> swapOrderResp = mapper.Map<List<SwapOrderResp>>(swapOrderRespList);

        List<SwapOrderReportCloud> swapOrderReportClouds =
            swapOrderReportCloudRepository.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));


        //将电池数据添加到换电订单数据中
        foreach (var row in swapOrderResp)
        {
            row.BatteryList = swapOrderBattery.Where(battery => battery.SwapOrderSn == row.Sn).ToList();

            var matchingReport = swapOrderReportClouds.FirstOrDefault(r => r.SwapOrderSn == row.Sn);
            if (matchingReport != null)
            {
                foreach (var battery in row.BatteryList)
                {
                    battery.Vtm = matchingReport.Vtm;
                }
            }
        }

        //查询订单步序数据
        var stepList = swapOrderStepService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));
        stepList = stepList.OrderBy(s => s.Sort).ToList();

        //映射
        var config2 = new MapperConfiguration(cfg => cfg.CreateMap<SwapOrderStep, SwapOrderStepResp>().ReverseMap());
        IMapper mapper2 = config2.CreateMapper();
        List<SwapOrderStepResp> swapOrderStep = mapper2.Map<List<SwapOrderStepResp>>(stepList);


        //将步序数据添加到换电订单数据中
        for (int i = 0; i < swapOrderResp.Count; i++)
        {
            swapOrderResp[i].StepList = new List<SwapOrderStepResp>();
            swapOrderResp[i].StepList
                .AddRange(swapOrderStep.Where(step => step.SwapOrderSn == swapOrderResp[i].Sn).ToList());
        }

        PageResult<SwapOrderResp> result = new PageResult<SwapOrderResp>()
        {
            PageNum = req.PageNum,
            PageSize = req.PageSize,
            ToTal = batteryCodeList.ToTal,
            Rows = swapOrderResp
        };
        return result;
    }

    /// <summary>
    /// 新增
    /// </summary>
    /// <returns></returns>
    [HttpPost("Add")]
    public async Task<Result<bool>> Add([FromBody] AddSwapOrderReq req)
    {
        using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
        {
            // 映射数据
            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap<SwapOrder, AddSwapOrderReq>().ReverseMap();
                cfg.CreateMap<SwapOrderBattery, SwapOrderBatteryReq>().ReverseMap();
            });

            IMapper mapper = config.CreateMapper();

            // 转换换电订单
            SwapOrder swapOrder = mapper.Map<SwapOrder>(req);
            swapOrder.Sn = SwapOrderNoGenerator.GenerateOrderNo(StaticStationInfo.StationNo);
            swapOrder.CloudReportStatus = 0;
            SwapOrder order = await swapOrderService.InsertAsync(swapOrder);

            // 绑定电池
            var swapOrderBattery = new SwapOrderBattery
            {
                SwapOrderSn = swapOrder.Sn,
                UpBatterySoc = req.UpBatterySoc,
                UpNominalEnergy = req.UpNominalEnergy,
                DownBatterySoc = req.DownBatterySoc,
                DownNominalEnergy = req.DownNominalEnergy,
                SettleAnAccountFlag = 0
            };
            SwapOrderBattery swapOrderBatteryResult  = await swapOrderBatteryService.InsertAsync(swapOrderBattery);

            if (order != null && swapOrderBatteryResult !=null)
            {
                // 提交
                transactionScope.Complete();
                return Result<bool>.Success(true, "新增成功");
            }

            return Result<bool>.Fail(false, "新增失败");
        }
    }

    /// <summary>
    /// 修改换电订单
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    [HttpPost("Modify")]
    public async Task<Result<bool>> Modify([FromBody] ModifySwapOrderReq req)
    {
        using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
        {
            var existingOrder = await swapOrderService.QueryByClauseAsync(u => u.Sn == req.Sn && u.Id != req.Id);
            if (existingOrder != null)
            {
                return Result<bool>.Fail("订单号已存在");
            }

            // 映射数据
            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap<SwapOrder, ModifySwapOrderReq>().ReverseMap();
                cfg.CreateMap<SwapOrderBattery, SwapOrderBatteryReq>().ReverseMap();
            });

            IMapper mapper = config.CreateMapper();
            SwapOrder swapOrder = mapper.Map<SwapOrder>(req);

            bool orderUpdated = swapOrderService.Update(swapOrder);
            bool batteriesUpdated = true;

            if (req.batteryList.Any())
            {
                // 绑定订单
                List<SwapOrderBattery> swapOrderBatteries = mapper.Map<List<SwapOrderBattery>>(req.batteryList);
                foreach (var swapOrderBattery in swapOrderBatteries)
                {
                    swapOrderBattery.SwapOrderSn = swapOrder.Sn;
                }

                // 更新电池订单
                batteriesUpdated = await swapOrderBatteryService.UpdateAsync(swapOrderBatteries);
            }

            if (orderUpdated && batteriesUpdated)
            {
                // 提交
                transactionScope.Complete();
                return Result<bool>.Success(true, "更改成功");
            }

            return Result<bool>.Fail("更改失败");
        }
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="ids">ids id列表</param>
    /// <returns></returns>
    [HttpPost("DeleteByIds")]
    public async Task<Result<bool>> DeleteByIds([FromBody] List<long> ids)
    {
        if (swapOrderService.DeleteByIds(ids))
        {
            return Result<bool>.Success(true, "删除成功");
        }
        else
        {
            return Result<bool>.Fail("删除失败");
        }
    }


    /// <summary>
    /// 换电订单导出
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    [HttpPost]
    [Route("export")]
    public async Task<IActionResult> ExportSwapOrder([FromBody] QuerySwapOrderPageReq req)
    {
        // 获取请求头中的语言信息
        var language = Request.Headers["Accept-Language"].ToString().ToLower();

        List<SwapOrder> orderList = await swapOrderService.QuerySwapOrderListAsync(req);
        foreach (var swapOrder in orderList)
        {
            if (swapOrder.ServiceTotalFee.HasValue && swapOrder.ServiceTotalFee.Value != 0)
            {
                swapOrder.ServiceTotalFee = swapOrder.ServiceTotalFee / 100;
            }
    
            if (swapOrder.ElectricityTotalFee.HasValue && swapOrder.ElectricityTotalFee.Value != 0)
            {
                swapOrder.ElectricityTotalFee = swapOrder.ElectricityTotalFee / 100;
            }

            if (swapOrder.AppendTotalFee.HasValue && swapOrder.AppendTotalFee.Value != 0)
            {
                swapOrder.AppendTotalFee = swapOrder.AppendTotalFee / 100;
            }

            if (swapOrder.TotalFee.HasValue && swapOrder.TotalFee.Value != 0)
            {
                swapOrder.TotalFee = swapOrder.TotalFee / 100;
            }
        }
        
        // 获取所有订单号
        var orderSns = orderList.Select(row => row.Sn).ToList();

        // 查询订单电池数据
        List<SwapOrderBattery> batteryList =
            swapOrderBatteryService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));


        // 根据语言设置不同的映射配置
        var config = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap<SwapOrderBatteryResp, SwapOrderBattery>().ReverseMap();
            cfg.CreateMap<SwapOrderDto, SwapOrderResp>().ReverseMap();
            cfg.CreateMap<SwapOrderResp, SwapOrder>().ReverseMap();
            cfg.CreateMap<SwapOrderDto2, SwapOrderResp>().ReverseMap();
            cfg.CreateMap<SwapLoseOrderDto, SwapOrderResp>().ReverseMap();
            cfg.CreateMap<SwapLoseOrderDto2, SwapOrderResp>().ReverseMap();
            cfg.CreateMap<SwapOrderStep, SwapOrderStepResp>().ReverseMap();
        });

        IMapper mapper = config.CreateMapper();

        List<SwapOrderBatteryResp> swapOrderBattery = mapper.Map<List<SwapOrderBatteryResp>>(batteryList);
        // 换电订单
        List<SwapOrderResp> swapOrderResp = mapper.Map<List<SwapOrderResp>>(orderList);
        foreach (var orderResp in swapOrderResp)
        {
            if (orderResp.ServiceTotalFee.HasValue)
            {
                orderResp.ServiceTotalFee = Math.Round(orderResp.ServiceTotalFee.Value / 100m, 2);
            }
            if (orderResp.ElectricityTotalFee.HasValue)
            {
                orderResp.ElectricityTotalFee = Math.Round(orderResp.ElectricityTotalFee.Value / 100m, 2);
            }
            if (orderResp.AppendTotalFee.HasValue)
            {
                orderResp.AppendTotalFee = Math.Round(orderResp.AppendTotalFee.Value / 100m, 2);
            }
            if (orderResp.TotalFee.HasValue)
            {
                orderResp.TotalFee = Math.Round(orderResp.TotalFee.Value / 100m, 2);
            }
        }

        List<string> vehicleNoList = swapOrderResp.Select(resp => resp.VehicleNo).ToList() ?? new List<string>();
        // 查询车辆的部门
        List<BaseVehicle> vehicleList = await _baseVehicleRepository
            .Queryable()
            .In(vehicle => vehicle.VehicleNo, vehicleNoList)
            .ToListAsync();
        
        var stepList = swapOrderStepService.QueryListByClause(u => orderSns.Contains(u.SwapOrderSn));
        stepList = stepList.OrderBy(s => s.Sort).ToList();
        List<SwapOrderStepResp> swapOrderStep = mapper.Map<List<SwapOrderStepResp>>(stepList);
        
        //将步序数据添加到换电订单数据中
        // 给换电订单赋值车的公司和部门
        for (int i = 0; i < swapOrderResp.Count; i++)
        {
            // 初始化 StepList
            swapOrderResp[i].StepList = new List<SwapOrderStepResp>();
    
            // 获取与当前订单匹配的步骤信息
            var swapOrderStepResps = swapOrderStep.Where(step => step.SwapOrderSn == swapOrderResp[i].Sn).ToList();
            swapOrderResp[i].StepList.AddRange(swapOrderStepResps);

            // 设置 ManualStep 字段
            swapOrderResp[i].ManualStep = string.Join(",",
                swapOrderStepResps.Where(step => step.StepType == (int)SwapConstant.StepType.MANUAL)
                    .Select(step => step.StepDesc)
                    .ToList());
    
            // 查找匹配的车辆信息并赋值公司和部门字段
            var matchingVehicle = vehicleList.FirstOrDefault(v => v.VehicleNo == swapOrderResp[i].VehicleNo);
            if (matchingVehicle != null)
            {
                swapOrderResp[i].Company = matchingVehicle.Company;
                swapOrderResp[i].Departments = matchingVehicle.Departments;
            }
        }


        if (req.SwapResult == 0 || req.SwapResult == 1)
        {
            List<SwapOrderDto> list = mapper.Map<List<SwapOrderDto>>(swapOrderResp);
            List<SwapOrderDto2> list2 = mapper.Map<List<SwapOrderDto2>>(swapOrderResp);

            // 将电池数据添加到换电订单数据中
            for (int i = 0; i < list.Count; i++)
            {
                if (language == "en")
                {
                    SwapOrderDto2 dto = list2[i];

                    SwapOrderBatteryResp? swapOrderBatteryResp =
                        swapOrderBattery.FirstOrDefault(battery => battery.SwapOrderSn == dto.Sn);
                    if (swapOrderBatteryResp != null)
                    {
                        dto.DownBatterySoc = swapOrderBatteryResp.DownBatterySoc;
                        dto.DownBatteryNo = swapOrderBatteryResp.DownBatteryNo;
                        dto.UpBatteryNo = swapOrderBatteryResp.UpBatteryNo;
                        dto.UpBatterySoc = swapOrderBatteryResp.UpBatterySoc;
                        dto.DownBatteryBinNo = swapOrderBatteryResp.DownBatteryBinNo;
                        dto.UpBatteryBinNo = swapOrderBatteryResp.UpBatteryBinNo;
                        try
                        {
                            dto.DownBatteryElectricQuantity = ((double)dto.DownBatterySoc * 3.75).ToString();
                            dto.UpBatteryElectricQuantity = ((double)dto.UpBatterySoc * 3.75).ToString();
                            double ElectricQuantity = ((float)(dto.UpBatterySoc - dto.DownBatterySoc)) * 3.75;
                            dto.ElectricQuantity = ElectricQuantity.ToString();
                        }
                        catch (Exception e)
                        {
                        }
                    }
                }
                else
                {
                    SwapOrderDto dto = list[i];
                    SwapOrderBatteryResp? swapOrderBatteryResp =
                        swapOrderBattery.FirstOrDefault(battery => battery.SwapOrderSn == dto.Sn);
                    if (swapOrderBatteryResp != null)
                    {
                        dto.DownBatterySoc = swapOrderBatteryResp.DownBatterySoc;
                        dto.DownBatteryNo = swapOrderBatteryResp.DownBatteryNo;
                        dto.UpBatteryNo = swapOrderBatteryResp.UpBatteryNo;
                        dto.UpBatterySoc = swapOrderBatteryResp.UpBatterySoc;
                        dto.DownBatteryBinNo = swapOrderBatteryResp.DownBatteryBinNo;
                        dto.UpBatteryBinNo = swapOrderBatteryResp.UpBatteryBinNo;
                        try
                        {
                            dto.DownBatteryElectricQuantity = ((double)dto.DownBatterySoc * 3.75).ToString();
                            dto.UpBatteryElectricQuantity = ((double)dto.UpBatterySoc * 3.75).ToString();
                            double ElectricQuantity = ((float)(dto.UpBatterySoc - dto.DownBatterySoc)) * 3.75;
                            dto.ElectricQuantity = ElectricQuantity.ToString();
                        }
                        catch (Exception e)
                        {
                        }
                    }
                }
            }

            IExcelExporter excelExporter = new ExcelExporter();
            var res = language == "en"
                ? await excelExporter.ExportAsByteArray(list2)
                : await excelExporter.ExportAsByteArray(list);

            return new FileStreamResult(new MemoryStream(res), "application/octet-stream")
            {
                FileDownloadName = DateTime.Now.ToString("yyyyMMddHHmm") +
                                   (language == "en" ? "_Swap_Orders.xlsx" : "2号站换电记录.xlsx")
            };
        }
        else
        {
            List<SwapLoseOrderDto> list = mapper.Map<List<SwapLoseOrderDto>>(swapOrderResp);
            List<SwapLoseOrderDto2> list2 = mapper.Map<List<SwapLoseOrderDto2>>(swapOrderResp);

            // 将电池数据添加到换电订单数据中
            for (int i = 0; i < list.Count; i++)
            {
                if (language == "en")
                {
                    SwapLoseOrderDto2 dto = list2[i];

                    SwapOrderBatteryResp? swapOrderBatteryResp =
                        swapOrderBattery.FirstOrDefault(battery => battery.SwapOrderSn == dto.Sn);
                    if (swapOrderBatteryResp != null)
                    {
                        dto.DownBatteryBinNo = swapOrderBatteryResp.DownBatteryBinNo;
                        dto.UpBatteryBinNo = swapOrderBatteryResp.UpBatteryBinNo;
                    }
                }
                else
                {
                    SwapLoseOrderDto dto = list[i];
                    SwapOrderBatteryResp? swapOrderBatteryResp =
                        swapOrderBattery.FirstOrDefault(battery => battery.SwapOrderSn == dto.Sn);
                    if (swapOrderBatteryResp != null)
                    {
                        dto.DownBatteryBinNo = swapOrderBatteryResp.DownBatteryBinNo;
                        dto.UpBatteryBinNo = swapOrderBatteryResp.UpBatteryBinNo;
                    }
                }
            }

            IExcelExporter excelExporter = new ExcelExporter();
            var res = language == "en"
                ? await excelExporter.ExportAsByteArray(list2)
                : await excelExporter.ExportAsByteArray(list);

            return new FileStreamResult(new MemoryStream(res), "application/octet-stream")
            {
                FileDownloadName = DateTime.Now.ToString("yyyyMMddHHmm") +
                                   (language == "en" ? "_Swap_Lose_Orders.xlsx" : "2号站换电失败记录.xlsx")
            };
        }
    }
}