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

namespace Ladaer.BackEnd.Infrastructures.Services.Finance
{
    public interface IBankService
    {
        Task<SmartTableResult<BankItem>> Search(SmartTableParam param);
        Task<List<BankItem>> GetAll();
        Task<BankModel?> GetById(int id);
        Task<BankResult> CreateOrUpdate(BankModel model);
        Task<BankResult> Create(BankModel model);
        Task<BankResult> Update(BankModel model);
        Task<BankResult> Delete(int id);
        Task<List<BankOptionItem>> SugBank(string keyword = "", int limit = 20);
    }

    /// <summary>
    /// Service quản lý ngân hàng
    /// </summary>
    public class BankService : IBankService
    {
        private readonly IRepository<Bank> _bankRepository;

        public BankService(IRepository<Bank> bankRepository)
        {
            _bankRepository = bankRepository;
        }

        /// <summary>
        /// Tìm kiếm ngân hàng với phân trang
        /// </summary>
        public async Task<SmartTableResult<BankItem>> Search(SmartTableParam param)
        {
            var query = _bankRepository.Query();

            // Tìm kiếm theo từ khóa
            if (param.Search?.PredicateObject != null)
            {
                dynamic search = param.Search.PredicateObject;
                if (search.Keyword != null)
                {
                    string keyword = search.Keyword;
                    keyword = keyword.Trim().ToLower();
                    if (!string.IsNullOrEmpty(keyword))
                    {
                        query = query.Where(b =>
                            b.BrandName.ToLower().Contains(keyword) ||
                            b.FullName.ToLower().Contains(keyword));
                    }
                }
            }

            param.Sort = new Sort() { Predicate = "Id", Reverse = false };

            // Sử dụng SmartTableExtension để xử lý phân trang
            return await query.ToSmartTableResultAsync(param, bank => bank.ToItem());
        }

        /// <summary>
        /// Lấy tất cả ngân hàng đang hoạt động
        /// </summary>
        public async Task<List<BankItem>> GetAll()
        {
            var banks = _bankRepository.Query()
                .Where(b => !b.IsDeleted)
                .OrderBy(b => b.BrandName)
                .ToList();

            return banks.Select(bank => bank.ToItem()).ToList();
        }

        /// <summary>
        /// Lấy ngân hàng theo ID (trả về model để edit)
        /// </summary>
        public async Task<BankModel?> GetById(int id)
        {
            var bank = await _bankRepository.GetByIdAsync(id);
            if (bank == null || bank.IsDeleted)
                return null;

            return bank.ToModel();
        }

        /// <summary>
        /// Tạo hoặc cập nhật ngân hàng
        /// </summary>
        public async Task<BankResult> CreateOrUpdate(BankModel model)
        {
            if (model == null)
            {
                return new BankResult
                {
                    Result = Result.Failed,
                    Message = "Dữ liệu không hợp lệ"
                };
            }

            return model.Id > 0
                ? await Update(model)
                : await Create(model);
        }

        /// <summary>
        /// Tạo ngân hàng mới
        /// </summary>
        public async Task<BankResult> Create(BankModel model)
        {
            var result = new BankResult();

            try
            {
                // Tạo entity mới
                var bank = model.ToEntity();
                bank.CreatedTime = DateTimeOffset.Now;
                bank.UpdatedTime = DateTimeOffset.Now;

                await _bankRepository.InsertAsync(bank);

                result.Result = Result.Success;
                result.Message = "Tạo ngân hàng thành công";
                result.Key = bank.Id;
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = $"Lỗi hệ thống: {ex.Message}";
            }

            return result;
        }

        /// <summary>
        /// Cập nhật ngân hàng
        /// </summary>
        public async Task<BankResult> Update(BankModel model)
        {
            var result = new BankResult();

            try
            {
                var bank = await _bankRepository.GetByIdAsync(model.Id);
                if (bank == null || bank.IsDeleted)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy ngân hàng";
                    return result;
                }

                // Cập nhật thông tin
                var updatedBank = model.ToEntity();
                bank.BrandName = updatedBank.BrandName;
                bank.FullName = updatedBank.FullName;
                bank.BankCode = updatedBank.BankCode;
                bank.DisplayOrder = updatedBank.DisplayOrder;
                bank.UpdatedTime = DateTimeOffset.Now;

                await _bankRepository.UpdateAsync(bank);

                result.Result = Result.Success;
                result.Message = "Cập nhật ngân hàng thành công";
                result.Key = bank.Id;
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = $"Lỗi hệ thống: {ex.Message}";
            }

            return result;
        }

        /// <summary>
        /// Xóa ngân hàng
        /// </summary>
        public async Task<BankResult> Delete(int id)
        {
            var result = new BankResult();

            try
            {
                var bank = await _bankRepository.GetByIdAsync(id);
                if (bank == null || bank.IsDeleted)
                {
                    result.Result = Result.Failed;
                    result.Message = "Không tìm thấy ngân hàng";
                    return result;
                }

                // Soft delete
                bank.IsDeleted = true;
                bank.UpdatedTime = DateTimeOffset.Now;

                await _bankRepository.UpdateAsync(bank);

                result.Result = Result.Success;
                result.Message = "Xóa ngân hàng thành công";
            }
            catch (Exception ex)
            {
                result.Result = Result.SystemError;
                result.Message = $"Lỗi hệ thống: {ex.Message}";
            }

            return result;
        }

        /// <summary>
        /// Gợi ý ngân hàng theo từ khóa (cho select option)
        /// </summary>
        public async Task<List<BankOptionItem>> SugBank(string keyword = "", int limit = 20)
        {
            var query = _bankRepository.Query()
                .Where(b => !b.IsDeleted);

            // Tìm kiếm theo từ khóa
            if (!string.IsNullOrEmpty(keyword))
            {
                var searchValue = keyword.ToLower();
                query = query.Where(b =>
                    b.BrandName.ToLower().Contains(searchValue) ||
                    b.FullName.ToLower().Contains(searchValue));
            }

            var banks = query
                .OrderBy(b => b.BrandName)
                .Take(limit)
                .ToList();

            return banks.Select(bank => bank.ToOptionItem()).ToList();
        }
    }
}
