using Lada.Framework.Data.Domains.Crm;
using Lada.Framework.Data.Repositories;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Items.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.DTO.Profiles;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Crm;
using Microsoft.EntityFrameworkCore;
using static Ladaer.BackEnd.Infrastructures.DTO.Profiles.CrmMappingExtensions;

namespace Ladaer.BackEnd.Infrastructures.Services.Crm
{
    /// <summary>
    /// Interface service quản lý thông tin xuất hóa đơn VAT của khách hàng
    /// </summary>
    public interface IVatInfoService
    {
        /// <summary>
        /// Lấy danh sách thông tin xuất hóa đơn VAT theo điều kiện tìm kiếm
        /// </summary>
        /// <param name="searchModel">Model tìm kiếm</param>
        /// <returns>Danh sách thông tin xuất hóa đơn VAT</returns>
        Task<SmartTableResult<VatInfoItem>> Search(SmartTableParam param);

        /// <summary>
        /// Lấy thông tin chi tiết xuất hóa đơn VAT theo ID
        /// </summary>
        /// <param name="id">ID thông tin xuất hóa đơn VAT</param>
        /// <returns>Thông tin chi tiết xuất hóa đơn VAT</returns>
        Task<VatInfoModel> GetByIdAsync(int id);

        /// <summary>
        /// Lấy thông tin xuất hóa đơn VAT mặc định của khách hàng
        /// </summary>
        /// <param name="customerId">ID khách hàng</param>
        /// <returns>Thông tin xuất hóa đơn VAT mặc định</returns>
        Task<VatInfoModel> GetDefaultByCustomerIdAsync(int customerId);

        /// <summary>
        /// Tạo mới hoặc cập nhật thông tin xuất hóa đơn VAT
        /// </summary>
        /// <param name="model">Model tạo mới hoặc cập nhật</param>
        /// <returns>Kết quả tạo mới hoặc cập nhật</returns>
        Task<VatInfoResult> CreateOrUpdateAsync(VatInfoModel model);

        /// <summary>
        /// Xóa thông tin xuất hóa đơn VAT
        /// </summary>
        /// <param name="id">ID thông tin xuất hóa đơn VAT</param>
        /// <returns>Kết quả xóa</returns>
        Task<BaseResult> DeleteAsync(int id);

        /// <summary>
        /// Đặt thông tin xuất hóa đơn VAT làm mặc định
        /// </summary>
        /// <param name="id">ID thông tin xuất hóa đơn VAT</param>
        /// <returns>Kết quả cập nhật</returns>
        Task<BaseResult> SetAsDefaultAsync(int id, CurrentUser currentUser);


    }

    /// <summary>
    /// Service quản lý thông tin xuất hóa đơn VAT của khách hàng
    /// </summary>
    public class VatInfoService : IVatInfoService
    {
        private readonly IRepository<VatInfo> _customerVatInfoRepository;
        private readonly IRepository<Customer> _customerRepository;

        public VatInfoService(
            IRepository<VatInfo> customerVatInfoRepository,
            IRepository<Customer> customerRepository)
        {
            _customerVatInfoRepository = customerVatInfoRepository;
            _customerRepository = customerRepository;
        }

        #region SEARCH
        public async Task<SmartTableResult<VatInfoItem>> Search(SmartTableParam param)
        {
            var query = _customerVatInfoRepository.Query();
            if (param.Search.PredicateObject != null)
            {
                dynamic search = param.Search.PredicateObject;

                // Filter theo CustomerId
                if (search.CustomerId != null)
                {
                    int customerId = (int)search.CustomerId;
                    if (customerId > 0)
                    {
                        query = query.Where(x => x.CustomerId == customerId);
                    }
                }

                if (search.Keyword != null)
                {
                    string keyword = search.Keyword;
                    keyword = keyword.Trim().ToLower();
                    query = query.Where(x => x.CompanyName.ToLower().Contains(keyword)
                                            || x.Address.ToLower().Contains(keyword)
                                            || x.InvoiceEmail.ToLower().Contains(keyword)
                                            || x.TaxCode.ToLower().Contains(keyword)
                                            || x.ContactName.ToLower().Contains(keyword)
                                            || x.ContactPhone.ToLower().Contains(keyword));
                }
                if (search.CreatedStart != null && search.CreatedEnd != null)
                {
                    DateTimeOffset start = search.CreatedStart;
                    DateTimeOffset end = search.CreatedEnd;
                    DateTimeOffset startParam = start.StartOfDay();
                    DateTimeOffset endParam = end.EndOfDay();
                    query = query.Where(x => x.CreatedTime >= startParam && x.CreatedTime <= endParam);
                }
            }
            param.Sort = new Sort() { Predicate = "Id", Reverse = true };
            var gridData = await query.ToSmartTableResultAsync(param, x => x.ToItem());
            return gridData;
        }
        #endregion

        public async Task<VatInfoModel> GetByIdAsync(int id)
        {
            var result = new VatInfoModel();
            if (id <= 0)
            {
                return result;
            }
            try
            {
                var entity = await _customerVatInfoRepository.Query()
                    .Include(x => x.Customer)
                    .FirstOrDefaultAsync(x => x.Id == id);

                if (entity == null)
                {
                    return result;
                }

                result = entity.ToModel();

            }
            catch (Exception ex)
            {
                result = new VatInfoModel();
            }

            return result;
        }

        public async Task<VatInfoModel> GetDefaultByCustomerIdAsync(int customerId)
        {
            var result = new VatInfoModel();

            try
            {
                var entity = await _customerVatInfoRepository.Query()
                    .Include(x => x.Customer)
                    .FirstOrDefaultAsync(x => x.CustomerId == customerId && x.IsDefault);

                if (entity == null)
                {
                    return result;
                }

                result = entity.ToModel();
            }
            catch (Exception ex)
            {
                result = new VatInfoModel();
            }

            return result;
        }

        public async Task<VatInfoResult> CreateOrUpdateAsync(VatInfoModel model)
        {
            var result = new VatInfoResult();

            try
            {
                // Kiểm tra khách hàng tồn tại
                var customer = await _customerRepository.GetByIdAsync(model.CustomerId);
                if (customer == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy khách hàng";
                    return result;
                }

                if (model.Id > 0)
                {
                    // Cập nhật
                    return await Update(model);
                }
                else
                {
                    // Tạo mới
                    return await Create(model);
                }
            }
            catch (Exception ex)
            {
                result.Result = Result.Failed;
                result.Message = $"Lỗi khi xử lý: {ex.Message}";
            }

            return result;
        }

        /// <summary>
        /// Cập nhật thông tin xuất hóa đơn VAT
        /// </summary>
        /// <param name="model">Model cập nhật</param>
        /// <returns>Kết quả cập nhật</returns>
        private async Task<VatInfoResult> Update(VatInfoModel model)
        {
            var result = new VatInfoResult();
            var entity = await _customerVatInfoRepository.Query()
                .FirstOrDefaultAsync(x => x.Id == model.Id);
            var currentTime = DateTimeHelper.CurrentTime();
            if (entity == null || model.Id <= 0)
            {
                result.Result = Result.Failed;
                result.Message = "Không tìm thấy thông tin xuất hóa đơn VAT yêu cầu!";
                return result;
            }

            try
            {
                // Nếu đặt làm mặc định, bỏ mặc định của các record khác
                if (model.IsDefault && !entity.IsDefault)
                {
                    var existingDefaults = await _customerVatInfoRepository.Query()
                        .Where(x => x.CustomerId == entity.CustomerId && x.IsDefault && x.Id != model.Id)
                        .ToListAsync();

                    foreach (var existing in existingDefaults)
                    {
                        existing.IsDefault = false;
                        existing.UpdatedTime = currentTime;
                        existing.UpdatedBy = model.UpdatedBy;
                        existing.UpdatedByUserName = model.UpdatedByUserName;
                        await _customerVatInfoRepository.UpdateAsync(existing);
                    }
                }

                // Cập nhật thông tin
                entity.CompanyName = model.CompanyName.Trim();
                entity.TaxCode = model.TaxCode.Trim();
                entity.InvoiceEmail = model.InvoiceEmail.Trim();
                entity.Address = model.Address.Trim();
                entity.ContactName = model.ContactName.Trim();
                entity.ContactPhone = model.ContactPhone.Trim();
                entity.Note = model.Note.Trim();
                entity.IsDefault = model.IsDefault;
                entity.UpdatedBy = model.UpdatedBy;
                entity.UpdatedByUserName = model.UpdatedByUserName;
                await _customerVatInfoRepository.UpdateAsync(entity);
                result.Id = entity.Id;
                result.Result = Result.Success;
                result.Message = "Cập nhật thông tin xuất hóa đơn VAT thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.ToString();
            }

            return result;
        }

        /// <summary>
        /// Tạo mới thông tin xuất hóa đơn VAT
        /// </summary>
        /// <param name="model">Model tạo mới</param>
        /// <returns>Kết quả tạo mới</returns>
        private async Task<VatInfoResult> Create(VatInfoModel model)
        {
            var result = new VatInfoResult();
            var currentTime = DateTimeHelper.CurrentTime();
            try
            {
                // Nếu đặt làm mặc định, bỏ mặc định của các record khác
                if (model.IsDefault)
                {
                    var existingDefaults = await _customerVatInfoRepository.Query()
                        .Where(x => x.CustomerId == model.CustomerId && x.IsDefault)
                        .ToListAsync();

                    foreach (var existing in existingDefaults)
                    {
                        existing.IsDefault = false;
                        existing.UpdatedTime = currentTime;
                        existing.UpdatedBy = model.UpdatedBy;
                        existing.UpdatedByUserName = model.UpdatedByUserName;
                        await _customerVatInfoRepository.UpdateAsync(existing);
                    }
                }

                var entity = model.ToEntity();
                await _customerVatInfoRepository.InsertAsync(entity);
                result.Id = entity.Id;
                result.Result = Result.Success;
                result.Message = "Tạo mới thông tin xuất hóa đơn VAT thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = ex.ToString();
                result.Id = 0;
            }

            return result;
        }

        public async Task<BaseResult> DeleteAsync(int id)
        {
            var result = new BaseResult();

            try
            {
                var entity = await _customerVatInfoRepository.GetByIdAsync(id);
                if (entity == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thông tin xuất hóa đơn VAT";
                    return result;
                }

                // Không cho phép xóa record mặc định
                if (entity.IsDefault)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không thể xóa thông tin xuất hóa đơn VAT mặc định";
                    return result;
                }

                await _customerVatInfoRepository.DeleteAsync(entity);

                result.Result = Result.Success;
                result.Message = "Xóa thông tin xuất hóa đơn VAT thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.Failed;
                result.Message = $"Lỗi khi xóa: {ex.Message}";
            }

            return result;
        }

        public async Task<BaseResult> SetAsDefaultAsync(int id, CurrentUser currentUser)
        {
            var result = new BaseResult();
            var currentTime = DateTimeHelper.CurrentTime();
            try
            {
                var entity = await _customerVatInfoRepository.GetByIdAsync(id);
                if (entity == null)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy thông tin xuất hóa đơn VAT";
                    return result;
                }

                // Bỏ mặc định của các record khác
                var existingDefaults = await _customerVatInfoRepository.Query()
                    .Where(x => x.CustomerId == entity.CustomerId && x.IsDefault && x.Id != id)
                    .ToListAsync();

                foreach (var existing in existingDefaults)
                {
                    existing.IsDefault = false;
                    existing.UpdatedTime = currentTime;
                    existing.UpdatedBy = currentUser.UserId;
                    existing.UpdatedByUserName = currentUser.UserName;
                    await _customerVatInfoRepository.UpdateAsync(existing);
                }

                // Đặt record hiện tại làm mặc định
                entity.IsDefault = true;
                entity.UpdatedTime = currentTime;
                entity.UpdatedBy = currentUser.UserId;
                entity.UpdatedByUserName = currentUser.UserName;
                await _customerVatInfoRepository.UpdateAsync(entity);
                result.Result = Result.Success;
                result.Message = "Đặt làm mặc định thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.Failed;
                result.Message = $"Lỗi khi đặt làm mặc định: {ex.Message}";
            }

            return result;
        }

    }
}