using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Models;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Trucks;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Media;
using Lada.Framework.Infrastructures.Services;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Trucks
{
    /// <summary>
    /// Giao diện cho dịch vụ quản lý hoạt động xe tải.
    /// </summary>
    public interface ITruckActivityService
    {
        /// <summary>
        /// Lấy thông tin hoạt động xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của hoạt động xe tải.</param>
        /// <returns>Kết quả chứa thông tin hoạt động xe tải.</returns>
        Task<TruckActivityResult> GetByIds(KeyModels<int> param);

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin hoạt động xe tải.
        /// </summary>
        /// <param name="param">Thông tin hoạt động xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<TruckActivityResult> CreateOrUpdate(TruckActivityModel param);

        /// <summary>
        /// Xóa thông tin hoạt động xe tải.
        /// </summary>
        /// <param name="param">Thông tin hoạt động xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> Delete(TruckModel param);

        /// <summary>
        /// Nhận xe (Check-in) với upload hình ảnh
        /// </summary>
        /// <param name="model">Thông tin nhận xe</param>
        /// <returns>Kết quả nhận xe</returns>
        Task<TruckActivityResult> CheckInTruck(TruckCheckInOutModel model);

        /// <summary>
        /// Trả xe (Check-out) với upload hình ảnh
        /// </summary>
        /// <param name="model">Thông tin trả xe</param>
        /// <returns>Kết quả trả xe</returns>
        Task<TruckActivityResult> CheckOutTruck(TruckCheckInOutModel model);

        /// <summary>
        /// Đổ dầu cho xe với upload hình ảnh và thông tin ODO
        /// </summary>
        /// <param name="model">Thông tin đổ dầu</param>
        /// <returns>Kết quả đổ dầu</returns>
        Task<TruckActivityResult> FuelRefillTruck(TruckFuelRefillModel model);

        /// <summary>
        /// Lấy danh sách xe có thể nhận (chưa có người phụ trách)
        /// </summary>
        /// <param name="agencyId">ID đại lý</param>
        /// <returns>Danh sách xe có thể nhận</returns>
        Task<TruckResult> GetAvailableTrucks(int agencyId);

        /// <summary>
        /// Lấy xe hiện tại của người dùng
        /// </summary>
        /// <param name="userId">ID người dùng</param>
        /// <returns>Thông tin xe hiện tại</returns>
        Task<TruckResult> GetCurrentUserTruck(int userId);
    }
    /// <summary>
    /// Triển khai dịch vụ quản lý hoạt động xe tải.
    /// </summary>
    public class TruckActivityService : ITruckActivityService
    {
        private readonly IRepository<Truck> _truckRepository;
        private readonly IRepository<TruckActivity> _truckActivityRepository;
        private readonly IRepository<TruckActivityMedia> _truckActivityMediaRepository;
        private readonly IRepository<Media> _mediaRepository;
        private readonly IRepository<TruckAsset> _truckAssetRepository;
        private readonly IRepository<TruckSpecAttribute> _truckSpecAttributeRepository;
        private readonly IRepository<TruckMaintAttribute> _truckMaintAttributeRepository;
        private readonly IRepository<TruckMaintenance> _truckMaintenanceRepository;
        private readonly IRepository<TruckSpecification> _truckSpecificationRepository;
        private readonly IRepository<Agency> _agencyRepository;
        private readonly IUserRepository<User> _userRepository;
        private readonly IUnifiedMediaService _unifiedMediaService;

        /// <summary>
        /// Khởi tạo một thể hiện của <see cref="TruckActivityService"/>.
        /// </summary>
        /// <param name="truckRepository">Đối tượng IRepository của Truck.</param>
        /// <param name="truckActivityRepository">Đối tượng IRepository của TruckActivity.</param>
        /// <param name="truckAssetRepository">Đối tượng IRepository của TruckAsset.</param>
        /// <param name="truckSpecAttributeRepository">Đối tượng IRepository của TruckSpecAttribute.</param>
        /// <param name="truckMaintAttributeRepository">Đối tượng IRepository của TruckMaintAttribute.</param>
        /// <param name="truckMaintenanceRepository">Đối tượng IRepository của TruckMaintenance.</param>
        /// <param name="truckSpecificationRepository">Đối tượng IRepository của TruckSpecification.</param>
        public TruckActivityService(IRepository<Truck> truckRepository,
            IRepository<TruckActivity> truckActivityRepository,
            IRepository<TruckActivityMedia> truckActivityMediaRepository,
            IRepository<Media> mediaRepository,
            IRepository<TruckAsset> truckAssetRepository,
            IRepository<TruckSpecAttribute> truckSpecAttributeRepository,
            IRepository<TruckMaintAttribute> truckMaintAttributeRepository,
            IRepository<TruckMaintenance> truckMaintenanceRepository,
            IRepository<TruckSpecification> truckSpecificationRepository,
            IRepository<Agency> agencyRepository,
            IUserRepository<User> userRepository,
            IUnifiedMediaService unifiedMediaService)
        {
            _truckRepository = truckRepository;
            _truckActivityRepository = truckActivityRepository;
            _truckActivityMediaRepository = truckActivityMediaRepository;
            _mediaRepository = mediaRepository;
            _truckAssetRepository = truckAssetRepository;
            _truckSpecAttributeRepository = truckSpecAttributeRepository;
            _truckMaintAttributeRepository = truckMaintAttributeRepository;
            _truckMaintenanceRepository = truckMaintenanceRepository;
            _truckSpecificationRepository = truckSpecificationRepository;
            _agencyRepository = agencyRepository;
            _userRepository = userRepository;
            _unifiedMediaService = unifiedMediaService;
        }

        #region TruckActivity
        /// <summary>
        /// Lấy thông tin hoạt động xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của hoạt động xe tải.</param>
        /// <returns>Kết quả chứa thông tin hoạt động xe tải.</returns>
        public async Task<TruckActivityResult> GetByIds(KeyModels<int> param)
        {
            TruckActivityResult result = new TruckActivityResult { Result = Result.Success };
            if (param.Ids.Any())
            {
                var entities = await _truckActivityRepository.Query().Where(x => param.Ids.Contains(x.Id)).ToListAsync();
                if (entities != null && entities.Any())
                {
                    result.Items = entities.ToItem();
                    result.Result = Result.Success;
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy hoạt động xe tải nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy hoạt động xe tải nào";
            }
            return result;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin hoạt động xe tải.
        /// </summary>
        /// <param name="param">Thông tin hoạt động xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<TruckActivityResult> CreateOrUpdate(TruckActivityModel param)
        {
            TruckActivityResult result = new TruckActivityResult { Result = Result.Success };
            if (param.Id > 0)
            {
                if (param.TruckId > 0)
                {
                    var entity = await _truckActivityRepository.GetByIdAsync(param.Id);
                    if (entity != null)
                    {
                        entity.AgencyId = param.AgencyId;
                        entity.Note = param.Note;
                        entity.ActionType = param.ActionType;
                        entity.UserId = param.UserId;
                        entity.CurrentOdo = param.CurrentOdo;
                        entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                        var rs = await _truckActivityRepository.UpdateAsync(entity);
                        if (rs > 0)
                        {
                            result.Result = Result.Success;
                        }
                    }
                    else
                    {
                        result.Result = Result.Failed;
                        result.Message = "Không tìm thấy hoạt động xe tải nào";
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải nào";
                }
            }
            else
            {
                if (param.TruckId > 0)
                {
                    var entity = param.ToEntity();
                    entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                    try
                    {
                        var rs = await _truckActivityRepository.InsertAsync(entity);
                        if (rs > 0)
                        {
                            result.Result = Result.Success;
                        }
                    }
                    catch (Exception e)
                    {
                        result.Result = Result.SystemError;
                        result.Message = e.Message;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải nào";
                }
            }
            return result;
        }

        /// <summary>
        /// Xóa thông tin hoạt động xe tải.
        /// </summary>
        /// <param name="param">Thông tin hoạt động xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> Delete(TruckModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckActivityRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    var rs = await _truckActivityRepository.DeleteAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy hoạt động xe tải nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy hoạt động xe tải nào";
            }
            return result;
        }

        public async Task<TruckActivityResult> CheckInTruck(TruckCheckInOutModel model)
        {
            var result = new TruckActivityResult { Result = Result.Success };

            try
            {
                // Kiểm tra người dùng có đang phụ trách xe nào khác không
                var currentUserTruck = await GetUserCurrentTruckAsync(model.UpdatedBy);

                if (currentUserTruck != null)
                {
                    result.Result = Result.Failed;
                    result.Message = $"Bạn đang phụ trách xe {currentUserTruck.LicensePlate}. Vui lòng trả xe hiện tại trước khi nhận xe mới";
                    return result;
                }

                // Kiểm tra xe có tồn tại và có thể nhận không
                var truck = await _truckRepository.GetByIdAsync(model.TruckId);
                if (truck == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải";
                    return result;
                }

                if (truck.CurrentDriverId != 0)
                {
                    result.Result = Result.Failed;
                    result.Message = "Xe tải đã có người phụ trách";
                    return result;
                }

                // Tạo TruckActivity record
                var activity = new TruckActivity
                {
                    TruckId = model.TruckId,
                    UserId = model.UpdatedBy,
                    AgencyId = model.AgencyId,
                    ActionType = ActionType.CheckIn,
                    Note = model.Note,
                    CurrentOdo = model.CurrentOdo
                };

                activity = activity.UpdateCommonInt(model.UpdatedBy, model.UpdatedByUserName);
                var activityId = await _truckActivityRepository.InsertAsync(activity);

                if (activityId > 0)
                {
                    // Cập nhật CurrentDriverId cho truck
                    truck.CurrentDriverId = model.UpdatedBy;
                    await _truckRepository.UpdateAsync(truck);

                    // Xử lý upload hình ảnh nếu có
                    if (model.Files != null && model.Files.Any())
                    {
                        await ProcessActivityMedia(activityId, model.Files, TruckActivityMediaType.CheckInPhoto, model.UpdatedBy, model.UpdatedByUserName);
                    }

                    result.Item = await GetActivityItemById(activityId);
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không thể tạo bản ghi nhận xe";
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.Message;
            }

            return result;
        }

        public async Task<TruckActivityResult> CheckOutTruck(TruckCheckInOutModel model)
        {
            var result = new TruckActivityResult { Result = Result.Success };

            try
            {
                // Kiểm tra xe có tồn tại không
                var truck = await _truckRepository.GetByIdAsync(model.TruckId);
                if (truck == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải";
                    return result;
                }

                // Kiểm tra người dùng có đang phụ trách xe này không
                if (truck.CurrentDriverId != model.UpdatedBy)
                {
                    result.Result = Result.Failed;
                    result.Message = "Bạn không phải là người phụ trách xe này";
                    return result;
                }

                // Tạo TruckActivity record
                var activity = new TruckActivity
                {
                    TruckId = model.TruckId,
                    UserId = model.UpdatedBy,
                    AgencyId = model.AgencyId,
                    ActionType = ActionType.CheckOut,
                    Note = model.Note,
                    CurrentOdo = model.CurrentOdo
                };

                activity = activity.UpdateCommonInt(model.UpdatedBy, model.UpdatedByUserName);
                var activityId = await _truckActivityRepository.InsertAsync(activity);

                if (activityId > 0)
                {
                    // Cập nhật CurrentDriverId cho truck (set về 0)
                    truck.CurrentDriverId = 0;
                    truck.OperatingStatus = OperatingStatus.Stop;
                    await _truckRepository.UpdateAsync(truck);

                    // Xử lý upload hình ảnh nếu có
                    if (model.Files != null && model.Files.Any())
                    {
                        await ProcessActivityMedia(activityId, model.Files, TruckActivityMediaType.CheckOutPhoto, model.UpdatedBy, model.UpdatedByUserName);
                    }

                    result.Item = await GetActivityItemById(activityId);
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không thể tạo bản ghi trả xe";
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.Message;
            }

            return result;
        }

        public async Task<TruckActivityResult> FuelRefillTruck(TruckFuelRefillModel model)
        {
            var result = new TruckActivityResult { Result = Result.Success };

            try
            {
                // Kiểm tra xe có tồn tại và user có đang phụ trách xe này không
                var truck = await _truckRepository.GetByIdAsync(model.TruckId);
                if (truck == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải";
                    return result;
                }

                if (truck.CurrentDriverId != model.UpdatedBy)
                {
                    result.Result = Result.Failed;
                    result.Message = "Bạn không phải là người phụ trách xe này";
                    return result;
                }

                // Kiểm tra số lượng ảnh (tối thiểu 2, tối đa 5)
                if (model.Files == null || model.Files.Count < 2)
                {
                    result.Result = Result.Failed;
                    result.Message = "Cần upload tối thiểu 2 ảnh đổ dầu";
                    return result;
                }

                if (model.Files.Count > 5)
                {
                    result.Result = Result.Failed;
                    result.Message = "Chỉ được upload tối đa 5 ảnh đổ dầu";
                    return result;
                }

                // Tạo TruckActivity record
                var activity = new TruckActivity
                {
                    TruckId = model.TruckId,
                    UserId = model.UpdatedBy,
                    AgencyId = model.AgencyId,
                    ActionType = ActionType.FuelRefill,
                    Note = model.Note,
                    CurrentOdo = model.CurrentOdo
                };

                activity = activity.UpdateCommonInt(model.UpdatedBy, model.UpdatedByUserName);
                var activityId = await _truckActivityRepository.InsertAsync(activity);

                if (activityId > 0)
                {
                    // Xử lý upload hình ảnh
                    await ProcessActivityMedia(activityId, model.Files, TruckActivityMediaType.FuelRefillPhoto, model.UpdatedBy, model.UpdatedByUserName);

                    result.Item = await GetActivityItemById(activityId);
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không thể tạo bản ghi đổ dầu";
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.Message;
            }

            return result;
        }

        public async Task<TruckResult> GetAvailableTrucks(int agencyId)
        {
            var result = new TruckResult { Result = Result.Success };

            try
            {
                var availableTrucks = await _truckRepository.Query()
                    .Where(t => t.AgencyId == agencyId && t.CurrentDriverId == 0 && !t.IsDeleted)
                    .Select(t => new TruckItem
                    {
                        Id = t.Id,
                        LicensePlate = t.LicensePlate,
                        AgencyName = t.Agency.Name,
                        OperatingStatus = t.OperatingStatus,
                        Status = t.Status,
                        CurrentDriverId = t.CurrentDriverId
                    })
                    .ToListAsync();

                result.Items = availableTrucks;
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.Message;
            }

            return result;
        }

        public async Task<TruckResult> GetCurrentUserTruck(int userId)
        {
            var result = new TruckResult { Result = Result.Success };

            try
            {
                var currentTruckEntity = await GetUserCurrentTruckAsync(userId);

                if (currentTruckEntity != null)
                {
                    var currentTruck = await _truckRepository.Query()
                        .Where(t => t.Id == currentTruckEntity.Id)
                        .Include(t => t.Agency)
                        .Select(t => new TruckItem
                        {
                            Id = t.Id,
                            LicensePlate = t.LicensePlate,
                            AgencyName = t.Agency.Name,
                            OperatingStatus = t.OperatingStatus,
                            Status = t.Status,
                            CurrentDriverId = t.CurrentDriverId
                        })
                        .FirstOrDefaultAsync();

                    if (currentTruck != null)
                    {
                        result.Items = new List<TruckItem> { currentTruck };
                    }
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.Message;
            }

            return result;
        }

        private async Task ProcessActivityMedia(int activityId, List<IFormFile> files, TruckActivityMediaType mediaType, int userId, string userName)
        {
            var mediaResults = await ProcessAndSaveListMediaAsync(files);

            if (mediaResults.Any())
            {
                var currentTime = DateTimeHelper.CurrentTime();

                for (int i = 0; i < mediaResults.Count; i++)
                {
                    var mediaResult = mediaResults[i];
                    if (mediaResult.Result == Result.Success && mediaResult.MediaId.HasValue)
                    {
                        var mediaDescription = mediaType switch
                        {
                            TruckActivityMediaType.CheckInPhoto => "nhận xe",
                            TruckActivityMediaType.CheckOutPhoto => "trả xe",
                            TruckActivityMediaType.FuelRefillPhoto => "đổ dầu",
                            _ => "hoạt động xe"
                        };

                        // Cập nhật thông tin Media đã tạo với user info
                        var existingMedia = await _mediaRepository.GetByIdAsync(mediaResult.MediaId.Value);
                        if (existingMedia != null)
                        {
                            existingMedia.AltText = $"Ảnh {mediaDescription}";
                            existingMedia.Caption = $"Ảnh {mediaDescription}";
                            existingMedia.CreatedBy = userId;
                            existingMedia.CreatedByUserName = userName;
                            existingMedia.UpdatedBy = userId;
                            existingMedia.UpdatedByUserName = userName;
                            await _mediaRepository.UpdateAsync(existingMedia);

                            // Tạo TruckActivityMedia record
                            var activityMedia = new TruckActivityMedia
                            {
                                TruckActivityId = activityId,
                                MediaId = mediaResult.MediaId.Value,
                                MediaType = mediaType,
                                DisplayOrder = i + 1,
                                CreatedTime = currentTime,
                                UpdatedTime = currentTime,
                                CreatedBy = userId,
                                CreatedByUserName = userName,
                                UpdatedBy = userId,
                                UpdatedByUserName = userName
                            };

                            await _truckActivityMediaRepository.InsertAsync(activityMedia);
                        }
                    }
                }
            }
        }

        private async Task<TruckActivityItem> GetActivityItemById(int activityId)
        {
            var item = await (from a in _truckActivityRepository.Query()
                              join t in _truckRepository.Query() on a.TruckId equals t.Id
                              join u in _userRepository.Query() on a.UserId equals u.Id
                              join ag in _agencyRepository.Query() on a.AgencyId equals ag.Id
                              where a.Id == activityId
                              select new TruckActivityItem
                              {
                                  Id = a.Id,
                                  TruckId = a.TruckId,
                                  LicensePlate = t.LicensePlate,
                                  UserId = a.UserId,
                                  UserName = u.UserName,
                                  FullName = u.FullName,
                                  AgencyId = a.AgencyId,
                                  AgencyName = ag.Name,
                                  Note = a.Note,
                                  ActionType = a.ActionType,
                                  CurrentOdo = a.CurrentOdo,
                                  CreatedTime = a.CreatedTime,
                                  UpdatedTime = a.UpdatedTime,
                                  CreatedBy = a.CreatedBy,
                                  CreatedByUserName = a.CreatedByUserName,
                                  UpdatedBy = a.UpdatedBy,
                                  UpdatedByUserName = a.UpdatedByUserName
                              })
                             .FirstOrDefaultAsync();

            if (item != null)
            {
                item.MediaItems = await GetActivityMediaItems(activityId);
            }

            return item;
        }

        private async Task<List<TruckActivityMediaItem>> GetActivityMediaItems(int activityId)
        {
            var mediaItems = await _truckActivityMediaRepository.Query()
                .Where(am => am.TruckActivityId == activityId)
                .Include(am => am.Media)
                .OrderBy(am => am.DisplayOrder)
                .Select(am => new TruckActivityMediaItem
                {
                    Id = am.Id,
                    TruckActivityId = am.TruckActivityId,
                    MediaId = am.MediaId,
                    MediaUrl = am.Media.SystemPath, // Sẽ được chuyển đổi bên dưới
                    AltText = am.Media.AltText,
                    Caption = am.Media.Caption,
                    MediaType = am.MediaType,
                    DisplayOrder = am.DisplayOrder,
                    CreatedTime = am.CreatedTime,
                    UpdatedTime = am.UpdatedTime,
                    CreatedBy = am.CreatedBy,
                    CreatedByUserName = am.CreatedByUserName,
                    UpdatedBy = am.UpdatedBy,
                    UpdatedByUserName = am.UpdatedByUserName
                })
                .ToListAsync();

            // Chuyển đổi SystemPath thành URL hiển thị được
            foreach (var item in mediaItems)
            {
                if (!string.IsNullOrEmpty(item.MediaUrl))
                {
                    item.MediaUrl = await _unifiedMediaService.GetUrlBySystemPathAsync(item.MediaUrl);
                }
            }

            return mediaItems;
        }

        /// <summary>
        /// Kiểm tra xem người dùng có đang phụ trách xe nào không
        /// </summary>
        /// <param name="userId">ID người dùng</param>
        /// <returns>Thông tin xe đang phụ trách (nếu có)</returns>
        private async Task<Truck?> GetUserCurrentTruckAsync(int userId)
        {
            return await _truckRepository.Query()
                .FirstOrDefaultAsync(t => t.CurrentDriverId == userId);
        }

        /// <summary>
        /// Xử lý và lưu nhiều file media cùng lúc
        /// </summary>
        /// <param name="files">Danh sách file media</param>
        /// <returns>Danh sách kết quả xử lý</returns>
        private async Task<List<SaveMediaResult>> ProcessAndSaveListMediaAsync(List<IFormFile> files)
        {
            var results = new List<SaveMediaResult>();

            if (files == null || files.Count == 0)
            {
                return results;
            }

            try
            {
                var currentTime = DateTimeHelper.CurrentTime();

                for (int i = 0; i < files.Count; i++)
                {
                    var file = files[i];
                    var saveResult = new SaveMediaResult
                    {
                        InputFilename = file.FileName,
                        Result = Result.Success
                    };

                    try
                    {
                        // Xử lý ảnh bằng UnifiedMediaService (không lưu database)
                        var processResult = await _unifiedMediaService.ProcessImageAsync(file, ImageType.TruckActivity);

                        if (processResult.Result == Result.Success)
                        {
                            // Tạo Media entity thủ công
                            var media = new Media
                            {
                                Id = Guid.NewGuid(),
                                SystemPath = processResult.SystemPath,
                                AltText = $"Ảnh hoạt động xe tải",
                                Caption = $"Ảnh hoạt động xe tải",
                                DisplayOrder = i,
                                CreatedTime = currentTime,
                                UpdatedTime = currentTime,
                                CreatedBy = 0, // Sẽ được cập nhật trong ProcessActivityMedia
                                CreatedByUserName = "System",
                                UpdatedBy = 0,
                                UpdatedByUserName = "System"
                            };

                            // Lưu Media entity
                            await _mediaRepository.InsertAsync(media);

                            saveResult.OutputFileName = processResult.SystemPath;
                            saveResult.Url = processResult.Url;
                            saveResult.Message = "Xử lý ảnh thành công";
                            saveResult.MediaId = media.Id; // Thêm MediaId để sử dụng sau
                        }
                        else
                        {
                            saveResult.Result = processResult.Result;
                            saveResult.Message = processResult.Message;
                        }
                    }
                    catch (Exception ex)
                    {
                        saveResult.Result = Result.SystemError;
                        saveResult.Message = $"Lỗi xử lý file {file.FileName}: {ex.Message}";
                    }

                    results.Add(saveResult);
                }
            }
            catch (Exception ex)
            {
                // Trả về lỗi chung nếu có exception
                results.Add(new SaveMediaResult
                {
                    Result = Result.SystemError,
                    Message = $"Lỗi hệ thống khi xử lý media: {ex.Message}"
                });
            }

            return results;
        }

        #endregion
    }
}
