using CPRNIMS.Domain.UIContracts.PO;
using CPRNIMS.Infrastructure.Entities.PO;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.PO;
using CPRNIMS.WebApps.Controllers.Base;
using Microsoft.AspNetCore.Mvc;

namespace CPRNIMS.WebApps.Controllers.PO
{
    public class POMgmtController : BaseMethod
    {
        #region Constructor
        List<POVM>? response;
        POVM postPutItem;

        private readonly IPurchaseOrder _purchaseOrder;
        public POMgmtController(TokenHelper tokenHelper, 
            ErrorLogHelper errorMessageService, IWebHostEnvironment webHostEnvironment
         , IPurchaseOrder purchaseOrder
            ) : base(tokenHelper, errorMessageService, webHostEnvironment)
        {
            _purchaseOrder = purchaseOrder;
        }
        #endregion
        #region POST PUT 
        [HttpPost]
        public async Task<IActionResult> DeleteIncShip(POVM viewModel)
        {
            var postPutItem = await _purchaseOrder.DeleteIncShip(await 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> PostPutIncoterms(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostPutIncoterms(await GetUser(), viewModel);

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

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutDocRequired(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostPutDocRequired(await GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPOToSupplier(POVM viewModel)
        {
             postPutItem = await _purchaseOrder.PostPOToSupplier(await GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutPO(POVM viewModel, List<DocRequirementList> DocRequiredList)
        {
            viewModel.DocRequiredList = MapToDocReqList(DocRequiredList);
            postPutItem = await _purchaseOrder.PostPutPO(await GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, Response = postPutItem.Message });         
        }
        public async Task<IActionResult> PostPutCustomPO(POVM viewModel, 
            List<DocRequirementList> DocRequiredList,
             List<POChargesList> OtherChargesList,
             List<PRItemList> PRItemList
            )
        {
            viewModel.DocRequiredList = MapToDocReqList(DocRequiredList);
            viewModel.OtherChargesList = MapToPOChargesList(OtherChargesList);
            viewModel.PRItemList = MapToPRItemList(PRItemList);

            postPutItem = await _purchaseOrder.PostPutCustomPO(await GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message, data = postPutItem.Data });
            }
            return Json(new { success = false, Response = postPutItem.Message });       
        }
        public async Task<IActionResult> PutPOCancel(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPOCancel(await GetUser(), viewModel);
            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message, 
                    data = postPutItem.Data });
            }
            return Json(new { success = false, Response = postPutItem.Message , data = postPutItem.Data });
        }
        public async Task<IActionResult> ApprovedSelectedPO(POVM viewModel,
        List<POList> POList)
        {
            try
            {
                viewModel.POList = MapToPONoList(POList);

                postPutItem = await _purchaseOrder.ApprovedSelectedPO(await GetUser(), viewModel);

                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true });
                }
                return Json(new { success = false, Response = postPutItem.Message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message, "WebApps");
                return Json(new { success = false, Response = postPutItem.Message });
                throw;
            }
        }
        public async Task<IActionResult> PostApprovedSuggested(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedSuggested(await GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostApprovedPO(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedPO(await GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostApprovedSupplier(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedSupplier(await GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutPRItemDetails(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPRItemDetails(await GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutPOItemDetail(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPOItemDetail(await GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutMyPONo(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutMyPONo(await GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.Message });
        }
        #endregion
        #region Get
        private POList MapToPONoList(IEnumerable<POList> poList)
        {
            if (poList == null || !poList.Any())
            {
                return new POList
                {
                    PONo = new List<string>()
                };
            }

            return new POList
            {
                PONo = poList.SelectMany(ic => ic.PONo).ToList(),
            };
        }
        private DocRequirementList MapToDocReqList(IEnumerable<DocRequirementList> docReqList)
        {
            if (docReqList == null || !docReqList.Any())
            {
                return new DocRequirementList
                {
                    DocRequirementId = new List<byte>()
                };
            }

            return new DocRequirementList
            {
                DocRequirementId = docReqList.SelectMany(ic => ic.DocRequirementId).ToList(),
            };
        }
        private POChargesList MapToPOChargesList(IEnumerable<POChargesList> chargesList)
        {
            if (chargesList == null || !chargesList.Any())
            {
                return new POChargesList
                {
                    OtherChargesId = new List<int>(),
                    Amount = new List<decimal>(),
                };
            }

            return new POChargesList
            {
                OtherChargesId = chargesList.SelectMany(ic => ic.OtherChargesId).ToList(),
                Amount = chargesList.SelectMany(ic => ic.Amount).ToList()
            };
        }
        private PRItemList MapToPRItemList(IEnumerable<PRItemList> itemList)
        {
            return new PRItemList
            {
                PRDetailsId = itemList.SelectMany(ic => ic.PRDetailsId).ToList(),
                Quantity = itemList.SelectMany(ic => ic.Quantity).ToList(),
                UnitPrice = itemList.SelectMany(ic => ic.UnitPrice).ToList(),
                PRNo = itemList.SelectMany(ic => ic.PRNo).ToList(),
                Amount = itemList.SelectMany(ic => ic.Amount).ToList(),
                Specification = itemList.SelectMany(ic => ic.Specification).ToList()
            };
        }
        public async Task<IActionResult> GetIncomingShipment(POVM viewModels)
        {
            response = await _purchaseOrder.GetIncomingShipment(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBid()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetSupplierBid(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidById(POVM viewModel)
        {
            response = await _purchaseOrder.GetSupplierBidById(await GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidByItem(POVM viewModel)
        {
            response = await _purchaseOrder.GetSupplierBidByItem(await GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForPOApprovalByPRNo(POVM viewModel)
        {
            response = await _purchaseOrder.GetForPOApprovalByPRNo(await GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForBiddingApproval()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetForBiddingApproval(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForPO()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetForPO(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForPOPerSuppEmail(POVM viewModels)
        {
            response = await _purchaseOrder.GetForPOPerSuppEmail(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetApprovedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetApprovedPO(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCreatedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetCreatedPO(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetMyCreatedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetMyCreatedPO(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetApprovedPOPerEmail(POVM viewModels)
        {
            response = await _purchaseOrder.GetApprovedPOPerEmail(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCreatedPOPerSupId(POVM viewModels)
        {
            response = await _purchaseOrder.GetCreatedPOPerSupId(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPortOfDischarge(string query)
        {
            var viewModels = new POVM();
            viewModels.PortOfDischarge = query;
            response = await _purchaseOrder.GetPortOfDischarge(await GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.PortOfDischarge,
                value = item.PodId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetPaymentTerms(string query)
        {
            var viewModels = new POVM();
            viewModels.PaymentTerms = query;
            response = await _purchaseOrder.GetPaymentTerms(await GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.PaymentTerms,
                value = item.PaymentTermsId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetLatestPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetLatestPO(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetLatestPO2(POVM viewModels)
        {
            response = await _purchaseOrder.GetLatestPO2(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetDocRequired(POVM viewModels)
        {
            response = await _purchaseOrder.GetDocRequired(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetOtherCharges(POVM viewModels)
        {
            response = await _purchaseOrder.GetOtherCharges(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSuppliers(string query)
        {
            var viewModels = new POVM();
            viewModels.SupplierName = query;
            var responseQuery = await _purchaseOrder.GetSuppliers(await GetUser(), viewModels);

            if (responseQuery == null)
            {
                responseQuery = new List<POVM>();
            }
            var formattedData = responseQuery.Select(item => new
            {
                label = item.SupplierName,
                value = item.SupplierId,
                value2 = item.Currency,
                value3 = item.PaymentTerms,
                value4 = item.PaymentTermsId,
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetPRWOCanvass(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRWOCanvass(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPOItemDetail(POVM viewModels)
        {
             response = await _purchaseOrder.GetPOItemDetail(await GetUser(), viewModels);
             return GetResponse(response);
        }
        public async Task<IActionResult> GetIncoterms(POVM viewModels)
        {
            response = await _purchaseOrder.GetIncoterms(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRPOSummaryReport(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRPOSummaryReport(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRPOSummaryItem(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRPOSummaryItem(await GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetIndexCard(POVM viewModel)
        {
            response = await _purchaseOrder.
                   GetIndexCard(await GetUser(), viewModel);
            return GetResponse(response);
        }
        #endregion
        #region Views
        public IActionResult GetShippingInstructions(int id)
        {
            return ViewComponent("ShippingInstructions", new { shippingInstructionId = id });
        }
        public IActionResult GetPOTable(int id)
        {
            return ViewComponent("POTable", new { tableId = id });
        }
        public IActionResult GetPOReference(int id)
        {
            return ViewComponent("POReference", new { referenceId = id });
        }
        public IActionResult GetCustomFormPOElem(int id)
        {
            return ViewComponent("CustomFormPOElemVC", new { poTypeId = id });
        }
        public IActionResult GetPOReportTable(int id)
        {
            return ViewComponent("POReportTableVC", new { tableId = id });
        }
        public IActionResult GetIndexCardTable()
        {
            return ViewComponent("IndexCardTableVC");
        }
        //IndexCardTableVC
        public async Task<IActionResult> Index()
        {        
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CustomPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> Bidding()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> POPrepApproval()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> ApprovedPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> POArchived()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CentralPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CreatedPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PutPONo()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PRPOSummaryReport()
        {
            return await IsAuthenTicated();
        }
        #endregion
    }
}