using CPRNIMS.Domain.Contracts.Items;
using CPRNIMS.Domain.Contracts.Receiving;
using CPRNIMS.Domain.Contracts.SMTP;
using CPRNIMS.Domain.Services;
using CPRNIMS.Infrastructure.Dto.Items;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.Receiving;
using CPRNIMS.WebApi.Controllers.Base;
using Microsoft.AspNetCore.Mvc;
using System.Text;

namespace CPRNIMS.WebApi.Controllers.Receiving
{
    [Security.AuthorizeRoles("Receiving")]
    public class ReceivingController : BaseController
    {
        private readonly IReceiving _receiving;
        private readonly IItem _item;

        public ReceivingController(ErrorMessageService errorMessageService, 
            IWebHostEnvironment webHostEnvironment, SMTPHelper sMTPHelper, 
            IConfiguration configuration, IReceiving receiving, IItem item) : 
            base(errorMessageService, webHostEnvironment, sMTPHelper, configuration)
        {
            _receiving = receiving;
            _item= item;
        }

        #region POST PUT
        [HttpPost("PostPutReceiving")]
        public async Task<IActionResult> PostPutReceiving([FromBody] ReceivingVM viewModel)
        {
            try
            {
                foreach (var items in viewModel.ItemList.PRDetailsId)
                {
                    var index = viewModel.ItemList.PRDetailsId.IndexOf(items);

                    var prDto = new ItemDto
                    {
                        UserId = viewModel.UserId,
                        PONo = viewModel.PONo,
                        POTypeId = viewModel.POTypeId,
                        EmailAddress = viewModel.EmailAddress,
                        DRNo = viewModel.DRNo,
                        ReceivedDate = viewModel.ReceivedDate,
                        DocTypeId = viewModel.DocTypeId,
                        QuantityReceived = viewModel.ItemList.QuantityReceived[index],
                        PRDetailsId = viewModel.ItemList.PRDetailsId[index],
                        RRNo = viewModel.RRNo,
                        Remarks = viewModel.Remarks,
                        IsCompleted = viewModel.IsCompleted,
                    };
                    var pR = await _receiving.PostPutReceiving(prDto);
                }

                return Ok(new { success = true, ErrCode = 1 });
            }
            catch (Exception ex)
            {
                var Message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(Message + "PostPutReceiving", "WebApi");// public byte messCode;
                return Ok(new { success = false, messCode = 0, message = Message });
                throw;
            }
        }
        [HttpPost("PutPOClose")]
        public async Task<IActionResult> PutPOClose([FromBody] ReceivingVM viewModel)
        {
            try
            {
                long prNo = await _item.GetPRNo();
                foreach (var items in viewModel.ItemList.PRDetailsId)
                {
                    var index = viewModel.ItemList.PRDetailsId.IndexOf(items);

                    var prDto = new ItemDto
                    {
                        UserId = viewModel.UserId,
                        PONo = viewModel.PONo,
                        POTypeId = viewModel.POTypeId,
                        EmailAddress = viewModel.EmailAddress,
                        PRNo = prNo + 1,
                        DocTypeId = viewModel.DocTypeId,
                        PRDetailsId = viewModel.ItemList.PRDetailsId[index],
                        Remarks = viewModel.Remarks,
                    };
                    var pR = await _receiving.PutPOClose(prDto);
                }

                return Ok(new { success = true });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PutPOClose", "WebApi");
                throw;
            }
        }
        [HttpPost("PutRRNoSeries")]
        public async Task<IActionResult> PutRRNoSeries(ItemDto itemDto)
        {
            try
            {
                await _receiving.PutRRNoSeries(itemDto);
                return Ok(new { success = true });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PutRRNoSeries", "WebApi");
                throw;
            }
        }
        #endregion
        #region Get       
        [HttpPost("GetRRReport")]
        public async Task<IActionResult> GetRRReport(ItemDto itemDto)
        {
            var myPR = await _receiving.GetRRReport(itemDto);

            return Ok(myPR);
        }
        [HttpPost("GetForReceiving")]
        public async Task<IActionResult> GetForReceiving(ItemDto itemDto)
        {
            try
            {
                var myPR = await _receiving.GetForReceiving(itemDto);

                return Ok(myPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message, "WebApi");
                throw;
            }
        }
        [HttpPost("GetRR")]
        public async Task<IActionResult> GetRR(ItemDto itemDto)
        {
            try
            {
                var myPR = await _receiving.GetRR(itemDto);

                return Ok(myPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message, "WebApi");
                throw;
            }
        }
        [HttpPost("GetRRDetailByPO")]
        public async Task<IActionResult> GetRRDetailByPO(ItemDto itemDto)
        {
            try
            {
                var myPR = await _receiving.GetRRDetailByPO(itemDto);

                return Ok(myPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetPRByRRId", "WebApi");
                throw;
            }
        }
        [HttpPost("GetRRDetail")]
        public async Task<IActionResult> GetRRDetail(ItemDto itemDto)
        {
            try
            {
                var myPR = await _receiving.GetRRDetail(itemDto);

                return Ok(myPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetRRDetail", "WebApi");
                throw;
            }
        }
        [HttpPost("GetLatestRRNo")]
        public async Task<IActionResult> GetLatestRRNo(ItemDto itemDto)
        {
            try
            {
                var myPR = await _receiving.GetLatestRRNo(itemDto);

                return Ok(myPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetLatestRRNo", "WebApi");
                throw;
            }
        }
        #endregion
    }
}