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

namespace Ladaer.BackEnd.Controllers.Ops
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class TruckController : ControllerBase
    {
        private readonly ITruckService _truckService;
        private readonly ITruckAssetService _truckAssetService;
        private readonly ITruckActivityService _truckActivityService;
        private readonly IUserService _userService;
        private readonly IRepository<Truck> _truckRepository;

        public TruckController(ITruckService truckService,
            ITruckAssetService truckAssetService,
            ITruckActivityService truckActivityService,
            IUserService userService,
            IRepository<Truck> truckRepository)
        {
            _truckService = truckService;
            _truckAssetService = truckAssetService;
            _truckActivityService = truckActivityService;
            _userService = userService;
            _truckRepository = truckRepository;
        }

        #region Truck Management

        /// <summary>
        /// Tạo hoặc cập nhật thông tin xe tải
        /// </summary>
        /// <param name="model">Thông tin xe tải</param>
        /// <returns>Kết quả tạo hoặc cập nhật</returns>
        [HttpPost("CreateOrUpdate")]
        [Authorize(Roles = "Truck.CreateOrUpdate")]
        public async Task<IActionResult> CreateOrUpdate([FromForm] TruckModel model)
        {
            var rs = await _truckService.CreateOrUpdate(model);
            return Ok(rs);
        }

        /// <summary>
        /// Lấy thông tin xe tải theo danh sách ID
        /// </summary>
        /// <param name="ids">Danh sách ID xe tải</param>
        /// <returns>Danh sách thông tin xe tải</returns>
        [HttpPost("GetTruckByIds")]
        [Authorize(Roles = "Truck.GetTruckByIds")]
        public async Task<IActionResult> GetTruckByIds(KeyModels<int> ids)
        {
            var rs = await _truckService.GetByIds(ids);
            return Ok(rs);
        }


        /// <summary>
        /// Lấy thông tin chi tiết của một xe tải dựa trên ID.
        /// </summary>
        /// <param name="id">ID của xe tải.</param>
        /// <returns>Thông tin chi tiết của xe tải.</returns>
        [HttpGet("GetById")]
        [Authorize(Roles = "Truck.GetById")]
        public async Task<IActionResult> GetById(int id)
        {
            var result = await _truckService.GetById(id);
            return Ok(result);
        }

        /// <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>
        [HttpGet("GetTruckMedia")]
        [Authorize(Roles = "Truck.GetById")]
        public async Task<IActionResult> GetTruckMedia(int truckId)
        {
            var result = await _truckService.GetTruckMediaAsync(truckId);
            return Ok(result);
        }

        /// <summary>
        /// Lấy thông tin xe tải theo ID đơn vị
        /// </summary>
        /// <param name="id">ID đơn vị</param>
        /// <returns>Danh sách thông tin xe tải</returns>
        [HttpGet("GetTruckByAgencyId")]
        [Authorize(Roles = "Truck.GetTruckByAgencyId")]
        public async Task<IActionResult> GetTruckByAgencyId(int id)
        {
            var rs = await _truckService.GetTruckByAgencyId(id);
            return Ok(rs);
        }

        /// <summary>
        /// Tìm kiếm xe tải dựa trên tham số SmartTableParam
        /// </summary>
        /// <param name="model">Tham số tìm kiếm</param>
        /// <returns>Danh sách xe tải phù hợp</returns>
        [HttpPost("TruckSearch")]
        [Authorize(Roles = "Truck.TruckSearch")]
        public async Task<IActionResult> TruckSearch(SmartTableParam model)
        {
            var rs = await _truckService.Search(model);
            return Ok(rs);
        }

        /// <summary>
        /// Xóa xe tải
        /// </summary>
        /// <param name="id">ID xe tải cần xóa</param>
        /// <returns>Kết quả xóa</returns>
        [HttpPost("TruckDelete")]
        [Authorize(Roles = "Truck.TruckDelete")]
        public async Task<IActionResult> TruckDelete([FromQuery] int id)
        {
            var rs = await _truckService.Delete(id);
            return Ok(rs);
        }

        /// <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>
        [HttpGet("GetActivityHistory/{truckId}")]
        [Authorize(Roles = "Truck.GetTruckActivityHistory")]
        public async Task<IActionResult> GetTruckActivityHistory(int truckId)
        {
            var rs = await _truckService.GetTruckActivityHistory(truckId);
            return Ok(rs);
        }

        #endregion

        #region Truck Specification

        /// <summary>
        /// Lấy tất cả thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="truckId">ID xe tải</param>
        /// <returns>Danh sách thông số kỹ thuật</returns>
        [HttpGet("TruckSpecGetAll")]
        [Authorize(Roles = "Truck.TruckSpecGetAll")]
        public async Task<IActionResult> TruckSpecGetAll(int truckId)
        {
            var rs = await _truckService.TruckSpecGetAll(new TruckSpecificationModel { TruckId = truckId });
            return Ok(rs);
        }

        /// <summary>
        /// Tạo hoặc cập nhật thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="model">Thông tin thông số kỹ thuật</param>
        /// <returns>Kết quả tạo hoặc cập nhật</returns>
        [HttpPost("TruckSpecCreateOrUpdate")]
        [Authorize(Roles = "Truck.TruckSpecCreateOrUpdate")]
        public async Task<IActionResult> TruckSpecCreateOrUpdate(TruckSpecificationModel model)
        {
            var rs = await _truckService.TruckSpecCreateOrUpdate(model);
            return Ok(rs);
        }

        /// <summary>
        /// Xóa thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="model">Thông tin thông số kỹ thuật</param>
        /// <returns>Kết quả xóa</returns>
        [HttpPost("TruckSpecDelete")]
        [Authorize(Roles = "Truck.TruckSpecDelete")]
        public async Task<IActionResult> TruckSpecDelete(TruckSpecificationModel model)
        {
            var rs = await _truckService.TruckSpecDelete(model);
            return Ok(rs);
        }

        #endregion

        #region Truck Specification Attribute

        /// <summary>
        /// Tìm kiếm thuộc tính thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="model">Tham số tìm kiếm</param>
        /// <returns>Danh sách thuộc tính thông số kỹ thuật</returns>
        [HttpPost("TruckSpecAttrSearch")]
        [Authorize(Roles = "Truck.TruckSpecAttrSearch")]
        public async Task<IActionResult> TruckSpecAttrSearch(SmartTableParam model)
        {
            var rs = await _truckService.TruckSpecAttrSearch(model);
            return Ok(rs);
        }

        /// <summary>
        /// Lấy tất cả thuộc tính thông số kỹ thuật của xe tải
        /// </summary>
        /// <returns>Danh sách thuộc tính thông số kỹ thuật</returns>
        [HttpGet("TruckSpecAttrGetAll")]
        [Authorize(Roles = "Truck.TruckSpecAttrGetAll")]
        public async Task<IActionResult> TruckSpecAttrGetAll()
        {
            var rs = await _truckService.TruckSpecAttrGetAll();
            return Ok(rs);
        }

        /// <summary>
        /// Tạo hoặc cập nhật thuộc tính thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="model">Thông tin thuộc tính thông số kỹ thuật</param>
        /// <returns>Kết quả tạo hoặc cập nhật</returns>
        [HttpPost("TruckSpecAttrCreateOrUpdate")]
        [Authorize(Roles = "Truck.TruckSpecAttrCreateOrUpdate")]
        public async Task<IActionResult> TruckSpecAttrCreateOrUpdate(TruckSpecAttributeModel model)
        {
            var rs = await _truckService.TruckSpecAttrCreateOrUpdate(model);
            return Ok(rs);
        }

        /// <summary>
        /// Xóa thuộc tính thông số kỹ thuật của xe tải
        /// </summary>
        /// <param name="model">Thông tin thuộc tính thông số kỹ thuật</param>
        /// <returns>Kết quả xóa</returns>
        [HttpPost("TruckSpecAttrDelete")]
        [Authorize(Roles = "Truck.TruckSpecAttrDelete")]
        public async Task<IActionResult> TruckSpecAttrDelete(TruckSpecAttributeModel model)
        {
            var rs = await _truckService.TruckSpecAttrDelete(model);
            return Ok(rs);
        }

        #endregion

        #region Truck Maintenance Attribute

        /// <summary>
        /// Tìm kiếm thuộc tính bảo trì của xe tải
        /// </summary>
        /// <param name="model">Tham số tìm kiếm</param>
        /// <returns>Danh sách thuộc tính bảo trì</returns>
        [HttpPost("TruckMaintAttrSearch")]
        [Authorize(Roles = "Truck.TruckMaintAttrSearch")]
        public async Task<IActionResult> TruckMaintAttrSearch(SmartTableParam model)
        {
            var rs = await _truckService.TruckMaintAttrSearch(model);
            return Ok(rs);
        }

        /// <summary>
        /// Lấy tất cả thuộc tính bảo trì của xe tải
        /// </summary>
        /// <returns>Danh sách thuộc tính bảo trì</returns>
        [HttpGet("TruckMaintAttrGetAll")]
        [Authorize(Roles = "Truck.TruckMaintAttrGetAll")]
        public async Task<IActionResult> TruckMaintAttrGetAll()
        {
            var rs = await _truckService.TruckMaintAttrGetAll();
            return Ok(rs);
        }

        /// <summary>
        /// Tạo hoặc cập nhật thuộc tính bảo trì của xe tải
        /// </summary>
        /// <param name="model">Thông tin thuộc tính bảo trì</param>
        /// <returns>Kết quả tạo hoặc cập nhật</returns>
        [HttpPost("TruckMaintAttrCreateOrUpdate")]
        [Authorize(Roles = "Truck.TruckMaintAttrCreateOrUpdate")]
        public async Task<IActionResult> TruckMaintAttrCreateOrUpdate(TruckMaintAttributeModel model)
        {
            var rs = await _truckService.TruckMaintAttrCreateOrUpdate(model);
            return Ok(rs);
        }

        /// <summary>
        /// Xóa thuộc tính bảo trì của xe tải
        /// </summary>
        /// <param name="model">Thông tin thuộc tính bảo trì</param>
        /// <returns>Kết quả xóa</returns>
        [HttpPost("TruckMaintAttrDelete")]
        [Authorize(Roles = "Truck.TruckMaintAttrDelete")]
        public async Task<IActionResult> TruckMaintAttrDelete(TruckMaintAttributeModel model)
        {
            var rs = await _truckService.TruckMaintAttrDelete(model);
            return Ok(rs);
        }

        #endregion

        #region Truck Maintenance Link

        /// <summary>
        /// Lấy tất cả liên kết bảo trì của xe tải
        /// </summary>
        /// <param name="truckMaintId">ID bảo trì xe tải</param>
        /// <returns>Danh sách liên kết bảo trì</returns>
        [HttpGet("TruckMaintLinkGetAll")]
        [Authorize(Roles = "Truck.TruckMaintLinkGetAll")]
        public async Task<IActionResult> TruckMaintLinkGetAll(int truckMaintId)
        {
            var rs = await _truckService.TruckMaintLinkGetAll(new TruckMaintLinkModel { TruckMaintenanceId = truckMaintId });
            return Ok(rs);
        }

        #endregion

        #region Truck Maintenance

        /// <summary>
        /// Tìm kiếm bảo trì xe tải
        /// </summary>
        /// <param name="model">Tham số tìm kiếm</param>
        /// <returns>Danh sách bảo trì xe tải</returns>
        [HttpPost("TruckMaintSearch")]
        [Authorize(Roles = "Truck.TruckMaintSearch")]
        public async Task<IActionResult> TruckMaintSearch(SmartTableParam model)
        {
            var rs = await _truckService.TruckMaintSearch(model);
            return Ok(rs);
        }

        /// <summary>
        /// Lấy thông tin bảo trì xe tải theo danh sách ID
        /// </summary>
        /// <param name="model">Danh sách ID bảo trì xe tải</param>
        /// <returns>Danh sách thông tin bảo trì xe tải</returns>
        [HttpPost("TruckMaintByIds")]
        [Authorize(Roles = "Truck.TruckMaintByIds")]
        public async Task<IActionResult> TruckMaintByIds(KeyModels<int> model)
        {
            var rs = await _truckService.TruckMaintByIds(model);
            return Ok(rs);
        }

        /// <summary>
        /// Tạo hoặc cập nhật thông tin bảo trì xe tải
        /// </summary>
        /// <param name="model">Thông tin bảo trì xe tải</param>
        /// <returns>Kết quả tạo hoặc cập nhật</returns>
        [HttpPost("TruckMaintCreateOrUpdate")]
        [Authorize(Roles = "Truck.TruckMaintCreateOrUpdate")]
        public async Task<IActionResult> TruckMaintCreateOrUpdate(TruckMaintenanceModel model)
        {
            var rs = new BaseResult();
            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;

            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                rs.Result = Lada.Framework.DTO.Result.Failed;
                rs.Message = $"Không xác định được người dùng {currentUser.UserId} - {currentUser.UserName} ";

                return Ok(rs);
            }
            rs = await _truckService.TruckMaintCreateOrUpdate(model);
            return Ok(rs);
        }

        /// <summary>
        /// Xóa thông tin bảo trì xe tải
        /// </summary>
        /// <param name="model">Thông tin bảo trì xe tải</param>
        /// <returns>Kết quả xóa</returns>
        [HttpPost("TruckMaintDelete")]
        [Authorize(Roles = "Truck.TruckMaintDelete")]
        public async Task<IActionResult> TruckMaintDelete(TruckMaintenanceModel model)
        {
            var rs = new BaseResult();
            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;

            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                rs.Result = Lada.Framework.DTO.Result.Failed;
                rs.Message = $"Không xác định được người dùng {currentUser.UserId} - {currentUser.UserName} ";

                return Ok(rs);
            }
            rs = await _truckService.TruckMaintDelete(model);
            return Ok(rs);
        }

        #endregion

        #region Truck Activity

        /// <summary>
        /// Lấy danh sách tất cả xe tải thuộc chi nhánh của người dùng hiện tại
        /// </summary>
        /// <returns>Danh sách tất cả xe tải thuộc chi nhánh</returns>
        [HttpGet("GetTrucksByAgency")]
        [Authorize(Roles = "DriverTruck.GetTrucksByAgency")]
        public async Task<IActionResult> GetTrucksByAgency()
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser.UserId <= 0)
            {
                return BadRequest("Không xác định được người dùng");
            }

            var agencyId = await _userService.GetAgencyIdByIdAsync(currentUser.UserId);
            if (agencyId <= 0)
            {
                return BadRequest("Người dùng không thuộc đơn vị nào");
            }

            var result = await _truckService.GetTruckByAgencyId(agencyId);
            return Ok(result);
        }


        /// <summary>
        /// Nạp dầu cho xe với upload hình ảnh và thông tin ODO
        /// </summary>
        /// <param name="model">Thông tin nạp dầu</param>
        /// <returns>Kết quả nạp dầu</returns>
        [HttpPost("FuelRefillTruck")]
        [Authorize(Roles = "Truck.FuelRefillTruck")]
        public async Task<IActionResult> FuelRefillTruck([FromForm] TruckFuelRefillModel model)
        {
            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;

            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                return BadRequest("Không xác định được người dùng");
            }

            // Lấy AgencyId từ thông tin người dùng
            var agencyId = await _userService.GetAgencyIdByIdAsync(currentUser.UserId);
            if (agencyId <= 0)
            {
                return BadRequest("Người dùng không thuộc đơn vị nào");
            }
            model.AgencyId = agencyId;

            var result = await _truckActivityService.FuelRefillTruck(model);
            return Ok(result);
        }

        /// <summary>
        /// Lấy hoạt động xe tải theo danh sách ID
        /// </summary>
        /// <param name="ids">Danh sách ID hoạt động xe tải</param>
        /// <returns>Thông tin hoạt động xe tải</returns>
        [HttpPost("GetTruckActivityByIds")]
        [Authorize(Roles = "Truck.GetTruckActivityByIds")]
        public async Task<IActionResult> GetTruckActivityByIds(KeyModels<int> ids)
        {
            var result = await _truckActivityService.GetByIds(ids);
            return Ok(result);
        }

        /// <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>
        [HttpPost("UpdateLastRefillOdo")]
        [Authorize(Roles = "Truck.UpdateLastRefillOdo")]
        public async Task<IActionResult> UpdateLastRefillOdo([FromQuery] int truckId, [FromQuery] int odoValue)
        {
            var result = await _truckService.UpdateLastRefillOdo(truckId, odoValue);
            return Ok(result);
        }

        /// <summary>
        /// Lấy giá trị ODO đổ dầu gần nhất của xe tải
        /// </summary>
        /// <param name="truckId">ID xe tải</param>
        /// <returns>Giá trị ODO đổ dầu gần nhất</returns>
        [HttpGet("GetLastRefillOdo")]
        [Authorize(Roles = "Truck.GetLastRefillOdo")]
        public async Task<IActionResult> GetLastRefillOdo([FromQuery] int truckId)
        {
            if (truckId <= 0)
            {
                return BadRequest("ID xe tải không hợp lệ");
            }

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

            return Ok(new
            {
                TruckId = truck.Id,
                LicensePlate = truck.LicensePlate,
                LastRefillOdo = truck.LastRefillOdo
            });
        }

        #endregion
    }
}
