using Lada.Framework.Data.Domains.OrderBusiness;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Services;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.DTO.Items.OrderBusiness;
using Ladaer.BackEnd.Infrastructures.DTO.Models.OrderBusiness;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.OrderBusiness
{
    /// <summary>
    /// Interface quản lý lý do thất bại lấy/giao hàng
    /// </summary>
    public interface IOrderFailReasonService
    {
        /// <summary>
        /// Tìm kiếm lý do thất bại
        /// </summary>
        Task<SmartTableResult<OrderFailReasonItem>> Search(SmartTableParam param);

        /// <summary>
        /// Tạo hoặc cập nhật lý do thất bại
        /// </summary>
        Task<BaseResult> CreateOrUpdate(OrderFailReasonModel model);

        /// <summary>
        /// Lấy thông tin lý do thất bại theo ID
        /// </summary>
        Task<OrderFailReasonModel> GetById(int id);

        /// <summary>
        /// Xóa lý do thất bại (soft delete)
        /// </summary>
        Task<BaseResult> Delete(OrderFailReasonModel model);

        /// <summary>
        /// Lấy danh sách lý do thất bại theo loại (cho Driver App)
        /// Chỉ trả về Active = true
        /// </summary>
        Task<List<OrderFailReasonItem>> GetByType(int type);
    }

    /// <summary>
    /// Service quản lý lý do thất bại lấy/giao hàng
    /// </summary>
    public class OrderFailReasonService : IOrderFailReasonService
    {
        private readonly IRepository<OrderFailReason> _repository;

        public OrderFailReasonService(IRepository<OrderFailReason> repository)
        {
            _repository = repository;
        }

        /// <summary>
        /// Tìm kiếm lý do thất bại
        /// </summary>
        public async Task<SmartTableResult<OrderFailReasonItem>> Search(SmartTableParam param)
        {
            IQueryable<OrderFailReason> query = _repository.Query()
                .Where(x => !x.IsDeleted);

            // Lọc theo từ khóa tìm kiếm
            if (param.Search.PredicateObject != null)
            {
                dynamic search = param.Search.PredicateObject;

                if (search.Keyword != null)
                {
                    string keyword = search.Keyword;
                    keyword = keyword.Trim().ToLower();
                    query = query.Where(x =>
                        x.Name.ToLower().Contains(keyword) ||
                        (x.Description != null && x.Description.ToLower().Contains(keyword)));
                }

                if (search.Type != null)
                {
                    int type = search.Type;
                    OrderFailReasonType reasonType = (OrderFailReasonType)type;
                    query = query.Where(x => x.Type == reasonType);
                }

                if (search.IsActive != null)
                {
                    bool isActive = search.IsActive;
                    query = query.Where(x => x.IsActive == isActive);
                }
            }

            // Sắp xếp mặc định
            param.Sort = new Sort() { Predicate = "SortOrder", Reverse = false };

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

        /// <summary>
        /// Tạo hoặc cập nhật lý do thất bại
        /// </summary>
        public async Task<BaseResult> CreateOrUpdate(OrderFailReasonModel model)
        {
            var result = new BaseResult();

            try
            {
                if (model.Id > 0)
                {
                    // Cập nhật
                    var entity = await _repository.GetByIdAsync(model.Id);
                    if (entity == null || entity.IsDeleted)
                    {
                        result.Result = Result.Failed;
                        result.Message = "Không tìm thấy bản ghi";
                        return result;
                    }

                    // Map thuộc tính từ model sang entity hiện có
                    entity.Name = model.Name;
                    entity.Description = model.Description;
                    entity.Type = (OrderFailReasonType)model.Type;
                    entity.IsMediaRequired = model.IsMediaRequired;
                    entity.MediaTitle = model.MediaTitle;
                    entity.SortOrder = model.SortOrder;
                    entity.IsActive = model.IsActive;
                    entity.UpdatedBy = model.UpdatedBy;
                    entity.UpdatedByUserName = model.UpdatedByUserName;
                    entity.UpdatedTime = DateTimeOffset.Now;

                    await _repository.UpdateAsync(entity);
                }
                else
                {
                    // Tạo mới
                    var entity = model.ToEntity();
                    entity.Type = (OrderFailReasonType)model.Type;
                    entity.CreatedBy = model.UpdatedBy;
                    entity.CreatedByUserName = model.UpdatedByUserName;
                    entity.CreatedTime = DateTimeOffset.Now;
                    entity.IsDeleted = false;

                    await _repository.InsertAsync(entity);
                }

                result.Message = "Thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = "Đã xảy ra lỗi: " + ex.Message;
            }

            return result;
        }

        /// <summary>
        /// Lấy thông tin lý do thất bại theo ID
        /// </summary>
        public async Task<OrderFailReasonModel> GetById(int id)
        {
            var entity = await _repository.GetByIdAsync(id);
            if (entity == null || entity.IsDeleted)
            {
                return null;
            }

            return entity.ToModel();
        }

        /// <summary>
        /// Xóa lý do thất bại (soft delete)
        /// </summary>
        public async Task<BaseResult> Delete(OrderFailReasonModel model)
        {
            var result = new BaseResult();

            try
            {
                var entity = await _repository.GetByIdAsync(model.Id);
                if (entity == null || entity.IsDeleted)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy bản ghi";
                    return result;
                }
                entity.UpdatedBy = model.UpdatedBy;
                entity.UpdatedByUserName = model.UpdatedByUserName;
                entity.UpdatedTime = DateTimeOffset.Now;

                await _repository.DeleteAsync(entity);

                result.Message = "Xóa thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = "Đã xảy ra lỗi: " + ex.Message;
            }

            return result;
        }

        /// <summary>
        /// Lấy danh sách lý do thất bại theo loại (cho Driver App)
        /// </summary>
        public async Task<List<OrderFailReasonItem>> GetByType(int type)
        {
            var query = _repository.Query()
                .Where(x => !x.IsDeleted && x.IsActive);

            if (type > 0)
            {
                OrderFailReasonType reasonType = (OrderFailReasonType)type;
                query = query.Where(x => x.Type == reasonType || x.Type == OrderFailReasonType.Both);
            }

            var entities = query.OrderBy(x => x.SortOrder).ToList();
            return entities.Select(x => x.ToItem()).ToList();
        }
    }
}
