using CPRNIMS.Domain.Contracts.Canvass;
using CPRNIMS.Domain.Contracts.SMTP;
using CPRNIMS.Domain.Services;
using CPRNIMS.Infrastructure.Dto.Canvass;
using CPRNIMS.Infrastructure.Entities.Canvass;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.Canvass;
using CPRNIMS.Infrastructure.ViewModel.Common;
using Microsoft.AspNetCore.Mvc;
using System.Text;

namespace CPRNIMS.WebApi.Controllers.Canvass
{
    [Security.AuthorizeRoles("CanvassMgmt")]
    public class CanvassMgmtController : Base.BaseController
    {
        private readonly SMTPHelper _smtpHelper;
        private readonly ICanvass _canvass;
        private readonly IConfiguration _config;

        public CanvassMgmtController(ErrorMessageService errorMessageService, 
            IWebHostEnvironment webHostEnvironment, SMTPHelper sMTPHelper, 
            IConfiguration configuration, ICanvass canvass) : 
            base(errorMessageService, webHostEnvironment, configuration)
        {
            _canvass = canvass;
            _config = configuration;
            _smtpHelper = sMTPHelper;
        }

        #region Get
        [HttpPost("GetSupplierItemWOEmail")]
        public async Task<IActionResult> GetSupplierItemWOEmail(CanvassDto viewModel)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetSupplierItemWOEmail(viewModel),
               nameof(GetSupplierItemWOEmail), false
           );
        }
        [HttpPost("GetSupplierById")]
        public async Task<IActionResult> GetSupplierById(CanvassDto viewModel)
        {
            return await ExecuteWithErrorHandling(
              () => _canvass.GetSupplierById(viewModel),
              nameof(GetSupplierById), false
          );         
        }
        [HttpPost("GetItemSupplierWOEmail")]
        public async Task<IActionResult> GetItemSupplierWOEmail(CanvassDto viewModel)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetItemSupplierWOEmail(viewModel),
               nameof(GetItemSupplierWOEmail), false
           );         
        }
        [HttpPost("GetCanvassByPRNo")]
        public async Task<IActionResult> GetCanvassByPRNo(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
              () => _canvass.GetCanvassByPRNo(itemCodeDto),
              nameof(GetCanvassByPRNo), false
          );
        }
        [HttpPost("GetSupplierBid")]
        public async Task<IActionResult> GetSupplierBid(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
                 () => _canvass.GetSupplierBid(itemCodeDto),
                 nameof(GetSupplierBid), false
            );         
        }
        [HttpPost("GetSupplierBidByItem")]
        public async Task<IActionResult> GetSupplierBidByItem(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
                () => _canvass.GetSupplierBidByItem(itemCodeDto),
                nameof(GetSupplierBidByItem), false
           );
        }
        [HttpPost("GetSupplierBidById")]
        public async Task<IActionResult> GetSupplierBidById(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetSupplierBidById(itemCodeDto),
               nameof(GetSupplierBidById), false
            );         
        }
        [HttpPost("GetCanvassPerSupplier")]
        public async Task<IActionResult> GetCanvassPerSupplier(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
              () => _canvass.GetCanvassPerSupplier(itemCodeDto),
              nameof(GetCanvassPerSupplier), false
            );
        }
        [HttpPost("GetCanvassPerSupplierId")]
        public async Task<IActionResult> GetCanvassPerSupplierId(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetCanvassPerSupplierId(itemCodeDto),
               nameof(GetCanvassPerSupplierId), false
           );          
        }
        [HttpPost("GetCanvassPerSupplierEmail")]
        public async Task<IActionResult> GetCanvassPerSupplierEmail(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
                 () => _canvass.GetCanvassPerSupplierEmail(itemCodeDto),
                 nameof(GetCanvassPerSupplierEmail), false
             );          
        }
        [HttpPost("GetPRItemList")]
        public async Task<IActionResult> GetPRItemList(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
                 () => _canvass.GetPRItemList(itemCodeDto),
                 nameof(GetPRItemList), false
             );
        }
        [HttpPost("GetPRItem")]
        public async Task<IActionResult> GetPRItem(CanvassDto itemCodeDto)
        {
            return await ExecuteWithErrorHandling(
                 () => _canvass.GetPRItem(itemCodeDto),
                 nameof(GetPRItem), false
             );
        }
        [HttpPost("GetCanvassById")]
        public async Task<IActionResult> GetCanvassById(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetCanvassById(CanvassDto),
               nameof(GetCanvassById), false
           );
        }
        [HttpPost("GetCanvassWOResponse")]
        public async Task<IActionResult> GetCanvassWOResponse(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetCanvassWOResponse(CanvassDto),
               nameof(GetCanvassWOResponse), false
            );
        }
        [HttpPost("GetWOResponseBySuppId")]
        public async Task<IActionResult> GetWOResponseBySuppId(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
              () => _canvass.GetWOResponseBySuppId(CanvassDto),
              nameof(GetWOResponseBySuppId), false
           );
        }
        [HttpPost("GetForCanvassPerItem")]
        public async Task<IActionResult> GetForCanvassPerItem(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
             () => _canvass.GetForCanvassPerItem(CanvassDto),
             nameof(GetForCanvassPerItem), false
            );
        }
        [HttpPost("GetPRListByPRNo")]
        public async Task<IActionResult> GetPRListByPRNo(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
             () => _canvass.GetPRListByPRNo(CanvassDto),
             nameof(GetPRListByPRNo), false
            );
        }
        [HttpPost("GetMySuppliers")]
        public async Task<IActionResult> GetMySuppliers(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetMySuppliers(CanvassDto),
               nameof(GetMySuppliers), false
             );
        }
        [HttpPost("GetMyPRWOCanvass")]
        public async Task<IActionResult> GetMyPRWOCanvass(CanvassDto itemDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetMyPRWOCanvass(itemDto),
               nameof(GetMyPRWOCanvass), false
             );
        }
        [HttpPost("GetCanvassGroupByPRNo")]
        public async Task<IActionResult> GetCanvassGroupByPRNo(CanvassDto itemDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetCanvassGroupByPRNo(itemDto),
               nameof(GetCanvassGroupByPRNo), false
             );
        }
        [HttpPost("GetAlternativeOfferByPRDetailId")]
        public async Task<IActionResult> GetAlternativeOfferByPRDetailId(CanvassDto itemDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.GetAlternativeOfferByPRDetailId(itemDto),
               nameof(GetAlternativeOfferByPRDetailId), false
             );
        }
        #endregion

        #region Post Put
        [HttpPost("PostAllCanvass")]
        public async Task<IActionResult> PostAllCanvass()
        {
            try
            {
                var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");

                // Get all canvass items
                var allCanvass = await _canvass.GetAllForCanvass();

                // ✅ Group all items by supplier
                var groupedBySupplier = allCanvass
                    .GroupBy(x => x.SupplierId)
                    .ToList();

                // Process each supplier group
                foreach (var supplierGroup in groupedBySupplier)
                {
                    var firstItem = supplierGroup.First();
                    int canvassNo = await _canvass.GetCanvassNo();

                    // Insert all items for this supplier
                    foreach (var rfqq in supplierGroup)
                    {
                        var canvass = new CanvassDto
                        {
                            PRDetailsId = rfqq.PRDetailsId,
                            PRNo = rfqq.PRNo,
                            ItemNo = rfqq.ItemNo,
                            SupplierId = rfqq.SupplierId,
                            UserId = rfqq.UserId,
                            FullName = rfqq.FullName,
                            CanvassNo = canvassNo + 1
                        };

                        await _canvass.PostPerSupplierToken(canvass);
                    }

                    // ✅ After inserting all items for this supplier, retrieve RFQ info
                    var canvassInfo = new CanvassDto
                    {
                        SupplierId = firstItem.SupplierId,
                        UserId = firstItem.UserId,
                        FullName = firstItem.FullName,
                        CanvassNo = canvassNo + 1
                    };

                    var rfq = await _canvass.GetRFQ(canvassInfo);

                    if (rfq?.Any() == true)
                    {
                        // ✅ Prepare email body
                        var message = new StringBuilder(baseTemplate);
                        message.Replace("@ViewBag.FormLink", Convert.ToString(_configuration["WebEndPoint:SupplierForm"] + rfq[0].Token));
                        message.Replace("@ViewBag.Supplier", rfq[0].SupplierName);
                        message.Replace("@ViewBag.Signature", firstItem.FullName);

                        // ✅ Prepare email details
                        var messageDetails = new EmailMessageDetailsVM
                        {
                            AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf"),
                            Recipient = rfq[0].EmailAddress,
                            Message = message.ToString(),
                            Subject = "CLMS - Request For Quotation #PRNo: " + rfq[0].AggrePRNo,
                            CC = Convert.ToString(_configuration["Canvass:CC"]),
                            SenderEmail = _config["SMTP:SenderEmail"],
                            DisplayName = "lloydlabinc.com",
                            NewPassword = _config["SMTP:Password"],
                            OutGoingPort = 587,
                            Server = _config["SMTP:Server"],
                            UserName = _config["SMTP:UserName"],
                            IsSuccess = false,
                            IsCanvass = true
                        };

                        await _smtpHelper.SendEmailAsync(messageDetails);

                        // ✅ Post canvass record after successful send
                        await _canvass.PostCanvass(canvassInfo);
                    }
                }

                return Ok(new { message = "All canvass emails sent successfully." });
            }
            catch (Exception ex)
            {
                var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(errorMessage, "WebApi");
                throw;
            }
        }

        [HttpPost("PostCanvassFollowUp")]
        public async Task<IActionResult> PostCanvassFollowUp(CanvassDto itemDto)
        {
            try
            {
                var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");

                var canvassFolloUp = await _canvass.GetCanvassForFollowUp(itemDto);
                foreach (var canvassSupplierId in canvassFolloUp)
                {
                    var message = new StringBuilder(baseTemplate);

                    message.Replace("@ViewBag.FormLink", Convert.ToString(_config["WebEndPoint:SupplierForm"] + canvassSupplierId.FormLink));
                    message.Replace("@ViewBag.Supplier", Convert.ToString(canvassSupplierId.SupplierName));
                    message.Replace("@ViewBag.Signature", canvassSupplierId.Signature);

                    var messageDetails = new EmailMessageDetailsVM
                    {
                        Recipient = canvassSupplierId.EmailAddress,
                        Message = message.ToString(),
                        Subject = canvassSupplierId.Subject,
                        CC = canvassSupplierId.CC,
                        SenderEmail = canvassSupplierId.SenderEmail,
                        DisplayName = canvassSupplierId.DisplayName,
                        NewPassword = canvassSupplierId.Password,
                        OutGoingPort = 587,
                        Server = canvassSupplierId.Server,
                        UserName = canvassSupplierId.SenderEmail,
                        IsSuccess = false
                    };
                    messageDetails.IsCanvass = true;
                    messageDetails.AttachPath = @"C:\webapi\Content\Documents\Pdf\Offer_Submission_Procedure.pdf";
                    if (await _smtpHelper.SendEmailAsync(messageDetails))
                    {
                        await _canvass.PutSupplierCanvass(canvassSupplierId.CanvassSupplierId);
                    }
                }

                return Ok(new { success = true, messCode = 1 });
            }
            catch (Exception ex)
            {
                var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(errorMessage, "WebApi");
                throw;
            }
        }
        [HttpPost("PostPutSupplier")]
        public async Task<IActionResult> PostPutSupplier(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
             () => _canvass.PostPutSupplier(CanvassDto),
             nameof(PostPutSupplier), true
           );
        }
        [HttpPost("PostTaggingSupplier")]
        public async Task<IActionResult> PostTaggingSupplier([FromBody] CanvassVM canvassVM)
        {
            try
            {
                var supplier = new Suppliers();
                foreach (var items in canvassVM.SupplierList.SupplierId)
                {
                    var index = canvassVM.SupplierList.SupplierId.IndexOf(items);

                    var CanvassDto = new CanvassDto
                    {
                        SupplierId = canvassVM.SupplierList.SupplierId[index],
                        ItemNo = canvassVM.ItemNo,
                        IsActive = true,
                        UserId = canvassVM.UserId,
                        SupplierName = "N/A",
                        EmailAddress = "N/A",
                        Address = "N/A",
                        ContactNo = "N/A",
                        ContactPerson = "N/A",
                        IsTagging = true
                    };

                    supplier = await _canvass.PostTaggingSupplier(CanvassDto);
                }
                return Ok(supplier);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.Message ?? ex.Message;
                return BadRequest(new { ErrMessage = message, ErrCode = 0 });
            }
        }
        [HttpPost("PostPutItemTagging")]
        public async Task<IActionResult> PostPutItemTagging([FromBody] CanvassVM canvassVM)
        {
            try
            {
                var supplier = new Suppliers();
                foreach (var items in canvassVM.ItemList.ItemNo)
                {
                    var index = canvassVM.ItemList.ItemNo.IndexOf(items);

                    var CanvassDto = new CanvassDto
                    {
                        ItemNo = canvassVM.ItemList.ItemNo[index],
                        SupplierId = canvassVM.SupplierId,
                        IsActive = canvassVM.IsActive,
                        UserId = canvassVM.UserId,
                    };

                    supplier = await _canvass.PostPutItemTagging(CanvassDto);
                }
                return Ok(supplier);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.Message ?? ex.Message;
                return BadRequest(new { ErrMessage = message, ErrCode = 0 });
            }
        }
        [HttpPost("PostCanvass")]
        public async Task<IActionResult> PostCanvass([FromBody] CanvassVM canvassVM)
        {
            try
            {
                var baseTemplate = "n/a";

                baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");

                var CanvassDto = new CanvassDto();
                int canvassNo = await _canvass.GetCanvassNo();
                foreach (var itemCartId in canvassVM.CanvassList.PRDetailsId)
                {
                    var index = canvassVM.CanvassList.PRDetailsId.IndexOf(itemCartId);

                    CanvassDto = new CanvassDto
                    {
                        PRDetailsId = canvassVM.CanvassList.PRDetailsId[index],
                        PRNo = canvassVM.CanvassList.PRNo[index],
                        ItemNo = canvassVM.CanvassList.ItemNo[index],
                        SupplierId = canvassVM.SupplierId,
                        UserId = canvassVM.UserId,
                        FullName = canvassVM.FullName,
                        CanvassNo = canvassNo + 1,
                    };
                    await _canvass.PostPerSupplierToken(CanvassDto);
                }
                var rfq = await _canvass.GetRFQ(CanvassDto);

                var message = new StringBuilder(baseTemplate);
                message.Replace("@ViewBag.FormLink", Convert.ToString(_configuration["WebEndPoint:SupplierForm"] + rfq[0].Token));
                message.Replace("@ViewBag.Supplier", rfq[0].SupplierName);
                message.Replace("@ViewBag.Signature", CanvassDto.FullName);

                var messageDetails = new EmailMessageDetailsVM();
                messageDetails.AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf");

                messageDetails.Recipient = rfq[0].EmailAddress;
                messageDetails.Message = message.ToString();
                messageDetails.Subject = "CLMS - Request For Quotation #PRNo: " + rfq[0].AggrePRNo;
                messageDetails.CC = Convert.ToString(_configuration["Canvass:CC"]);
                messageDetails.SenderEmail = _config["SMTP:SenderEmail"];
                messageDetails.DisplayName = "lloydlabinc.com";
                messageDetails.NewPassword = _config["SMTP:Password"];
                messageDetails.OutGoingPort = 587;
                messageDetails.Server = _config["SMTP:Server"];
                messageDetails.UserName = _config["SMTP:UserName"];
                messageDetails.IsSuccess = false;
                messageDetails.IsCanvass = true;
                await _smtpHelper.SendEmailAsync(messageDetails);

                var pR = await _canvass.PostCanvass(CanvassDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(errorMessage + " PostCanvass", "WebApi");
                throw;
            }
        }
        [HttpPost("PostSuggestedSupp")]
        public async Task<IActionResult> PostSuggestedSupp(CanvassDto CanvassDto)
        {
            try
            {
                var pR = await _canvass.PostSuggestedSupp(CanvassDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + " PostSuggestedSupp", "WebApi");
                throw;
            }
        }
        [HttpPost("PostApprovedSupp")]
        public async Task<IActionResult> PostApprovedSupp(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
                () => _canvass.PostApprovedSupp(CanvassDto),
                nameof(PostApprovedSupp), true
            );          
        }
        [HttpPost("PutSuppUnitPrice")]
        public async Task<IActionResult> PutSuppUnitPrice(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
               () => _canvass.PutSuppUnitPrice(CanvassDto),
               nameof(PutSuppUnitPrice), true
           );
        }
        [HttpPost("PutSuppBidDetails")]
        public async Task<IActionResult> PutSuppBidDetails(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
              () => _canvass.PutSuppBidDetails(CanvassDto),
              nameof(PutSuppBidDetails), true
            );          
        }
        [HttpPost("PostPutMySupplier")]
        public async Task<IActionResult> PostPutMySupplier(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
                () => _canvass.PostPutMySupplier(CanvassDto),
                nameof(PostPutMySupplier), true
              );          
        }
        [HttpPost("UnlockFormLink")]
        public async Task<IActionResult> UnlockFormLink(CanvassDto CanvassDto)
        {
            return await ExecuteWithErrorHandling(
                () => _canvass.UnlockFormLink(CanvassDto),
                nameof(UnlockFormLink), true
              );
        }
        #endregion
    }
}