using CPRNIMS.Domain.Contracts.PR;
using CPRNIMS.Infrastructure.Database;
using CPRNIMS.Infrastructure.Dto.Items;
using CPRNIMS.Infrastructure.Dto.PR;
using CPRNIMS.Infrastructure.Dto.PR.Response;
using CPRNIMS.Infrastructure.Entities.Common;
using CPRNIMS.Infrastructure.Entities.Purchasing;
using CPRNIMS.Infrastructure.Entities.SMTP;
using CPRNIMS.Infrastructure.Models.Common;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static CPRNIMS.Domain.Services.OutputParamMessage;

namespace CPRNIMS.Domain.Services.PR
{
    public class PRequest : IPRequest
    {
        private readonly NonInventoryDbContext _dbContext;
        public PRequest(NonInventoryDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        #region Get
        public async Task<List<NotificationById>> GetNotificationById(PRDto PRDto)
        {
            var allItems = await _dbContext.NotificationByIds
                    .FromSqlRaw("EXEC GetNotificationById @UserId,@PRDetailsId,@AppsModuleId",
                       new SqlParameter("@UserId", PRDto.UserId),
                       new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                       new SqlParameter("@AppsModuleId", PRDto.AppsModuleId))
                   .ToListAsync();

            return allItems ?? new List<NotificationById>();
        }
        public async Task<List<ProjectCodes>> GetProjectCodes(PRDto pRDto)
        {
            return await _dbContext.ProjectCodes.ToListAsync();
        }
        public async Task<PagedResult<DeletedPR>> GetDeletedPR(PRDto dto)
        {
            var parameters = new[]
          {
                new SqlParameter("@UserId",          dto.UserId),
                new SqlParameter("@IsArchived",      dto.IsArchived),
                new SqlParameter("@SearchPRNo",      dto.SearchPRNo     ?? ""),
                new SqlParameter("@SearchItemName",  dto.SearchItemName ?? ""),
                new SqlParameter("@SearchDept",      dto.SearchDept     ?? ""),
                new SqlParameter("@PageNumber",      dto.PageNumber),
                new SqlParameter("@PageSize",        dto.PageSize)
            };

            int totalCount = 0;
            var items = new List<DeletedPR>();

            var conn = _dbContext.Database.GetDbConnection();
            await conn.OpenAsync();

            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"EXEC GetDeletedPR @UserId, 
                        @SearchPRNo, @SearchItemName, @SearchDept,
                        @PageNumber, @PageSize";
            foreach (var p in parameters) cmd.Parameters.Add(p);

            using var reader = await cmd.ExecuteReaderAsync();

            // First result set = total count
            if (await reader.ReadAsync())
                totalCount = reader.GetInt32(0);

            // Second result set = paged rows
            await reader.NextResultAsync();
            while (await reader.ReadAsync())
            {
                items.Add(new DeletedPR
                {
                    PRId = reader["PRId"] as long? ?? 0,
                    PRNo = reader["PRNo"] as long? ?? 0,
                    PRDetailsId = reader["PRDetailsId"] as long? ?? 0,
                    ItemNo = reader["ItemNo"] as long? ?? 0,
                    ItemName = reader["ItemName"]?.ToString(),
                    Department = reader["Department"]?.ToString(),
                    Remarks = reader["Remarks"]?.ToString(),
                    DateNeeded = reader["DateNeeded"] as DateTime? ?? DateTime.UtcNow,
                    CreatedDate = reader["CreatedDate"] as DateTime? ?? DateTime.UtcNow,
                    AttestedDate = reader["AttestedDate"]?.ToString(),
                    ApprovedDate = reader["ApprovedDate"]?.ToString(),
                    ApprovedBy = reader["ApprovedBy"]?.ToString(),
                    AttestedBy = reader["AttestedBy"]?.ToString(),
                    CreatedBy = reader["CreatedBy"]?.ToString(),
                    Qty = Convert.ToDecimal(reader["Qty"])       
                });
            }

            await conn.CloseAsync();

            return new PagedResult<DeletedPR>
            {
                Data = items,
                TotalCount = totalCount,
                PageNumber = dto.PageNumber,
                PageSize = dto.PageSize
            };
        }
        public async Task<PagedResult<DetailedPRTracking>> GetDetailedPRTracking(PRDto dto)
        {
            var parameters = new[]
            {
                new SqlParameter("@UserId",           dto.UserId),
                new SqlParameter("@SearchPRNo",       dto.SearchPRNo       ?? ""),
                new SqlParameter("@SearchItemNo",     dto.SearchItemNo     ?? ""),
                new SqlParameter("@SearchItemName",   dto.SearchItemName   ?? ""),
                new SqlParameter("@SearchDept",       dto.SearchDept       ?? ""),
                new SqlParameter("@SearchStatusName", dto.SearchStatusName ?? ""),
                new SqlParameter("@PageNumber",       dto.PageNumber),
                new SqlParameter("@PageSize",         dto.PageSize)
            };

            var statusList = new List<string>();
            int totalCount = 0;
            var items = new List<DetailedPRTracking>();

            var conn = _dbContext.Database.GetDbConnection();
            await conn.OpenAsync();

            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"EXEC GetDetailedPRTracking @UserId,
                        @SearchPRNo, @SearchItemNo, @SearchItemName, @SearchDept, @SearchStatusName,
                        @PageNumber, @PageSize";
            foreach (var p in parameters) cmd.Parameters.Add(p);
            cmd.CommandTimeout = 60;

            using var reader = await cmd.ExecuteReaderAsync();

            while (await reader.ReadAsync())
                statusList.Add(reader.GetString(0));

            await reader.NextResultAsync();
            if (await reader.ReadAsync())
                totalCount = reader.GetInt32(0);

            await reader.NextResultAsync();
            while (await reader.ReadAsync())
            {
                items.Add(new DetailedPRTracking
                {
                    PRNo = Convert.ToInt64(reader["PRNo"]),
                    PRDetailsId = Convert.ToInt64(reader["PRDetailsId"]),
                    PRBy = reader["PRBy"]?.ToString(),
                    PRTypeName = reader["PRTypeName"]?.ToString(),
                    PRDate = reader["PRDate"] as DateTime? ?? DateTime.UtcNow,
                    AttestedBy = reader["AttestedBy"]?.ToString(),
                    ApprovedBy = reader["ApprovedBy"]?.ToString(),
                    CanvassDate = reader["CanvassDate"]?.ToString(),
                    CanvassBy = reader["CanvassBy"]?.ToString(),
                    CanvassNo = reader["CanvassNo"]?.ToString(),
                    PONo = reader["PONo"]?.ToString(),
                    POBy = reader["POBy"]?.ToString(),
                    POQty = Convert.ToDecimal(reader["POQty"]), 
                    PODate = reader["PODate"]?.ToString(),
                    RRDate = reader["RRDate"]?.ToString(),
                    ReceivedDate = reader["ReceivedDate"]?.ToString(),
                    ReceivedBy = reader["ReceivedBy"]?.ToString(),
                    AcknowledgeBy = reader["AcknowledgeBy"]?.ToString(),
                    AcknowledgeDate = reader["AcknowledgeDate"]?.ToString(),
                    Specification = reader["Specification"]?.ToString(),
                    RRNo = Convert.ToInt64(reader["RRNo"]),
                    Department = reader["Department"]?.ToString(),
                    ItemCategoryName = reader["ItemCategoryName"]?.ToString(),
                    ItemName = reader["ItemName"]?.ToString(),
                    ItemDescription = reader["ItemDescription"]?.ToString(),
                    Status = Convert.ToInt16(reader["Status"]),
                    StatusName = reader["StatusName"]?.ToString(),
                    NewPRNo = reader["NewPRNo"]?.ToString(),
                    DateNeeded = reader["DateNeeded"] as DateTime? ?? DateTime.UtcNow,
                    ItemNo = Convert.ToInt64(reader["ItemNo"]),
                    Qty = Convert.ToDecimal(reader["Qty"]),
                    QuantityReceived = Convert.ToDecimal(reader["QuantityReceived"]),
                    UOMName = reader["UOMName"]?.ToString(),
                    ItemAttachPath = reader["ItemAttachPath"]?.ToString(),
                    Remarks = reader["Remarks"]?.ToString(),
                });
            }

            await conn.CloseAsync();

            return new PagedResult<DetailedPRTracking>
            {
                Data = items,
                TotalCount = totalCount,
                PageNumber = dto.PageNumber,
                PageSize = dto.PageSize,
                StatusList = statusList
            };
        }
        public async Task<PagedResult<ApprovedPR>> GetApprovedPR(PRDto dto)
        {
            var parameters = new[]
            {
                new SqlParameter("@UserId",           dto.UserId),
                new SqlParameter("@SearchPRNo",       dto.SearchPRNo       ?? ""),
                new SqlParameter("@SearchItemName",   dto.SearchItemName   ?? ""),
                new SqlParameter("@SearchDept",       dto.SearchDept       ?? ""),
                new SqlParameter("@SearchStatusName", dto.SearchStatusName ?? ""),
                new SqlParameter("@PageNumber",       dto.PageNumber),
                new SqlParameter("@PageSize",         dto.PageSize)
            };

            var statusList = new List<string>();
            int totalCount = 0;
            var items = new List<ApprovedPR>();

            var conn = _dbContext.Database.GetDbConnection();
            await conn.OpenAsync();

            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"EXEC GetApprovedPR @UserId,
                        @SearchPRNo, @SearchItemName, @SearchDept, @SearchStatusName,
                        @PageNumber, @PageSize";
            foreach (var p in parameters) cmd.Parameters.Add(p);
            cmd.CommandTimeout = 60;

            using var reader = await cmd.ExecuteReaderAsync();

            // Result set 1 — distinct status list
            while (await reader.ReadAsync())
                statusList.Add(reader.GetString(0));

            // Result set 2 — total count
            await reader.NextResultAsync();
            if (await reader.ReadAsync())
                totalCount = reader.GetInt32(0);

            // Result set 3 — paged rows
            await reader.NextResultAsync();
            while (await reader.ReadAsync())
            {
                items.Add(new ApprovedPR
                {
                    PRId = reader["PRId"] as long? ?? 0,
                    PRNo = reader["PRNo"] as long? ?? 0,
                    PRDetailsId = reader["PRDetailsId"] as long? ?? 0,
                    ItemNo = reader["ItemNo"] as long? ?? 0,
                    ItemName = reader["ItemName"]?.ToString(),
                    Department = reader["Department"]?.ToString(),
                    StatusName = reader["StatusName"]?.ToString(),
                    DateNeeded = reader["DateNeeded"] as DateTime? ?? DateTime.UtcNow,
                    CreatedDate = reader["CreatedDate"] as DateTime? ?? DateTime.UtcNow,
                    AttestedDate = reader["AttestedDate"]?.ToString(),
                    ApprovedDate = reader["ApprovedDate"]?.ToString(),
                    Qty = Convert.ToDecimal(reader["Qty"]),
                    ApprovedBy = reader["ApprovedBy"]?.ToString(),
                    AttestedBy = reader["AttestedBy"]?.ToString(),
                    CreatedBy = reader["CreatedBy"]?.ToString(),
                    RemainingDays = reader["RemainingDays"] as int? ?? 0,
                });
            }

            await conn.CloseAsync();

            return new PagedResult<ApprovedPR>
            {
                Data = items,
                TotalCount = totalCount,
                PageNumber = dto.PageNumber,
                PageSize = dto.PageSize,
                StatusList = statusList        
            };
        }
        public async Task<PagedResult<Infrastructure.Entities.Purchasing.PRList>> GetAllPR(PRDto dto)
        {
            var parameters = new[]
          {
                new SqlParameter("@UserId",          dto.UserId),
                new SqlParameter("@SearchPRNo",      dto.SearchPRNo     ?? ""),
                new SqlParameter("@SearchItemName",  dto.SearchItemName ?? ""),
                new SqlParameter("@SearchDept",      dto.SearchDept     ?? ""),
                new SqlParameter("@PageNumber",      dto.PageNumber),
                new SqlParameter("@PageSize",        dto.PageSize)
            };

            int totalCount = 0;
            var items = new List<Infrastructure.Entities.Purchasing.PRList>();

            var conn = _dbContext.Database.GetDbConnection();
            await conn.OpenAsync();

            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"EXEC GetAllPR @UserId, 
                        @SearchPRNo, @SearchItemName, @SearchDept,
                        @PageNumber, @PageSize";
            foreach (var p in parameters) cmd.Parameters.Add(p);

            using var reader = await cmd.ExecuteReaderAsync();

            if (await reader.ReadAsync())
                totalCount = reader.GetInt32(0);

            await reader.NextResultAsync();
            while (await reader.ReadAsync())
            {
                items.Add(new Infrastructure.Entities.Purchasing.PRList
                {
                    PRId = reader["PRId"] as long? ?? 0,
                    PRNo = reader["PRNo"] as long? ?? 0,
                    NewPRNo = reader["NewPRNo"]?.ToString(),
                    AggreItemName = reader["AggreItemName"]?.ToString(),
                    CreatedDate = reader["CreatedDate"] as DateTime? ?? DateTime.UtcNow,
                    DateNeeded = reader["DateNeeded"] as DateTime? ?? DateTime.UtcNow,
                    CreatedBy = reader["CreatedBy"]?.ToString(),
                    Department = reader["Department"]?.ToString(),
                    ApprovedBy = reader["ApprovedBy"]?.ToString(),
                    AttestedBy = reader["AttestedBy"]?.ToString(),
                    Remarks = reader["Remarks"]?.ToString(),
                    Status = reader["Status"] as short? ?? 0,
                });
            }

            await conn.CloseAsync();

            return new PagedResult<Infrastructure.Entities.Purchasing.PRList>
            {
                Data = items,
                TotalCount = totalCount,
                PageNumber = dto.PageNumber,
                PageSize = dto.PageSize
            };
        }
        public async Task<PagedResult<Infrastructure.Entities.Purchasing.PRList>> GetPRArchived(PRDto dto)
        {
            var parameters = new[]
          {
                new SqlParameter("@UserId",          dto.UserId),
                new SqlParameter("@SearchPRNo",      dto.SearchPRNo     ?? ""),
                new SqlParameter("@SearchItemName",  dto.SearchItemName ?? ""),
                new SqlParameter("@SearchDept",      dto.SearchDept     ?? ""),
                new SqlParameter("@PageNumber",      dto.PageNumber),
                new SqlParameter("@PageSize",        dto.PageSize)
            };

            int totalCount = 0;
            var items = new List<Infrastructure.Entities.Purchasing.PRList>();

            var conn = _dbContext.Database.GetDbConnection();
            await conn.OpenAsync();

            using var cmd = conn.CreateCommand();
            cmd.CommandText = @"EXEC GetPRArchived @UserId, 
                        @SearchPRNo, @SearchItemName, @SearchDept,
                        @PageNumber, @PageSize";
            foreach (var p in parameters) cmd.Parameters.Add(p);

            using var reader = await cmd.ExecuteReaderAsync();

            if (await reader.ReadAsync())
                totalCount = reader.GetInt32(0);

            await reader.NextResultAsync();
            while (await reader.ReadAsync())
            {
                items.Add(new Infrastructure.Entities.Purchasing.PRList
                {
                    PRId = reader["PRId"] as long? ?? 0,
                    PRNo = reader["PRNo"] as long? ?? 0,
                    NewPRNo = reader["NewPRNo"]?.ToString(),
                    AggreItemName = reader["AggreItemName"]?.ToString(),
                    CreatedDate = reader["NewPRNo"] as DateTime? ?? DateTime.UtcNow,
                    DateNeeded = reader["DateNeeded"] as DateTime? ?? DateTime.UtcNow,
                    CreatedBy = reader["CreatedBy"]?.ToString(),
                    Department = reader["Department"]?.ToString(),
                    ApprovedBy = reader["ApprovedBy"]?.ToString(),
                    AttestedBy = reader["AttestedBy"]?.ToString(),
                    Remarks = reader["Remarks"]?.ToString(),
                    Status = reader["Status"] as short? ?? 0,
                });
            }

            await conn.CloseAsync();

            return new PagedResult<Infrastructure.Entities.Purchasing.PRList>
            {
                Data = items,
                TotalCount = totalCount,
                PageNumber = dto.PageNumber,
                PageSize = dto.PageSize
            };
        }
        public async Task<List<PRDto>> GetApproverNameByPRNo(PRDto PRDto)
        {
            var result = await _dbContext.Approved
                .Where(a => a.PRNo == PRDto.PRNo && (a.ApproverId == 1 || a.ApproverId == 2))
                .GroupBy(a => a.PRNo)
                .Select(g => new PRDto
                {
                    AttestedBy = g.Where(x => x.ApproverId == 1 && x.ApprovedBy != null)
                                  .Select(x => x.ApprovedBy)
                                  .FirstOrDefault(),

                    ApprovedBy = g.Where(x => x.ApproverId == 2 && x.ApprovedBy != null)
                                  .Select(x => x.ApprovedBy)
                                  .FirstOrDefault()
                })
                .ToListAsync();

            if (result.Any() && (result[0].AttestedBy != null || result[0].ApprovedBy != null))
            {
                return result;
            }

            return new List<PRDto>();
        }
        public async Task<List<PRDto>> GetApproverName(PRDto PRDto)
        {
            var result = await _dbContext.Approved
                .Where(a => a.PRDetailsId == PRDto.PRDetailsId && (a.ApproverId == 1 || a.ApproverId == 2))
                .GroupBy(a => a.PRDetailsId)
                .Select(g => new PRDto
                {
                    AttestedBy = g.Where(x => x.ApproverId == 1).Select(x => x.ApprovedBy).FirstOrDefault(),
                    ApprovedBy = g.Where(x => x.ApproverId == 2).Select(x => x.ApprovedBy).FirstOrDefault()
                })
                .ToListAsync();

            return result ?? new List<PRDto>();
        }
        public async Task<List<ForRR>> GetPRByRRId(PRDto PRDto)
        {
            var allItems = await _dbContext.ForRRs
                     .FromSqlRaw($"EXEC GetPRByRRId @RRId = '{PRDto.RRId}',@UserId = '{PRDto.UserId}'")
                     .ToListAsync();

            return allItems ?? new List<ForRR>();
        }
        public async Task<List<ForReceiving>> GetForReceiving(PRDto PRDto)
        {
            var allItems = await _dbContext.ForReceivings
                   .FromSqlRaw($"EXEC GetForReceiving @UserId,@IsDenied",
                       new SqlParameter("@UserId", PRDto.UserId),
                     new SqlParameter("@IsDenied", PRDto.IsDenied))
                   .ToListAsync();

            return allItems ?? new List<ForReceiving>();
        }
        public async Task<List<ReceivingDetail>> GetRRDetailByPO(PRDto PRDto)
        {
            var allItems = await _dbContext.ReceivingDetails
                   .FromSqlRaw($"EXEC GetRRDetailByPO @PONo,@POTypeId,@UserId",
                   new SqlParameter("@PONo", PRDto.PONo),
                   new SqlParameter("@POTypeId", PRDto.POTypeId),
                   new SqlParameter("@UserId", PRDto.UserId))
                   .ToListAsync();

            return allItems ?? new List<ReceivingDetail>();
        }
        public async Task<List<ForReceiving>> GetItemDetailForReceiving(PRDto PRDto)
        {
            var allItems = await _dbContext.ForReceivings
                 .FromSqlRaw("EXEC GetItemDetailForReceiving @UserId,@ItemNo",
                 new SqlParameter("@UserId", PRDto.UserId),
                  new SqlParameter("@ItemNo", PRDto.ItemNo))
                 .ToListAsync();
            return allItems ?? new List<ForReceiving>();
        }
        public async Task<List<ItemApproval>> GetMyPR(PRDto PRDto)
        {
            var allItems = await _dbContext.ItemApprovals
                  .FromSqlRaw($"EXEC GetMyPR @UserId,@PRDetailsId",
                   new SqlParameter("@UserId", PRDto.UserId),
                   new SqlParameter("@PRDetailsId", PRDto.PRDetailsId))
                  .ToListAsync();

            return allItems ?? new List<ItemApproval>();
        }
        public async Task<List<NotifUserKey>> GetNotifUserKey(PRDto PRDto)
        {
            var allItems = await _dbContext.NotifUserKeys
                        .FromSqlRaw($"EXEC GetNotifUserKey @UserId,@Status,@PRDetailsId,@PRNo",
                        new SqlParameter("@UserId", PRDto.UserId),
                        new SqlParameter("@Status", PRDto.Status),
                        new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                        new SqlParameter("@PRNo", PRDto.PRNo))
                    .ToListAsync();

            return allItems ?? new List<NotifUserKey>();
        }
        public async Task<List<PRItemList>> GetPRDetailByPRNo(PRDto PRDto)
        {
            var allItems = await _dbContext.PRItemLists
                      .FromSqlRaw($"EXEC GetPRDetailByPRNo @UserId, @PRNo",
                         new SqlParameter("@UserId", PRDto.UserId),
                         new SqlParameter("@PRNo", PRDto.PRNo))
                     .ToListAsync();

            return allItems ?? new List<PRItemList>();
        }
        public async Task<List<PRTracking>> GetPRStatusById(PRDto PRDto)
        {
            var allItems = await _dbContext.PRTrackings
                .FromSqlRaw("EXEC GetPRStatusById @UserId,@PRDetailId",
                new SqlParameter("@UserId", PRDto.UserId),
                new SqlParameter("@PRDetailId", PRDto.PRDetailsId))
                .ToListAsync();

            return allItems ?? new List<PRTracking>();
        }
        public async Task<List<Dashboard>> GetDashBoard(PRDto PRDto)
        {
            var allItems = await _dbContext.Dashboards
                    .FromSqlRaw($"EXEC GetDashBoard @UserId",
                      new SqlParameter("@UserId", PRDto.UserId))
                    .ToListAsync();

            return allItems ?? new List<Dashboard>();
        }

        public async Task<List<Infrastructure.Entities.Canvass.PRList>>
            GetPRListByPRNo(PRDto PRDto)
        {
            var allItems = await _dbContext.PRItemList
                    .FromSqlRaw("EXEC GetPRListByPRNo @PRNo,@UserId",
                     new SqlParameter("@UserId", PRDto.UserId),
                     new SqlParameter("@PRNo", PRDto.PRNo))
                 .ToListAsync();

            return new List<Infrastructure.Entities.Canvass.PRList>();
        }
        public async Task<List<AlternativeOffer>> GetSupplierAlternativeOffer(PRDto PRDto)
        {
            var rfq = await _dbContext.AlternativeOffers
                     .FromSqlRaw("EXEC GetSupplierAlternativeOffer @UserId",
                      new SqlParameter("@UserId", PRDto.UserId)).ToListAsync();
            return rfq ?? new List<AlternativeOffer>();
        }
        public async Task<List<AlternativeOfferDetails>> GetSupplierAlterOfferDetails(PRDto PRDto)
        {
            var rfq = await _dbContext.AlternativeOfferDetails
                     .FromSqlRaw("EXEC GetAlternativeOfferDetails @UserId,@CanvassDetailId",
                      new SqlParameter("@UserId", PRDto.UserId),
                      new SqlParameter("@CanvassDetailId", PRDto.CanvassDetailId)).ToListAsync();
            return rfq ?? new List<AlternativeOfferDetails>();
        }
        #endregion
        #region Post Put
        public async Task<PRResponse> PostPRApproveReject(PRDto PRDto)
        {
            await _dbContext.Database
                  .ExecuteSqlRawAsync("EXEC PostPRApproveReject @UserId, @ItemNo, @Status, @PRDetailsId, @Remarks",
                   new SqlParameter("@ItemNo", PRDto.ItemNo != null ? PRDto.ItemNo : 0L),
                   new SqlParameter("@UserId", PRDto.UserId),
                   new SqlParameter("@Status", PRDto.Status),
                   new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                   new SqlParameter("@Remarks", PRDto.Remarks ?? "N/A"));
            return new PRResponse();
        }
        public async Task<PRResponse> PutItemDetail(PRDto PRDto)
        {
            await _dbContext.Database
                    .ExecuteSqlRawAsync($"EXEC PutPRItemDetail @UserId, @ItemLocalId, @UOMId, @ItemColorId," +
                    $"@Qty,@ItemCategoryId,@PRDetailsId,@Remarks,@ItemName,@ItemDescription",
                      new SqlParameter("@PRDetailsId", PRDto.PRDetailsId != null ? PRDto.PRDetailsId : 0L),
                      new SqlParameter("@ItemLocalId", PRDto.ItemLocalId),
                      new SqlParameter("@UOMId", PRDto.UOMId),
                      new SqlParameter("@ItemColorId", PRDto.ItemColorId),
                      new SqlParameter("@UserId", PRDto.UserId),
                      new SqlParameter("@Qty", PRDto.Qty),
                      new SqlParameter("@ItemCategoryId", PRDto.ItemCategoryId),
                      new SqlParameter("@Remarks", PRDto.Remarks),
                      new SqlParameter("@ItemName", PRDto.ItemName),
                      new SqlParameter("@ItemDescription", PRDto.ItemDescription));
            return new PRResponse();
        }
        public async Task<PRResponse> PostPutDeniedItem(PRDto PRDto)
        {
            await _dbContext.Database
                   .ExecuteSqlRawAsync("EXEC PostPutDeniedItem @UserId,@PRDetailsId,@Remarks",
                    new SqlParameter("@UserId", PRDto.UserId),
                    new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                    new SqlParameter("@Remarks", PRDto.Remarks ?? "N/A"));
            return new PRResponse();
        }
        public async Task<PRResponse> PostPutReceiving(PRDto PRDto)
        {
            await _dbContext.Database
                  .ExecuteSqlRawAsync($"EXEC PostPutReceiving @UserId, @PONo, @POTypeId, @EmailAddress, @DRNo, @DocTypeId, @QuantityReceived,@RRNo,@PRDetailsId,@Remarks,@ReceivedDate,@IsCompleted",
                   new SqlParameter("@UserId", PRDto.UserId),
                   new SqlParameter("@PONo", PRDto.PONo),
                   new SqlParameter("@POTypeId", PRDto.POTypeId),
                   new SqlParameter("@EmailAddress", PRDto.EmailAddress),
                   new SqlParameter("@DRNo", PRDto.DRNo),
                   new SqlParameter("@DocTypeId", PRDto.DocTypeId),
                   new SqlParameter("@QuantityReceived", PRDto.QuantityReceived),
                   new SqlParameter("@RRNo", PRDto.RRNo),
                   new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                   new SqlParameter("@Remarks", PRDto.Remarks ?? "N/A"),
                   new SqlParameter("@ReceivedDate", PRDto.ReceivedDate),
                   new SqlParameter("@IsCompleted", PRDto.IsCompleted));
            return new PRResponse();
        }
        public async Task<PRResponse> PutPOClose(PRDto PRDto)
        {
            await _dbContext.Database
                  .ExecuteSqlRawAsync("EXEC PutPOClose @UserId, @PONo, @POTypeId, @EmailAddress,@PRDetailsId,@DocTypeId,@PRNo,@Remarks",
                   new SqlParameter("@UserId", PRDto.UserId),
                   new SqlParameter("@PONo", PRDto.PONo),
                   new SqlParameter("@POTypeId", PRDto.POTypeId),
                   new SqlParameter("@EmailAddress", PRDto.EmailAddress),
                   new SqlParameter("@DocTypeId", PRDto.DocTypeId),
                   new SqlParameter("@PRDetailsId", PRDto.PRDetailsId),
                    new SqlParameter("@PRNo", PRDto.PRNo),
                   new SqlParameter("@Remarks", PRDto.Remarks ?? "N/A"));
            return new PRResponse();
        }
        public async Task<AlternativeOfferDetails> PutSupplierAlterOffer(PRDto pRDto)
        {
            await _dbContext.Database
                  .ExecuteSqlRawAsync("EXEC PutSupplierAlterOffer @UserId,@AlternativeOfferId,@CanvassDetailId",
                   new SqlParameter("@UserId", pRDto.UserId),
                   new SqlParameter("@AlternativeOfferId", pRDto.AlternativeOfferId),
                   new SqlParameter("@CanvassDetailId", pRDto.CanvassDetailId));
            return new AlternativeOfferDetails();
        }
        private async Task<bool> IsUsingAsync(int projectCodeId)
        {
            return await (from pr in _dbContext.PRs
                          join pod in _dbContext.PODetails on pr.PRNo equals pod.PRNo
                          where pr.ProjectCodeId == projectCodeId
                          && !pod.IsRemoved
                          && pr.IsActive
                          select pr).AnyAsync();
        }
        public async Task<MessageResponse> PRItemRemoval(PRDto prDto)
        {
            var (messCode, message) = CreateOutputParams();

            await _dbContext.Database.ExecuteSqlRawAsync(
                "EXEC PRItemRemoval @UserId,@PRDetailsId,@Remarks,@MessCode OUTPUT,@Message OUTPUT",
                new SqlParameter("@UserId", prDto.UserId),
                new SqlParameter("@PRDetailsId", prDto.PRDetailsId),
                new SqlParameter("@Remarks", prDto.Remarks ?? (object)DBNull.Value),
                messCode,
                message
            );

            var response = new MessageResponse
            {
                Message = message.Value?.ToString(),
                MessageCode = Convert.ToByte(messCode.Value)
            };
            return response;
        }

        public async Task<ResponseObject> PostPutProjectCode(PRDto prDto)
        {
            if (prDto == null) throw new ArgumentNullException(nameof(prDto));

            var existing = await _dbContext.ProjectCodes
                .FirstOrDefaultAsync(p => p.ProjectCodeId == prDto.ProjectCodeId);

            if (existing == null)
            {
                var project = new ProjectCodes
                {
                    ProjectCode = prDto.ProjectCode,
                    ProjectName = prDto.ProjectName,
                    DeliveryAddress = prDto.DeliveryAddress,
                    MaxDays = prDto.MaxDays,
                    IsActive = prDto.IsActive
                };
                await _dbContext.ProjectCodes.AddAsync(project);
            }
            else
            {
                if (await IsUsingAsync(prDto.ProjectCodeId))
                {
                    return new ResponseObject()
                    {
                        message = "Cannot update this project code because it is already being used in a Purchase Order (PO).",
                        messCode = 0,
                        success = false,
                    };
                }
                else
                {
                    existing.ProjectCode = prDto.ProjectCode;
                    existing.ProjectName = prDto.ProjectName;
                    existing.DeliveryAddress = prDto.DeliveryAddress;
                    existing.MaxDays = prDto.MaxDays;
                    existing.IsActive = prDto.IsActive;
                }
            }

            await _dbContext.SaveChangesAsync();

            return new ResponseObject()
            {
                message = "Project code detail successfully updated",
                messCode = 1,
                success = true
            };
        }

        public async Task<ResponseObject> PostItemInPR(PRDto dto)
        {
            var (messCode, message) = CreateOutputParams();

            await _dbContext.Database.ExecuteSqlRawAsync(
                "EXEC PostItemInPR @UserId,@ItemNo,@Qty,@PRNo,@MessCode OUTPUT,@Message OUTPUT",
                new SqlParameter("@UserId", dto.UserId),
                new SqlParameter("@ItemNo", dto.ItemNo),
                new SqlParameter("@Qty", dto.Qty),
                new SqlParameter("@PRNo", dto.PRNo),
                messCode,
                message
            );

            var response = new ResponseObject
            {
                message = message.Value?.ToString(),
                messCode = Convert.ToByte(messCode.Value)
            };
            return response;
        }

        #endregion
    }
}