using Lada.Framework.Data.Domains;
using Lada.Framework.Data.Domains.Categories;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Domains.Medias;
using Lada.Framework.Data.Domains.Trucks;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Infrastructures.Services;
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 Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Trucks
{
    /// <summary>
    /// Giao diện cho dịch vụ quản lý xe tải.
    /// </summary>
    public interface ITruckService
    {
        #region Truck Management
        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin xe tải.
        /// </summary>
        /// <param name="param">Thông tin xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> CreateOrUpdate(TruckModel param);

        /// <summary>
        /// Lấy danh sách media (ảnh đăng ký, đăng kiểm) của xe tải.
        /// </summary>
        /// <param name="truckId">ID xe tải.</param>
        /// <returns>Danh sách media items.</returns>
        Task<List<TruckMediaItem>> GetTruckMediaAsync(int truckId);

        /// <summary>
        /// Xóa thông tin xe tải.
        /// </summary>
        /// <param name="id">ID xe tải cần xóa.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> Delete(int id);

        /// <summary>
        /// Lấy thông tin xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của xe tải.</param>
        /// <returns>Kết quả chứa thông tin xe tải.</returns>
        Task<TruckResult> GetByIds(KeyModels<int> param);

        /// <summary>
        /// Lấy thông tin xe tải theo ID của đại lý.
        /// </summary>
        /// <param name="param">ID của đại lý.</param>
        /// <returns>Kết quả chứa thông tin xe tải.</returns>
        Task<TruckResult> GetTruckByAgencyId(int param);

        /// <summary>
        /// Tìm kiếm thông tin xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm xe tải.</returns>
        Task<SmartTableResult<TruckItem>> Search(SmartTableParam param);

        /// <summary>
        /// Lấy lịch sử giao nhận xe tải theo ID xe
        /// </summary>
        /// <param name="truckId">ID xe tải</param>
        /// <returns>Danh sách lịch sử giao nhận xe với thông tin ODO, ghi chú và ảnh</returns>
        Task<BaseResult> GetTruckActivityHistory(int truckId);

        /// <summary>
        /// Cập nhật giá trị ODO đổ dầu gần nhất của xe tải
        /// </summary>
        /// <param name="truckId">ID xe tải</param>
        /// <param name="odoValue">Giá trị ODO</param>
        /// <returns>Kết quả cập nhật</returns>
        Task<BaseResult> UpdateLastRefillOdo(int truckId, int odoValue);

        /// <summary>
        /// Lấy thông tin xe tải theo ID.
        /// </summary>
        /// <param name="truckId">ID của xe tải.</param>
        /// <returns>Thông tin xe tải kèm danh sách ảnh.</returns>
        Task<TruckItem> GetById(int truckId);
        #endregion

        #region Truck Specification
        /// <summary>
        /// Lấy thông số kỹ thuật của xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của thông số kỹ thuật.</param>
        /// <returns>Kết quả chứa thông số kỹ thuật của xe tải.</returns>
        Task<TruckSpecificationResult> TruckSpecByIds(KeyModels<int> param);

        /// <summary>
        /// Tạo mới hoặc cập nhật thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckSpecCreateOrUpdate(TruckSpecificationModel param);

        /// <summary>
        /// Xóa thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckSpecDelete(TruckSpecificationModel param);

        /// <summary>
        /// Tìm kiếm thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thông số kỹ thuật của xe tải.</returns>
        Task<SmartTableResult<TruckSpecificationItem>> TruckSpecSearch(SmartTableParam param);

        /// <summary>
        /// Lấy tất cả thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả chứa tất cả thông số kỹ thuật của xe tải.</returns>
        Task<TruckSpecificationResult> TruckSpecGetAll(TruckSpecificationModel param);

        #region Attribute
        /// <summary>
        /// Lấy tất cả thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <returns>Kết quả chứa tất cả thuộc tính kỹ thuật của xe tải.</returns>
        Task<TruckSpecAttributeResult> TruckSpecAttrGetAll();

        /// <summary>
        /// Tìm kiếm thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thuộc tính kỹ thuật của xe tải.</returns>
        Task<SmartTableResult<TruckSpecAttributeItem>> TruckSpecAttrSearch(SmartTableParam param);

        /// <summary>
        /// Tạo mới hoặc cập nhật thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckSpecAttrCreateOrUpdate(TruckSpecAttributeModel param);

        /// <summary>
        /// Xóa thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckSpecAttrDelete(TruckSpecAttributeModel param);
        #endregion

        #endregion

        #region Truck Maintenance 
        /// <summary>
        /// Lấy thông tin bảo dưỡng xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của thông tin bảo dưỡng.</param>
        /// <returns>Kết quả chứa thông tin bảo dưỡng xe tải.</returns>
        Task<TruckMaintenanceResult> TruckMaintByIds(KeyModels<int> param);

        /// <summary>
        /// Tìm kiếm thông tin bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thông tin bảo dưỡng xe tải.</returns>
        Task<SmartTableResult<TruckMaintenanceItem>> TruckMaintSearch(SmartTableParam param);

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông tin bảo dưỡng xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckMaintCreateOrUpdate(TruckMaintenanceModel param);

        /// <summary>
        /// Xóa thông tin bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông tin bảo dưỡng xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckMaintDelete(TruckMaintenanceModel param);

        #region Attribute
        /// <summary>
        /// Lấy tất cả thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <returns>Kết quả chứa tất cả thuộc tính bảo dưỡng của xe tải.</returns>
        Task<TruckMaintAttributeResult> TruckMaintAttrGetAll();

        /// <summary>
        /// Tìm kiếm thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thuộc tính bảo dưỡng của xe tải.</returns>
        Task<SmartTableResult<TruckMaintAttributeItem>> TruckMaintAttrSearch(SmartTableParam param);

        /// <summary>
        /// Tạo mới hoặc cập nhật thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckMaintAttrCreateOrUpdate(TruckMaintAttributeModel param);

        /// <summary>
        /// Xóa thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        Task<BaseResult> TruckMaintAttrDelete(TruckMaintAttributeModel param);
        #endregion

        #region Truck Maintenance Link
        /// <summary>
        /// Lấy tất cả thông tin liên kết bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thông tin liên kết bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả chứa tất cả thông tin liên kết bảo dưỡng của xe tải.</returns>
        Task<TruckMaintLinkResult> TruckMaintLinkGetAll(TruckMaintLinkModel param);
        #endregion

        #endregion
    }

    /// <summary>
    /// Triển khai dịch vụ quản lý xe tải.
    /// </summary>
    public class TruckService : ITruckService
    {
        private readonly IRepository<Truck> _truckRepository;
        private readonly IRepository<Agency> _agencyRepository;
        private readonly IUserRepository<User> _userRepository;
        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<TruckMaintLink> _truckMaintLinkRepository;
        private readonly IRepository<TruckSpecification> _truckSpecificationRepository;
        private readonly IRepository<TruckMedia> _truckMediaRepository;
        private readonly IUnifiedMediaService _unifiedMediaService;

        /// <summary>
        /// Khởi tạo
        /// </summary>
        /// <param name="agencyRepository"></param>
        /// <param name="userRepository"></param>
        /// <param name="truckRepository"></param>
        /// <param name="truckActivityRepository"></param>
        /// <param name="truckActivityMediaRepository"></param>
        /// <param name="mediaRepository"></param>
        /// <param name="truckAssetRepository"></param>
        /// <param name="truckSpecAttributeRepository"></param>
        /// <param name="truckMaintAttributeRepository"></param>
        /// <param name="truckMaintenanceRepository"></param>
        /// <param name="truckMaintLinkRepository"></param>
        /// <param name="truckSpecificationRepository"></param>
        /// <param name="unifiedMediaService"></param>
        public TruckService(IRepository<Agency> agencyRepository,
            IUserRepository<User> userRepository,
            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<TruckMaintLink> truckMaintLinkRepository,
            IRepository<TruckSpecification> truckSpecificationRepository,
            IRepository<TruckMedia> truckMediaRepository,
            IUnifiedMediaService unifiedMediaService)
        {
            _userRepository = userRepository;
            _agencyRepository = agencyRepository;
            _truckRepository = truckRepository;
            _truckActivityRepository = truckActivityRepository;
            _truckActivityMediaRepository = truckActivityMediaRepository;
            _mediaRepository = mediaRepository;
            _truckAssetRepository = truckAssetRepository;
            _truckSpecAttributeRepository = truckSpecAttributeRepository;
            _truckMaintAttributeRepository = truckMaintAttributeRepository;
            _truckMaintenanceRepository = truckMaintenanceRepository;
            _truckSpecificationRepository = truckSpecificationRepository;
            _truckMaintLinkRepository = truckMaintLinkRepository;
            _truckMediaRepository = truckMediaRepository;
            _unifiedMediaService = unifiedMediaService;
        }

        #region Truck
        /// <summary>
        /// Tìm kiếm thông tin xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm xe tải.</returns>
        public async Task<SmartTableResult<TruckItem>> Search(SmartTableParam param)
        {
            SmartTableResult<TruckItem> gridData = new SmartTableResult<TruckItem>();
            var query = _truckRepository.Query();
            if (param != null)
            {
                if (param.Search != null)
                {
                    if (param.Search.PredicateObject != null)
                    {
                        dynamic search = param.Search.PredicateObject;
                        if (search.Keyword != null)
                        {
                            string keyword = search.Keyword;
                            keyword = keyword.Trim();
                            if (!string.IsNullOrWhiteSpace(keyword))
                                query = query.Where(x => x.LicensePlate.Contains(keyword));
                        }
                        //if (search.Status != null)
                        //{
                        //    TruckStatus status = search.Status;
                        //    query = query.Where(x => x.Status == status);
                        //}
                        if (search.CreateDateStart != null)
                        {
                            DateTime createStart = search.CreateDateStart;
                            var startOfDay = createStart.StartOfDay();
                            query = query.Where(x => x.CreatedTime >= startOfDay);
                        }
                        if (search.CreateDateEnd != null)
                        {
                            DateTime createEnd = search.CreateDateEnd;
                            var endOfDay = createEnd.EndOfDay();
                            query = query.Where(x => x.CreatedTime < endOfDay);
                        }

                        //if (search.LastRepairStart != null)
                        //{

                        //    DateTimeOffset startDate = search.LastRepairStart;
                        //    var startOfDay = startDate.StartOfDay();
                        //    query = query.Where(x => x.LastRepairDate >= startOfDay);
                        //}
                        //if (search.LastRepairEnd != null)
                        //{
                        //    DateTimeOffset endDate = search.LastRepairEnd;
                        //    var endOfDay = endDate.EndOfDay();
                        //    query = query.Where(x => x.LastRepairDate < endOfDay);
                        //}

                    }
                }
            }
            gridData = await query.Include(t => t.Agency).ToSmartTableResultAsync(param, x => x.ToItem());
            if (gridData.Items.Any())
            {
                //var agencyIds = gridData.Items.Select(x => x.AgencyId).Distinct().ToList();
                //var agencies = await _agencyRepository.Query().Where(x => agencyIds.Contains(x.Id)).ToListAsync();

                var userIds = gridData.Items.Select(x => x.CurrentDriverId).Distinct().ToList();
                var users = await _userRepository.Query().Where(x => userIds.Contains(x.Id)).ToListAsync();

                foreach (var item in gridData.Items)
                {
                    //if (agencies.Any())
                    //{
                    //    var agency = agencies.FirstOrDefault(x => x.Id == item.AgencyId);
                    //    if (agency != null)
                    //    {
                    //        item.AgencyName = agency.Name;
                    //    }
                    //}
                    if (users.Any())
                    {
                        var user = users.FirstOrDefault(x => x.Id == item.CurrentDriverId);
                        if (user != null)
                        {
                            item.PicUserName = user.UserName;
                            item.PicFullName = user.FullName;
                        }
                    }
                }
            }
            return gridData;
        }

        /// <summary>
        /// Lấy thông tin xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của xe tải.</param>
        /// <returns>Kết quả chứa thông tin xe tải.</returns>
        public async Task<TruckResult> GetByIds(KeyModels<int> param)
        {
            TruckResult result = new TruckResult { Result = Result.Success };
            if (param.Ids.Any())
            {
                var entities = await _truckRepository.Query().Where(x => param.Ids.Contains(x.Id)).ToListAsync();
                if (entities != null && entities.Any())
                {
                    var items = entities.ToItem();
                    //var agencyIds = items.Select(x => x.AgencyId).Distinct().ToList();
                    //var agencies = await _agencyRepository.Query().Where(x => agencyIds.Contains(x.Id)).ToListAsync();

                    var userIds = items.Select(x => x.CurrentDriverId).Distinct().ToList();
                    var users = await _userRepository.Query().Where(x => userIds.Contains(x.Id)).ToListAsync();

                    foreach (var item in items)
                    {
                        //if (agencies.Any())
                        //{
                        //    var agency = agencies.FirstOrDefault(x => x.Id == item.AgencyId);
                        //    if (agency != null)
                        //    {
                        //        item.AgencyName = agency.Name;
                        //    }
                        //}
                        if (users.Any())
                        {
                            var user = users.FirstOrDefault(x => x.Id == item.CurrentDriverId);
                            if (user != null)
                            {
                                item.PicUserName = user.UserName;
                                item.PicFullName = user.FullName;
                            }
                        }
                    }
                    result.Items = items;
                    result.Result = Result.Success;

                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy xe tải nào";
            }
            return result;
        }

        /// <summary>
        /// Lấy thông tin xe tải theo ID của đại lý.
        /// </summary>
        /// <param name="param">ID của đại lý.</param>
        /// <returns>Kết quả chứa thông tin xe tải.</returns>
        public async Task<TruckResult> GetTruckByAgencyId(int param)
        {
            TruckResult result = new TruckResult { Result = Result.Success };
            if (param > 0)
            {
                var entities = await _truckRepository.Query().Where(x => x.AgencyId == param).ToListAsync();
                if (entities != null && entities.Any())
                {
                    var items = entities.ToItem();
                    //var agencyIds = items.Select(x => x.AgencyId).Distinct().ToList();
                    //var agencies = await _agencyRepository.Query().Where(x => agencyIds.Contains(x.Id)).ToListAsync();

                    var userIds = items.Select(x => x.CurrentDriverId).Distinct().ToList();
                    var users = await _userRepository.Query().Where(x => userIds.Contains(x.Id)).ToListAsync();

                    foreach (var item in items)
                    {
                        //if (agencies.Any())
                        //{
                        //    var agency = agencies.FirstOrDefault(x => x.Id == item.AgencyId);
                        //    if (agency != null)
                        //    {
                        //        item.AgencyName = agency.Name;
                        //    }
                        //}
                        if (users.Any())
                        {
                            var user = users.FirstOrDefault(x => x.Id == item.CurrentDriverId);
                            if (user != null)
                            {
                                item.PicUserName = user.UserName;
                                item.PicFullName = user.FullName;
                            }
                        }
                    }
                    result.Items = items;
                    result.Result = Result.Success;

                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy xe tải nào";
            }
            return result;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin xe tải.
        /// </summary>
        /// <param name="param">Thông tin xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> CreateOrUpdate(TruckModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    // Cập nhật thông tin cơ bản
                    entity.LicensePlate = param.LicensePlate;
                    
                    // Chỉ cập nhật AgencyId nếu có giá trị hợp lệ
                    if (param.AgencyId > 0)
                    {
                        entity.AgencyId = param.AgencyId;
                    }
                    
                    entity.Brand = param.Brand;
                    entity.Model = param.Model;
                    
                    // Cập nhật thông số kỹ thuật (nếu có giá trị, nếu null thì giữ nguyên)
                    entity.MaxPayload = param.MaxPayload ?? entity.MaxPayload;
                    entity.CargoLength = param.CargoLength ?? entity.CargoLength;
                    entity.CargoWidth = param.CargoWidth ?? entity.CargoWidth;
                    entity.CargoHeight = param.CargoHeight ?? entity.CargoHeight;
                    
                    // Lưu ý: OperatingStatus, Status, CurrentDriverId KHÔNG được cập nhật tại đây
                    // Các trường này được quản lý bởi chức năng check-in/check-out riêng
                    
                    // Cập nhật thông tin vận hành
                    entity.ManufacturingYear = param.ManufacturingYear ?? entity.ManufacturingYear;
                    entity.RegistrationInfo = param.RegistrationInfo;
                    entity.FuelQuotaPer100Km = param.FuelQuotaPer100Km ?? entity.FuelQuotaPer100Km;

                    entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                    var rs = await _truckRepository.UpdateAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;

                        // Xử lý media (ảnh đăng ký, đăng kiểm)
                        await HandleTruckMediaAsync(entity.Id, param);
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy xe tải nào";
                }
            }
            else
            {
                var entity = param.ToEntity();
                entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                try
                {
                    var rs = await _truckRepository.InsertAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;

                        // Xử lý media (ảnh đăng ký, đăng kiểm)
                        await HandleTruckMediaAsync(entity.Id, param);
                    }
                }
                catch (Exception e)
                {
                    result.Result = Result.SystemError;
                    result.Message = e.Message;
                }
            }
            return result;
        }

        /// <summary>
        /// Xử lý upload/cập nhật media cho xe tải (ảnh đăng ký, đăng kiểm)
        /// </summary>
        private async Task HandleTruckMediaAsync(int truckId, TruckModel param)
        {
            // Xử lý xóa media cũ nếu có ExistingMediaIds
            if (param.ExistingMediaIds != null && param.ExistingMediaIds.Count > 0)
            {
                var currentMediaItems = await _truckMediaRepository.Query()
                    .Where(x => x.TruckId == truckId && !x.IsDeleted)
                    .OrderBy(x => x.DisplayOrder)
                    .ToListAsync();

                var currentMediaIds = currentMediaItems.Select(x => x.Id).ToList();
                var existingMediaIds = param.ExistingMediaIds;

                // Soft delete media không còn trong danh sách
                var mediaIdsToDelete = currentMediaIds.Except(existingMediaIds).ToList();
                if (mediaIdsToDelete.Any())
                {
                    var mediaToDelete = currentMediaItems.Where(x => mediaIdsToDelete.Contains(x.Id)).ToList();
                    foreach (var media in mediaToDelete)
                    {
                        media.IsDeleted = true;
                        media.UpdatedBy = param.UpdatedBy;
                        media.UpdatedByUserName = param.UpdatedByUserName;
                        media.UpdatedTime = DateTimeOffset.Now;
                        await _truckMediaRepository.UpdateAsync(media);
                    }
                }

                // Cập nhật DisplayOrder cho media giữ lại
                for (int i = 0; i < existingMediaIds.Count; i++)
                {
                    var mediaId = existingMediaIds[i];
                    if (mediaId > 0)
                    {
                        var mediaItem = currentMediaItems.FirstOrDefault(x => x.Id == mediaId);
                        if (mediaItem != null && mediaItem.DisplayOrder != i + 1)
                        {
                            mediaItem.DisplayOrder = i + 1;
                            mediaItem.UpdatedBy = param.UpdatedBy;
                            mediaItem.UpdatedByUserName = param.UpdatedByUserName;
                            mediaItem.UpdatedTime = DateTimeOffset.Now;
                            await _truckMediaRepository.UpdateAsync(mediaItem);
                        }
                    }
                }
            }

            // Upload file mới
            if (param.Files != null && param.Files.Count > 0 && param.MediaTypes != null)
            {
                for (int i = 0; i < param.Files.Count; i++)
                {
                    var file = param.Files[i];
                    var mediaType = param.MediaTypes[i];

                    // Process image
                    var processResult = await _unifiedMediaService.ProcessImageAsync(file, ImageType.TruckDocument);

                    if (processResult.Result == Result.Success)
                    {
                        // Tạo Media entity
                        var media = new Media
                        {
                            Id = Guid.NewGuid(),
                            SystemPath = processResult.SystemPath,
                            AltText = $"Ảnh xe tải - {mediaType.GetDescription()}",
                            Caption = $"Ảnh xe tải - {mediaType.GetDescription()}",
                            DisplayOrder = i,
                            IsDeleted = false
                        };
                        media = media.UpdateCommonGuid(param.UpdatedBy, param.UpdatedByUserName);

                        await _mediaRepository.InsertAsync(media);

                        // Tạo TruckMedia liên kết
                        var truckMedia = new TruckMedia
                        {
                            TruckId = truckId,
                            MediaId = media.Id,
                            MediaType = mediaType,
                            DisplayOrder = i + 1,
                            IsDeleted = false
                        };
                        truckMedia = truckMedia.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                        await _truckMediaRepository.InsertAsync(truckMedia);
                    }
                }
            }
        }


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

        /// <summary>
        /// Lấy thông tin xe tải theo ID.
        /// </summary>
        /// <param name="truckId">ID của xe tải.</param>
        /// <returns>Thông tin xe tải kèm danh sách ảnh.</returns>
        public async Task<TruckItem> GetById(int truckId)
        {
            var result = new TruckItem();
            if (truckId <= 0)
            {
                return result;
            }
            
            var truck = await _truckRepository.Query()
                .Include(t => t.Agency)
                .FirstOrDefaultAsync(t => t.Id == truckId);
                
            if (truck == null || truck.Id <= 0)
            {
                return result;
            }
            
            result = truck.ToItem();
            
            // Lấy thông tin người phụ trách
            if (result.CurrentDriverId > 0)
            {
                var user = await _userRepository.GetByIdAsync(result.CurrentDriverId);
                if (user != null)
                {
                    result.PicUserName = user.UserName;
                    result.PicFullName = user.FullName;
                }
            }
            
            // Lấy danh sách media (ảnh đăng ký, đăng kiểm)
            result.MediaItems = await GetTruckMediaAsync(truckId);
            
            return result;
        }

        /// <summary>
        /// Lấy danh sách media (ảnh đăng ký, đăng kiểm) của xe tải
        /// </summary>
        public async Task<List<TruckMediaItem>> GetTruckMediaAsync(int truckId)
        {
            var mediaItems = await _truckMediaRepository.Query()
                .Include(x => x.Media)
                .Where(x => x.TruckId == truckId && !x.IsDeleted)
                .OrderBy(x => x.DisplayOrder)
                .Select(x => new TruckMediaItem
                {
                    Id = x.Id,
                    MediaId = x.MediaId,
                    MediaUrl = _unifiedMediaService.GetUrlBySystemPathAsync(x.Media.SystemPath).Result,
                    MediaType = x.MediaType,
                    DisplayOrder = x.DisplayOrder
                })
                .ToListAsync();

            return mediaItems;
        }

        #endregion

        #region Truck Specs
        /// <summary>
        /// Tìm kiếm thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thông số kỹ thuật của xe tải.</returns>
        public async Task<SmartTableResult<TruckSpecificationItem>> TruckSpecSearch(SmartTableParam param)
        {
            SmartTableResult<TruckSpecificationItem> gridData = new SmartTableResult<TruckSpecificationItem>();
            var query = _truckSpecificationRepository.Query();
            if (param != null)
            {
                if (param.Search != null)
                {
                    if (param.Search.PredicateObject != null)
                    {
                        dynamic search = param.Search.PredicateObject;
                        if (search.Keyword != null)
                        {
                            string keyword = search.Keyword;
                            keyword = keyword.Trim();
                            if (!string.IsNullOrWhiteSpace(keyword))
                                query = query.Where(x => x.Note.Contains(keyword));
                        }

                        if (search.CreateDateStart != null)
                        {
                            DateTime createStart = DateTime.Parse(search.CreateDateStart.ToString());
                            var startOfDay = createStart.StartOfDay();
                            query = query.Where(x => x.CreatedTime >= startOfDay);
                        }
                        if (search.CreateDateEnd != null)
                        {
                            DateTime createEnd = DateTime.Parse(search.CreateDateEnd.ToString());
                            var endOfDay = createEnd.EndOfDay();
                            query = query.Where(x => x.CreatedTime < endOfDay);
                        }

                        if (search.TruckIds != null)
                        {
                            List<int> truckIds = search.TruckIds;
                            query = query.Where(x => truckIds.Contains(x.TruckId));
                        }

                    }
                }
            }
            gridData = await query.ToSmartTableResultAsync(param, x => x.ToItem());
            return gridData;
        }

        /// <summary>
        /// Lấy tất cả thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả chứa tất cả thông số kỹ thuật của xe tải.</returns>
        public async Task<TruckSpecificationResult> TruckSpecGetAll(TruckSpecificationModel param)
        {
            TruckSpecificationResult result = new TruckSpecificationResult { Result = Result.Success };
            if (param.TruckId > 0)
            {
                var entities = await _truckSpecificationRepository.Query().Where(x => x.TruckId == param.TruckId).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 xe tải này";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thông số kỹ thuật nào";
            }
            return result;
        }

        /// <summary>
        /// Lấy thông số kỹ thuật của xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của thông số kỹ thuật.</param>
        /// <returns>Kết quả chứa thông số kỹ thuật của xe tải.</returns>
        public async Task<TruckSpecificationResult> TruckSpecByIds(KeyModels<int> param)
        {
            TruckSpecificationResult result = new TruckSpecificationResult { Result = Result.Success };
            if (param.Ids.Any())
            {
                var entities = await _truckSpecificationRepository.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 thông số kỹ thuật nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thông số kỹ thuật nào";
            }
            return result;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thông số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckSpecCreateOrUpdate(TruckSpecificationModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                if (param.TruckId > 0)
                {
                    var entity = await _truckSpecificationRepository.GetByIdAsync(param.Id);
                    if (entity != null)
                    {
                        entity.TruckId = param.TruckId;
                        entity.Note = param.Note;
                        entity.LifeCycleByDay = param.LifeCycleByDay;
                        entity.LifeCycleByKm = param.LifeCycleByKm;
                        entity.UnitPrice = param.UnitPrice;
                        entity.Quantity = param.Quantity;
                        entity.TruckUnit = param.TruckUnit;
                        entity.TruckAttributeId = param.TruckAttributeId;
                        entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                        try
                        {
                            var rs = await _truckSpecificationRepository.UpdateAsync(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 thông số kỹ thuật 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 _truckSpecificationRepository.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 số kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckSpecDelete(TruckSpecificationModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckSpecificationRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    var rs = await _truckSpecificationRepository.DeleteAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thông số kỹ thuật nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thông số kỹ thuật nào";
            }
            return result;
        }

        #region Attribute
        /// <summary>
        /// Lấy tất cả thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <returns>Kết quả chứa tất cả thuộc tính kỹ thuật của xe tải.</returns>
        public async Task<TruckSpecAttributeResult> TruckSpecAttrGetAll()
        {
            TruckSpecAttributeResult rs = new TruckSpecAttributeResult() { Result = Result.Success };
            var query = await _truckSpecAttributeRepository.Query().ToListAsync();
            if (query.Any())
            {
                rs.Items = query.ToItem();
            }
            else
            {
                rs.Result = Result.Failed;
                rs.Message = "Không tìm thấy thuộc tính nào";
            }
            return rs;
        }

        /// <summary>
        /// Tìm kiếm thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thuộc tính kỹ thuật của xe tải.</returns>
        public async Task<SmartTableResult<TruckSpecAttributeItem>> TruckSpecAttrSearch(SmartTableParam param)
        {
            SmartTableResult<TruckSpecAttributeItem> gridData = new SmartTableResult<TruckSpecAttributeItem>();
            var query = _truckSpecAttributeRepository.Query();
            if (param != null)
            {
                if (param.Search != null)
                {
                    if (param.Search.PredicateObject != null)
                    {
                        dynamic search = param.Search.PredicateObject;
                        if (search.Keyword != null)
                        {
                            string keyword = search.Keyword;
                            keyword = keyword.Trim();
                            if (!string.IsNullOrWhiteSpace(keyword))
                                query = query.Where(x => x.Name.Contains(keyword));
                        }

                        if (search.CreateDateStart != null)
                        {
                            DateTime createStart = DateTime.Parse(search.CreateDateStart.ToString());
                            var startOfDay = createStart.StartOfDay();
                            query = query.Where(x => x.CreatedTime >= startOfDay);
                        }
                        if (search.CreateDateEnd != null)
                        {
                            DateTime createEnd = DateTime.Parse(search.CreateDateEnd.ToString());
                            var endOfDay = createEnd.EndOfDay();
                            query = query.Where(x => x.CreatedTime < endOfDay);
                        }
                    }
                }
            }
            gridData = await query.ToSmartTableResultAsync(param, x => x.ToItem());
            return gridData;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckSpecAttrCreateOrUpdate(TruckSpecAttributeModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckSpecAttributeRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    entity.Name = param.Name;
                    entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                    var rs = await _truckSpecAttributeRepository.UpdateAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thuộc tính kỹ thuật nào";
                }
            }
            else
            {
                var entity = param.ToEntity();
                entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                try
                {
                    var rs = await _truckSpecAttributeRepository.InsertAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                catch (Exception e)
                {
                    result.Result = Result.SystemError;
                    result.Message = e.Message;
                }
            }
            return result;
        }

        /// <summary>
        /// Xóa thuộc tính kỹ thuật của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính kỹ thuật của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckSpecAttrDelete(TruckSpecAttributeModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckSpecAttributeRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    var rs = await _truckSpecAttributeRepository.DeleteAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thuộc tính kỹ thuật nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thuộc tính kỹ thuật nào";
            }
            return result;
        }
        #endregion

        #endregion

        #region Truck Maint
        /// <summary>
        /// Tìm kiếm thông tin bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thông tin bảo dưỡng xe tải.</returns>
        public async Task<SmartTableResult<TruckMaintenanceItem>> TruckMaintSearch(SmartTableParam param)
        {
            SmartTableResult<TruckMaintenanceItem> gridData = new SmartTableResult<TruckMaintenanceItem>();
            var query = _truckMaintenanceRepository.Query();
            if (param != null)
            {
                if (param.Search != null)
                {
                    if (param.Search.PredicateObject != null)
                    {
                        dynamic search = param.Search.PredicateObject;
                        if (search.Keyword != null)
                        {
                            string keyword = search.Keyword;
                            keyword = keyword.Trim();
                            if (!string.IsNullOrWhiteSpace(keyword))
                                query = query.Where(x =>
                                x.Title.Contains(keyword)
                                || x.Description.Contains(keyword)
                                || x.GarageAddress.Contains(keyword)
                                || x.GarageName.Contains(keyword)
                                || x.GaragePhone.Contains(keyword)
                                );
                        }

                        if (search.CreateDateStart != null)
                        {
                            DateTimeOffset createStart = DateTimeOffset.Parse(search.CreateDateStart.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy đầu ngày
                            var startOfDay = createStart.ToLocalTime().DateTime.StartOfDay();
                            query = query.Where(x => x.CreatedTime >= startOfDay);
                        }
                        if (search.CreateDateEnd != null)
                        {
                            DateTimeOffset createEnd = DateTimeOffset.Parse(search.CreateDateEnd.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy cuối ngày
                            var endOfDay = createEnd.ToLocalTime().DateTime.EndOfDay();
                            query = query.Where(x => x.CreatedTime < endOfDay);
                        }

                        if (search.NextTimeStart != null)
                        {
                            DateTimeOffset startDate = DateTimeOffset.Parse(search.NextTimeStart.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy đầu ngày
                            var startOfDay = startDate.ToLocalTime().DateTime.StartOfDay();
                            query = query.Where(x => x.NextTime >= startOfDay);
                        }
                        if (search.NextTimeEnd != null)
                        {
                            DateTimeOffset endDate = DateTimeOffset.Parse(search.NextTimeEnd.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy cuối ngày
                            var endOfDay = endDate.ToLocalTime().DateTime.EndOfDay();
                            query = query.Where(x => x.NextTime < endOfDay);
                        }

                        if (search.StartTimeBegin != null)
                        {
                            DateTimeOffset startDate = DateTimeOffset.Parse(search.StartTimeBegin.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy đầu ngày
                            var startOfDay = startDate.ToLocalTime().DateTime.StartOfDay();
                            query = query.Where(x => x.StartTime >= startOfDay);
                        }
                        if (search.StartTimeFinish != null)
                        {
                            DateTimeOffset endDate = DateTimeOffset.Parse(search.StartTimeFinish.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy cuối ngày
                            var endOfDay = endDate.ToLocalTime().DateTime.EndOfDay();
                            query = query.Where(x => x.StartTime < endOfDay);
                        }

                        if (search.EndTimeBegin != null)
                        {
                            DateTimeOffset startDate = DateTimeOffset.Parse(search.EndTimeBegin.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy đầu ngày
                            var startOfDay = startDate.ToLocalTime().DateTime.StartOfDay();
                            query = query.Where(x => x.EndTime >= startOfDay);
                        }
                        if (search.EndTimeFinish != null)
                        {
                            DateTimeOffset endDate = DateTimeOffset.Parse(search.EndTimeFinish.ToString());
                            // Chuyển từ UTC sang local time (GMT+7) và lấy cuối ngày
                            var endOfDay = endDate.ToLocalTime().DateTime.EndOfDay();
                            query = query.Where(x => x.EndTime < endOfDay);
                        }
                    }
                }
            }
            param ??= new SmartTableParam();
            gridData = await query.ToSmartTableResultAsync(param, x => x.ToItem());
            if (gridData.Items.Any())
            {
                var truckIds = gridData.Items.Select(x => x.TruckId).Distinct().ToList();
                var trucks = await _truckRepository.Query().Where(x => truckIds.Contains(x.Id)).ToListAsync();

                var agencyIds = gridData.Items.Select(x => x.AgencyId).Distinct().ToList();
                var agencies = await _agencyRepository.Query().Where(x => agencyIds.Contains(x.Id)).ToListAsync();

                var userIds = gridData.Items.Select(x => x.UserId).Distinct().ToList();
                var users = await _userRepository.Query().Where(x => userIds.Contains(x.Id)).ToListAsync();

                foreach (var item in gridData.Items)
                {
                    var agency = agencies.FirstOrDefault(x => x.Id == item.AgencyId);
                    if (agency != null)
                    {
                        item.AgencyName = agency.Name;
                    }
                    var truck = trucks.FirstOrDefault(x => x.Id == item.TruckId);
                    if (truck != null)
                    {
                        item.TruckLicensePlate = truck.LicensePlate;
                    }
                    var user = users.FirstOrDefault(x => x.Id == item.UserId);
                    if (user != null)
                    {
                        item.FullName = user.FullName;
                        item.UserName = user.UserName;
                    }
                }
            }
            return gridData;
        }

        /// <summary>
        /// Lấy thông tin bảo dưỡng xe tải theo danh sách ID.
        /// </summary>
        /// <param name="param">Danh sách ID của thông tin bảo dưỡng.</param>
        /// <returns>Kết quả chứa thông tin bảo dưỡng xe tải.</returns>
        public async Task<TruckMaintenanceResult> TruckMaintByIds(KeyModels<int> param)
        {
            TruckMaintenanceResult result = new TruckMaintenanceResult { Result = Result.Success };
            if (param.Ids.Any())
            {
                var entities = await _truckMaintenanceRepository.Query().Where(x => param.Ids.Contains(x.Id)).ToListAsync();
                if (entities != null && entities.Any())
                {
                    var truckMaintIds = entities.Select(x => x.Id).ToList();
                    var truckMaintLinks = await _truckMaintLinkRepository.Query().Where(x => truckMaintIds.Contains(x.TruckMaintenanceId)).ToListAsync();
                    var truckMaintItems = entities.ToItem();
                    foreach (var item in truckMaintItems)
                    {
                        var truckMaintLinkEntities = truckMaintLinks.Where(x => x.TruckMaintenanceId == item.Id).ToList();
                        if (truckMaintLinkEntities != null && truckMaintLinkEntities.Any())
                        {
                            item.TruckMaintLinkItems = truckMaintLinkEntities.ToItem();
                        }
                    }
                    result.Items = truckMaintItems;
                    result.Result = Result.Success;
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy hoạt động bảo dưỡng nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy hoạt động bảo dưỡng nào";
            }
            return result;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông tin bảo dưỡng xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckMaintCreateOrUpdate(TruckMaintenanceModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                if (param.TruckId > 0)
                {
                    var entity = await _truckMaintenanceRepository.GetByIdAsync(param.Id);
                    if (entity != null)
                    {
                        entity.AgencyId = param.AgencyId;
                        entity.TruckId = param.TruckId;
                        entity.UserId = param.UserId;
                        entity.Cost = param.Cost;
                        entity.Title = param.Title;
                        entity.Description = param.Description;
                        entity.StartTime = param.StartTime;
                        entity.EndTime = param.EndTime;
                        entity.NextTime = param.NextTime;
                        entity.HasInvoice = param.HasInvoice;
                        entity.InvoiceUrl = param.InvoiceUrl;
                        entity.GarageAddress = param.GarageAddress;
                        entity.GarageName = param.GarageName;
                        entity.GaragePhone = param.GaragePhone;

                        entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                        try
                        {
                            var rs = await _truckMaintenanceRepository.UpdateAsync(entity);
                            if (rs > 0)
                            {
                                var existTruckMaintAttr = await _truckMaintLinkRepository.Query().Where(x => x.TruckMaintenanceId == entity.Id).ToListAsync();
                                if (existTruckMaintAttr != null)
                                {
                                    await _truckMaintLinkRepository.DeleteAsync(existTruckMaintAttr);
                                }

                                var truckMaintAttr = param.TruckMaintLinkModels.Select(x => new TruckMaintLink
                                {
                                    TruckMaintenanceId = entity.Id,
                                    TruckMaintAttributeId = x.TruckMaintAttributeId,
                                    TruckMaintenanceValue = x.TruckMaintenanceValue,
                                    TruckMaintenanceUnit = x.TruckMaintenanceUnit,
                                    UpdatedBy = x.UpdatedBy,
                                    UpdatedByUserName = x.UpdatedByUserName,
                                    UpdatedTime = x.UpdatedTime,
                                    CreatedBy = x.UpdatedBy,
                                    CreatedByUserName = x.UpdatedByUserName,
                                    CreatedTime = x.UpdatedTime
                                }).ToList();
                                if (truckMaintAttr != null && truckMaintAttr.Any())
                                {
                                    await _truckMaintLinkRepository.InsertAsync(truckMaintAttr);
                                }

                                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 hoạt động bảo dưỡng 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 _truckMaintenanceRepository.InsertAsync(entity);
                        if (rs > 0)
                        {
                            var truckMaintAttr = param.TruckMaintLinkModels.Select(x => new TruckMaintLink
                            {
                                TruckMaintenanceId = entity.Id,
                                TruckMaintAttributeId = x.TruckMaintAttributeId,
                                TruckMaintenanceValue = x.TruckMaintenanceValue,
                                TruckMaintenanceUnit = x.TruckMaintenanceUnit,
                                UpdatedBy = x.UpdatedBy,
                                UpdatedByUserName = x.UpdatedByUserName,
                                UpdatedTime = x.UpdatedTime,
                                CreatedBy = x.UpdatedBy,
                                CreatedByUserName = x.UpdatedByUserName,
                                CreatedTime = x.UpdatedTime
                            }).ToList();
                            if (truckMaintAttr != null && truckMaintAttr.Any())
                            {
                                await _truckMaintLinkRepository.InsertAsync(truckMaintAttr);
                            }

                            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 bảo dưỡng xe tải.
        /// </summary>
        /// <param name="param">Thông tin bảo dưỡng xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckMaintDelete(TruckMaintenanceModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckMaintenanceRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    var rs = await _truckMaintenanceRepository.DeleteAsync(entity);
                    if (rs > 0)
                    {
                        var existTruckMaintAttr = await _truckMaintLinkRepository.Query().Where(x => x.TruckMaintenanceId == entity.Id).ToListAsync();
                        if (existTruckMaintAttr != null)
                        {
                            await _truckMaintLinkRepository.DeleteAsync(existTruckMaintAttr);
                        }
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy hoạt động bảo dưỡng nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy hoạt động bảo dưỡng nào";
            }
            return result;
        }

        #region Maintenance Link
        /// <summary>
        /// Lấy tất cả thông tin liên kết bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thông tin liên kết bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả chứa tất cả thông tin liên kết bảo dưỡng của xe tải.</returns>
        public async Task<TruckMaintLinkResult> TruckMaintLinkGetAll(TruckMaintLinkModel param)
        {
            TruckMaintLinkResult result = new TruckMaintLinkResult { Result = Result.Success };
            if (param.TruckMaintenanceId > 0)
            {
                var entities = await _truckMaintLinkRepository.Query().Where(x => x.TruckMaintenanceId == param.TruckMaintenanceId).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 thông tin bảo trì này";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thông tin bảo trì nào";
            }
            return result;
        }
        #endregion

        #region Attribute
        /// <summary>
        /// Lấy tất cả thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <returns>Kết quả chứa tất cả thuộc tính bảo dưỡng của xe tải.</returns>
        public async Task<TruckMaintAttributeResult> TruckMaintAttrGetAll()
        {
            TruckMaintAttributeResult rs = new TruckMaintAttributeResult() { Result = Result.Success };
            var query = await _truckMaintAttributeRepository.Query().ToListAsync();
            if (query.Any())
            {
                rs.Items = query.ToItem();
            }
            else
            {
                rs.Result = Result.Failed;
                rs.Message = "Không tìm thấy thuộc tính nào";
            }
            return rs;
        }

        /// <summary>
        /// Tìm kiếm thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thông số tìm kiếm.</param>
        /// <returns>Kết quả tìm kiếm thuộc tính bảo dưỡng của xe tải.</returns>
        public async Task<SmartTableResult<TruckMaintAttributeItem>> TruckMaintAttrSearch(SmartTableParam param)
        {
            SmartTableResult<TruckMaintAttributeItem> gridData = new SmartTableResult<TruckMaintAttributeItem>();
            var query = _truckMaintAttributeRepository.Query();
            if (param != null)
            {
                if (param.Search != null)
                {
                    if (param.Search.PredicateObject != null)
                    {
                        dynamic search = param.Search.PredicateObject;
                        if (search.Keyword != null)
                        {
                            string keyword = search.Keyword;
                            keyword = keyword.Trim();
                            if (!string.IsNullOrWhiteSpace(keyword))
                                query = query.Where(x => x.Name.Contains(keyword));
                        }

                        if (search.CreateDateStart != null)
                        {
                            DateTime createStart = DateTime.Parse(search.CreateDateStart.ToString());
                            var startOfDay = createStart.StartOfDay();
                            query = query.Where(x => x.CreatedTime >= startOfDay);
                        }
                        if (search.CreateDateEnd != null)
                        {
                            DateTime createEnd = DateTime.Parse(search.CreateDateEnd.ToString());
                            var endOfDay = createEnd.EndOfDay();
                            query = query.Where(x => x.CreatedTime < endOfDay);
                        }
                    }
                }
            }
            param ??= new SmartTableParam();
            gridData = await query.ToSmartTableResultAsync(param, x => x.ToItem());
            return gridData;
        }

        /// <summary>
        /// Tạo mới hoặc cập nhật thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckMaintAttrCreateOrUpdate(TruckMaintAttributeModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckMaintAttributeRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    entity.Name = param.Name;
                    entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                    var rs = await _truckMaintAttributeRepository.UpdateAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thuộc tính kỹ thuật nào";
                }
            }
            else
            {
                var entity = param.ToEntity();
                entity = entity.UpdateCommonInt(param.UpdatedBy, param.UpdatedByUserName);

                try
                {
                    var rs = await _truckMaintAttributeRepository.InsertAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                catch (Exception e)
                {
                    result.Result = Result.SystemError;
                    result.Message = e.Message;
                }
            }
            return result;
        }

        /// <summary>
        /// Xóa thuộc tính bảo dưỡng của xe tải.
        /// </summary>
        /// <param name="param">Thuộc tính bảo dưỡng của xe tải.</param>
        /// <returns>Kết quả của thao tác.</returns>
        public async Task<BaseResult> TruckMaintAttrDelete(TruckMaintAttributeModel param)
        {
            BaseResult result = new BaseResult { Result = Result.Success };
            if (param.Id > 0)
            {
                var entity = await _truckMaintAttributeRepository.GetByIdAsync(param.Id);
                if (entity != null)
                {
                    var rs = await _truckMaintAttributeRepository.DeleteAsync(entity);
                    if (rs > 0)
                    {
                        result.Result = Result.Success;
                    }
                }
                else
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thuộc tính bảo dưỡng nào";
                }
            }
            else
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thuộc tính bảo dưỡng nào";
            }
            return result;
        }

        /// <summary>
        /// Lấy lịch sử giao nhận xe tải theo ID xe
        /// </summary>
        /// <param name="truckId">ID của xe tải</param>
        /// <returns>Danh sách lịch sử giao nhận xe</returns>
        public async Task<BaseResult> GetTruckActivityHistory(int truckId)
        {
            var result = new TruckActivityResult();

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

                // Lấy danh sách hoạt động giao nhận xe (check-in/check-out)
                var activities = await _truckActivityRepository.Query()
                    .Where(ta => ta.TruckId == truckId &&
                                (ta.ActionType == ActionType.CheckIn ||
                                 ta.ActionType == ActionType.CheckOut))
                    .OrderByDescending(ta => ta.CreatedTime)
                    .ToListAsync();

                var activityItems = new List<TruckActivityItem>();

                foreach (var activity in activities)
                {
                    var activityItem = new TruckActivityItem
                    {
                        Id = activity.Id,
                        TruckId = activity.TruckId,
                        ActionType = activity.ActionType,
                        CurrentOdo = activity.CurrentOdo,
                        Note = activity.Note ?? string.Empty,
                        CreatedTime = activity.CreatedTime,
                        CreatedBy = activity.CreatedBy,
                        CreatedByUserName = activity.CreatedByUserName ?? string.Empty,
                        UpdatedTime = activity.UpdatedTime,
                        UpdatedBy = activity.UpdatedBy,
                        UpdatedByUserName = activity.UpdatedByUserName ?? string.Empty
                    };

                    // Lấy danh sách media cho activity này
                    var mediaList = await GetActivityMediaAsync(activity.Id);
                    activityItem.MediaItems = mediaList;

                    activityItems.Add(activityItem);
                }

                result.Items = activityItems;
                result.Result = Result.Success;
                result.Message = $"Lấy lịch sử giao nhận xe thành công. Tìm thấy {activityItems.Count} hoạt động.";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = $"Lỗi hệ thống: {ex.Message}";
            }

            return result;
        }

        /// <summary>
        /// Lấy danh sách media cho một activity
        /// </summary>
        /// <param name="activityId">ID của activity</param>
        /// <returns>Danh sách media items</returns>
        private async Task<List<TruckActivityMediaItem>> GetActivityMediaAsync(int activityId)
        {
            var mediaItems = new List<TruckActivityMediaItem>();

            try
            {
                // Lấy danh sách TruckActivityMedia
                var activityMediaList = await _truckActivityMediaRepository.Query()
                    .Where(tam => tam.TruckActivityId == activityId)
                    .Include(tam => tam.Media)
                    .OrderBy(tam => tam.DisplayOrder)
                    .ToListAsync();

                foreach (var activityMedia in activityMediaList)
                {
                    if (activityMedia.Media != null)
                    {
                        var mediaItem = new TruckActivityMediaItem
                        {
                            Id = activityMedia.Id,
                            TruckActivityId = activityId,
                            MediaId = activityMedia.MediaId,
                            MediaType = activityMedia.MediaType,
                            DisplayOrder = activityMedia.DisplayOrder,
                            MediaUrl = await _unifiedMediaService.GetUrlBySystemPathAsync(activityMedia.Media.SystemPath),
                            AltText = activityMedia.Media.AltText ?? string.Empty,
                            Caption = activityMedia.Media.Caption ?? string.Empty,
                            CreatedTime = activityMedia.CreatedTime,
                            CreatedBy = activityMedia.CreatedBy,
                            CreatedByUserName = activityMedia.CreatedByUserName ?? string.Empty
                        };

                        mediaItems.Add(mediaItem);
                    }
                }
            }
            catch (Exception)
            {
                // Trả về danh sách rỗng nếu có lỗi
                mediaItems = [];
            }

            return mediaItems;
        }

        /// <summary>
        /// Cập nhật giá trị ODO đổ dầu gần nhất của xe tải
        /// </summary>
        /// <param name="truckId">ID xe tải</param>
        /// <param name="odoValue">Giá trị ODO</param>
        /// <returns>Kết quả cập nhật</returns>
        public async Task<BaseResult> UpdateLastRefillOdo(int truckId, int odoValue)
        {
            var result = new BaseResult { Result = Result.Failed };

            if (truckId <= 0)
            {
                result.Message = "ID xe tải không hợp lệ";
                return result;
            }

            if (odoValue < 0)
            {
                result.Message = "Giá trị ODO không hợp lệ";
                return result;
            }

            var truck = await _truckRepository.GetByIdAsync(truckId);
            if (truck == null)
            {
                result.Message = "Không tìm thấy xe tải";
                return result;
            }

            // Kiểm tra nếu ODO mới nhỏ hơn ODO hiện tại
            if (truck.LastRefillOdo.HasValue && odoValue < truck.LastRefillOdo.Value)
            {
                result.Message = $"Giá trị ODO mới ({odoValue}) không thể nhỏ hơn ODO đổ dầu trước đó ({truck.LastRefillOdo.Value})";
                return result;
            }

            truck.LastRefillOdo = odoValue;
            
            try
            {
                var updateResult = await _truckRepository.UpdateAsync(truck);
                if (updateResult > 0)
                {
                    result.Result = Result.Success;
                    result.Message = $"Đã cập nhật ODO đổ dầu gần nhất: {odoValue} km";
                }
                else
                {
                    result.Message = "Cập nhật ODO thất bại";
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = $"Lỗi hệ thống: {ex.Message}";
            }

            return result;
        }
        #endregion
        #endregion
    }
}