using Ladaer.BackEnd.Infrastructures.DTO.Models.Finance;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Finances;
using Ladaer.BackEnd.Infrastructures.DTO.Results.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finance;
using Ladaer.BackEnd.Infrastructures.Services.Finances;
using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Lada.Framework.Infrastructures.Helpers;
using Lada.Framework.Data.Domains.Finance;

namespace Ladaer.BackEnd.Controllers.Finance
{
    /// <summary>
    /// Controller quản lý đối soát đơn hàng
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class ReconciliationController : ControllerBase
    {
        private readonly IReconciliationService _reconciliationService;

        /// <summary>
        /// Khởi tạo controller
        /// </summary>
        /// <param name="reconciliationService">Service quản lý đối soát</param>
        public ReconciliationController(IReconciliationService reconciliationService)
        {
            _reconciliationService = reconciliationService;
        }

        /// <summary>
        /// Tìm kiếm khách hàng cần đối soát với phân trang
        /// </summary>
        /// <param name="param">Tham số tìm kiếm</param>
        /// <returns>Kết quả tìm kiếm khách hàng cần đối soát</returns>
        [HttpPost("SearchCustomersForReconciliation")]
        [Authorize(Roles = "Reconciliation.View")]
        public async Task<IActionResult> SearchCustomersForReconciliation([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _reconciliationService.SearchCustomersForReconciliation(param, currentUser.UserId);
            return Ok(result);
        }

        /// <summary>
        /// Tìm kiếm đơn hàng có thể đối soát với phân trang
        /// </summary>
        /// <param name="param">Tham số tìm kiếm</param>
        /// <param name="reconciliationType">Loại đối soát (tùy chọn)</param>
        /// <returns>Kết quả tìm kiếm đơn hàng có thể đối soát</returns>
        [HttpPost("SearchReconciliableOrders")]
        [Authorize(Roles = "Reconciliation.View")]
        public async Task<IActionResult> SearchReconciliableOrders([FromBody] SmartTableParam param, [FromQuery] ReconciliationType? reconciliationType = null)
        {
            var result = await _reconciliationService.SearchReconciliableOrders(param, reconciliationType);
            return Ok(result);
        }

        /// <summary>
        /// Tìm kiếm đối soát
        /// </summary>
        /// <param name="param">Tham số tìm kiếm</param>
        /// <returns>Kết quả tìm kiếm đối soát</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "Reconciliation.View,Reconciliation.Confirm")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _reconciliationService.Search(param, currentUser.UserId);
            return Ok(result);
        }

        /// <summary>
        /// Lấy chi tiết đối soát
        /// </summary>
        /// <param name="id">ID đối soát</param>
        /// <returns>Chi tiết đối soát</returns>
        [HttpGet("GetById")]
        [Authorize(Roles = "Reconciliation.View,Reconciliation.Confirm")]
        public async Task<IActionResult> GetById(int id)
        {
            if (id <= 0)
            {
                return BadRequest("ID đối soát không hợp lệ");
            }
            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _reconciliationService.GetById(id, currentUser);
            if (result == null)
            {
                return NotFound("Không tìm thấy đối soát");
            }

            return Ok(result);
        }

        /// <summary>
        /// Tạo đối soát mới
        /// </summary>
        /// <param name="model">Thông tin đối soát</param>
        /// <returns>Kết quả thao tác</returns>
        [HttpPost("Create")]
        [Authorize(Roles = "Reconciliation.Create")]
        public async Task<IActionResult> Create([FromBody] CreateReconciliationModel model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            model.CreatedBy = currentUser.UserId;
            model.CreatedByUsername = currentUser.UserName;

            // Validate model
            var validationErrors = model.Validate();
            if (validationErrors.Any())
            {
                return BadRequest(string.Join("; ", validationErrors));
            }

            var result = await _reconciliationService.Create(model);
            return Ok(result);
        }

        /// <summary>
        /// Xác nhận đối soát
        /// </summary>
        /// <param name="id">ID đối soát</param>
        /// <returns>Kết quả thao tác</returns>
        [HttpPut("Confirm/{id}")]
        [Authorize(Roles = "Reconciliation.Confirm")]
        public async Task<IActionResult> Confirm(int id)
        {
            if (id <= 0)
            {
                return BadRequest("ID đối soát không hợp lệ");
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _reconciliationService.Confirm(id, currentUser);
            return Ok(result);
        }

        /// <summary>
        /// Cập nhật đã chuyển khoản
        /// </summary>
        /// <param name="model">Thông tin chuyển khoản</param>
        /// <returns>Kết quả thao tác</returns>
        [HttpPut("UpdateTransferred")]
        [Authorize(Roles = "Reconciliation.Transfer")]
        public async Task<IActionResult> UpdateTransferred([FromBody] TransferReconciliationModel model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            model.TransferredBy = currentUser.UserId;
            model.TransferredByUsername = currentUser.UserName;

            // Validate model
            var validationErrors = model.Validate();
            if (validationErrors.Any())
            {
                return BadRequest(string.Join("; ", validationErrors));
            }

            var result = await _reconciliationService.UpdateTransferred(model);
            return Ok(result);
        }

        /// <summary>
        /// Hủy đối soát với thông tin chi tiết
        /// </summary>
        /// <param name="model">Thông tin hủy đối soát</param>
        /// <returns>Kết quả thao tác</returns>
        [HttpPost("Cancel")]
        [Authorize(Roles = "Reconciliation.Cancel")]
        public async Task<IActionResult> Cancel([FromBody] CancelReconciliationModel model)
        {
            if (model == null)
            {
                return BadRequest("Thông tin hủy đối soát không được để trống");
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            // Set thông tin người hủy từ current user
            model.CancelledBy = currentUser.UserId;
            model.CancelledByUsername = currentUser.UserName;
            model.CancelledTime = DateTimeOffset.UtcNow;

            var result = await _reconciliationService.Cancel(model);
            return Ok(result);
        }

        /// <summary>
        /// Hủy đối soát (phương thức cũ - deprecated)
        /// </summary>
        /// <param name="id">ID đối soát</param>
        /// <returns>Kết quả thao tác</returns>
        [HttpPut("Cancel/{id}")]
        [Authorize(Roles = "Reconciliation.Cancel")]
        [Obsolete("Sử dụng Cancel([FromBody] CancelReconciliationModel model) thay thế")]
        public async Task<IActionResult> Cancel(int id)
        {
            if (id <= 0)
            {
                return BadRequest("ID đối soát không hợp lệ");
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _reconciliationService.Cancel(id, currentUser);
            return Ok(result);
        }

        /// <summary>
        /// Upload ảnh chứng từ chuyển khoản
        /// </summary>
        /// <param name="reconciliationId">ID đối soát</param>
        /// <param name="files">Danh sách file ảnh</param>
        /// <returns>Kết quả upload</returns>
        [HttpPost("UploadTransferProof/{reconciliationId}")]
        [Authorize(Roles = "Reconciliation.Transfer")]
        public Task<IActionResult> UploadTransferProof(int reconciliationId, List<IFormFile> files)
        {
            if (reconciliationId <= 0)
            {
                return Task.FromResult<IActionResult>(BadRequest("ID đối soát không hợp lệ"));
            }

            if (files == null || !files.Any())
            {
                return Task.FromResult<IActionResult>(BadRequest("Vui lòng chọn ít nhất một file ảnh"));
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser == null)
            {
                return Task.FromResult<IActionResult>(BadRequest("Không xác định được người dùng"));
            }

            // TODO: Implement upload ảnh chứng từ
            // 1. Validate file (định dạng, kích thước)
            // 2. Upload file lên server/cloud
            // 3. Lưu thông tin file vào database
            // 4. Liên kết với đối soát

            return Task.FromResult<IActionResult>(Ok(new { Message = "Upload ảnh chứng từ thành công" }));
        }

        /// <summary>
        /// Lấy danh sách ảnh chứng từ chuyển khoản
        /// </summary>
        /// <param name="reconciliationId">ID đối soát</param>
        /// <returns>Danh sách ảnh chứng từ</returns>
        [HttpGet("GetTransferProof/{reconciliationId}")]
        [Authorize(Roles = "Reconciliation.View")]
        public Task<IActionResult> GetTransferProof(int reconciliationId)
        {
            if (reconciliationId <= 0)
            {
                return Task.FromResult<IActionResult>(BadRequest("ID đối soát không hợp lệ"));
            }

            // TODO: Implement lấy danh sách ảnh chứng từ
            // 1. Query từ database
            // 2. Trả về danh sách URL ảnh

            return Task.FromResult<IActionResult>(Ok(new List<object>()));
        }

        #region Excel Export

        /// <summary>
        /// Xuất Excel danh sách phiếu đối soát
        /// </summary>
        /// <param name="model">Model xuất Excel</param>
        /// <returns>Kết quả xuất file</returns>
        [HttpPost("ExportExcel")]
        [Authorize(Roles = "Reconciliation.ExportExcel")]
        public Task<IActionResult> ExportExcel([FromBody] ReconciliationExcelExportModel model)
        {
            try
            {
                var currentUser = User.GetCurrentUser();
                if (currentUser == null)
                {
                    return Task.FromResult<IActionResult>(BadRequest("Không xác định được người dùng"));
                }

                if (!ModelState.IsValid)
                {
                    return Task.FromResult<IActionResult>(BadRequest(ModelState));
                }

                // Set thông tin người tạo
                model.UpdatedBy = currentUser.UserId;
                model.UpdatedByUserName = currentUser.UserName;

                // TODO: Inject IReconciliationExcelService và gọi method export
                // var result = await _reconciliationExcelService.ExportReconciliationsAsync(model);

                // Tạm thời trả về response mẫu
                var result = new ReconciliationExcelExportResult
                {
                    Result = Result.Success,
                    Message = "Chức năng xuất Excel đang được phát triển",
                    FileName = "DanhSachPhieuDoiSoat.xlsx",
                    TotalRecords = 0
                };

                if (result.Result == Result.Success)
                {
                    return Task.FromResult<IActionResult>(Ok(result));
                }
                else
                {
                    return Task.FromResult<IActionResult>(BadRequest(result));
                }
            }
            catch (Exception ex)
            {
                return Task.FromResult<IActionResult>(StatusCode(500, new ReconciliationExcelExportResult
                {
                    Result = Result.SystemError,
                    Message = $"Lỗi hệ thống: {ex.Message}"
                }));
            }
        }

        /// <summary>
        /// Xuất Excel chi tiết phiếu đối soát
        /// </summary>
        /// <param name="reconciliationId">ID phiếu đối soát</param>
        /// <param name="model">Model xuất Excel</param>
        /// <returns>Kết quả xuất file</returns>
        [HttpPost("ExportExcelDetail/{reconciliationId}")]
        [Authorize(Roles = "Reconciliation.ExportExcel")]
        public Task<IActionResult> ExportExcelDetail(int reconciliationId, [FromBody] ReconciliationExcelExportModel model)
        {
            try
            {
                if (reconciliationId <= 0)
                {
                    return Task.FromResult<IActionResult>(BadRequest("ID phiếu đối soát không hợp lệ"));
                }

                var currentUser = User.GetCurrentUser();
                if (currentUser == null)
                {
                    return Task.FromResult<IActionResult>(BadRequest("Không xác định được người dùng"));
                }

                if (!ModelState.IsValid)
                {
                    return Task.FromResult<IActionResult>(BadRequest(ModelState));
                }

                // Set thông tin người tạo
                model.UpdatedBy = currentUser.UserId;
                model.UpdatedByUserName = currentUser.UserName;

                // TODO: Inject IReconciliationExcelService và gọi method export detail
                // var result = await _reconciliationExcelService.ExportReconciliationDetailAsync(reconciliationId, model);

                // Tạm thời trả về response mẫu
                var result = new ReconciliationExcelExportResult
                {
                    Result = Result.Success,
                    Message = "Chức năng xuất Excel chi tiết đang được phát triển",
                    FileName = $"ChiTietPhieuDoiSoat_{reconciliationId}.xlsx",
                    TotalRecords = 1
                };

                if (result.Result == Result.Success)
                {
                    return Task.FromResult<IActionResult>(Ok(result));
                }
                else
                {
                    return Task.FromResult<IActionResult>(BadRequest(result));
                }
            }
            catch (Exception ex)
            {
                return Task.FromResult<IActionResult>(StatusCode(500, new ReconciliationExcelExportResult
                {
                    Result = Result.SystemError,
                    Message = $"Lỗi hệ thống: {ex.Message}"
                }));
            }
        }

        #endregion
    }
}
