using CPRNIMS.Domain.Services;
using CPRNIMS.Domain.UIContracts.Account;
using CPRNIMS.Domain.UIContracts.PR;
using CPRNIMS.Infrastructure.Dto.PR;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.PR;
using CPRNIMS.WebApps.Controllers.Base;
using Microsoft.AspNetCore.Mvc;

namespace CPRNIMS.WebApps.Controllers.PR
{
    public class PRMgmtController : BaseMethod
    {
        List<PRVM>? response;
        private readonly IPRequest _pRequest;
        public PRMgmtController(TokenHelper tokenHelper, ErrorLogHelper errorMessageService,
         IWebHostEnvironment webHostEnvironment
         , IPRequest pRequest, IConfiguration configuration,IAccount account)
         : base(errorMessageService, webHostEnvironment, tokenHelper, account)
        {
            _pRequest = pRequest;
        }
        #region Get
        private async Task<IActionResult> GetProductFile(string fileName)
        {
            try
            {
                // Validate filename
                if (string.IsNullOrWhiteSpace(fileName) || fileName.Contains(".."))
                {
                    return BadRequest("Invalid file name");
                }

                var uploadsPath = Path.Combine(_webHostEnvironment.WebRootPath, "Content/Uploads", "PRAttachment");
                var filePath = Path.Combine(uploadsPath, fileName);

                ContentTypeHelper.ValidateFile(filePath, uploadsPath);

                // Stream the file instead of loading entirely into memory
                var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                var contentType = ContentTypeHelper.GetContentType(fileName);

                return File(fileStream, contentType, fileName, enableRangeProcessing: true);
            }
            catch (Exception ex)
            {
                return StatusCode(500, "Error retrieving file");
            }
        }
        public async Task<IActionResult> GetProjectCodes(PRVM viewModels)
        {
            response = await _pRequest.GetProjectCodes(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetApproverName(PRVM viewModels)
        {
            response = await _pRequest.GetApproverName(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetAllPR(PRVM viewModels)
        {
            response = await _pRequest.GetAllPR(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRDetailByPRNo(PRVM viewModels)
        {
            response = await _pRequest.GetPRDetailByPRNo(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRListByPRNo(PRVM viewModels)
        {
            response = await _pRequest.GetPRListByPRNo(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetMyPR(PRVM viewModels)
        {
            response = await _pRequest.GetMyPR(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForReceiving()
        {
            var viewModels = new PRVM();
            response = await _pRequest.GetForReceiving(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetDeniedItem(PRVM viewModels)
        {
            response = await _pRequest.GetForReceiving(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRByRRId(PRVM viewModel)
        {
            response = await _pRequest.GetPRByRRId(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetRRDetailByPO(PRVM viewModel)
        {
            response = await _pRequest.GetRRDetailByPO(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRStatusById(PRVM viewModel)
        {
            response = await _pRequest.GetPRStatusById(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetItemDetailForReceiving(PRVM viewModel)
        {
            response = await _pRequest.GetItemDetailForReceiving(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetDetailedPRTracking(PRVM viewModel)
        {
            response = await _pRequest.GetDetailedPRTracking(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierAlternativeOffer(PRVM viewModel)
        {
            response = await _pRequest.GetSupplierAlternativeOffer(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierAlterOfferDetails(PRVM viewModel)
        {
            response = await _pRequest.GetSupplierAlterOfferDetails(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetDashBoard()
        {
            var viewModel = new PRVM();

            response = await _pRequest.GetDashBoard(GetUser(), viewModel);

            return GetResponse(response);
        }
        private PRList MapToPRItemList(IEnumerable<PRList> prList)
        {
            if (prList == null || !prList.Any())
            {
                return new PRList
                {
                    PRDetailsId = new List<long>(),
                    ItemNo = new List<long>(),
                };
            }

            return new PRList
            {
                PRDetailsId = prList.SelectMany(ic => ic.PRDetailsId).ToList(),
                ItemNo = prList.SelectMany(ic => ic.ItemNo).ToList()
            };
        }
        #endregion
        #region POST PUT
        public async Task<IActionResult> PostPutProjectCode([FromBody] PRVM viewModel)
        {
            var postPutItem = await _pRequest.PostPutProjectCode(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message });
            }
            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> ApprovedSelectedPRItem(PRVM viewModel,
            List<PRList> PRList)
        {
            viewModel.PRList = MapToPRItemList(PRList);

            var postPutItem = await _pRequest.ApprovedSelectedPRItem(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutDeniedItem(PRVM viewModel, List<ItemReceivingList> ItemList)
        {
            if (ItemList.Count > 0)
            {
                viewModel.ItemList = new ItemReceivingList
                {
                    PRDetailsId = ItemList.SelectMany(ic => ic.PRDetailsId).ToList(),
                    PRNo = ItemList.SelectMany(ic => ic.PRNo).ToList(),
                    ItemNo = ItemList.SelectMany(ic => ic.ItemNo).ToList(),
                };
                var postPutItem = await _pRequest.PostPutDeniedItem(GetUser(), viewModel);

                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true, Response = postPutItem.Message });
                }

                return Json(new { success = false, Response = postPutItem.Message });
            }
            return Json(new { success = false, Response = "EmptyArray" });
        }
        public async Task<IActionResult> PutItemDetail(PRVM viewModel)
        {
            var postPutItem = await _pRequest.PutItemDetail(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPRApproveReject(PRVM viewModel)
        {
            var postPutItem = await _pRequest.PostPRApproveReject(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutSupplierAlterOffer(PRVM viewModel)
        {
            var postPutItem = await _pRequest.PutSupplierAlterOffer(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message });
            }
            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PRItemRemoval(PRVM viewModel)
        {
            var postPutItem = await _pRequest.PRItemRemoval(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true , Response = postPutItem.Message });
            }
            return Json(new { success = false, Response = postPutItem.Message });
        }
        #endregion
        #region Views
        public IActionResult GetDashBoardById(int DashboardId)
        {
            return ViewComponent("Dashboard", new { dashboardId = DashboardId });
        }
        public async Task<IActionResult> DashBoard()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> Index()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PRArchived()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> DeniedItem()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PRTracking()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> AlterOffer()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> ProjectCode()
        {
            return await IsAuthenTicated();
        }
        #endregion
    }
}