using vendorApproverBackend.Data;
using vendorApproverBackend.Entities;
using vendorApproverBackend.Requests;
using vendorApproverBackend.Responses;
using vendorApproverBackend.Enums;
using Microsoft.EntityFrameworkCore;



namespace vendorApproverBackend.Services
{
    public class AssessmentReportService
    {
        private readonly DataContext _context;

        public AssessmentReportService(DataContext context)
        {
            _context = context;
        }

        public async Task<AssessmentReport?> FindAssessmentReportByIdAsync(long reportId)
        {
            return await _context.AssessmentReports
                .AsNoTracking()
                .FirstOrDefaultAsync(r => r.Id == reportId);
        }

        public async Task<AssessmentReport?> GetAssessmentReportByPrequalificationRequestIdAsync(long prequalificationRequestId)
        {
            return await _context.AssessmentReports
                .AsNoTracking()
                .FirstOrDefaultAsync(r => r.PrequalificationRequestId == prequalificationRequestId);
        }

        public async Task<AssessmentReport> AddAssessmentReportAsync(User user, PrequalificationRequest request, AssessmentReportRequest reportRequest)
        {
            var dbRequest = await _context.PrequalificationRequests
                         .Include(r => r.AssessmentReport)
                         .FirstOrDefaultAsync(r => r.Id == request.Id);

            if (dbRequest == null)
                throw new KeyNotFoundException($"Prequalification Request with ID {dbRequest.Id} not found.");


            if (dbRequest.AssessmentReport != null)
            {
                throw new InvalidOperationException($"A report already exists for Prequalification Request ID {dbRequest.Id}.");
            }

            var report = new AssessmentReport
            {
                CreatedById = user.Id,
                PrequalificationRequestId = dbRequest.Id,
                DocumentationReview = CopyQuestionsRateList(reportRequest.DocumentationReview),
                AuditVisit = CopyQuestionsRateList(reportRequest.AuditVisit),
                Timestamp = DateTime.UtcNow,
                TotalMarks = reportRequest.TotalMarks,
                passed = reportRequest.passed

            };

            _context.AssessmentReports.Add(report);
            dbRequest.Status = RequestStatus.EVALUATION_COMPLETED;
            await _context.SaveChangesAsync();

            return report;
        }



        public async Task<AssessmentReport> AddInspectorReportAsync(User user, PrequalificationRequest request, InspectorReportRequest reportRequest)
        {
            var dbRequest = await _context.PrequalificationRequests
                .Include(r => r.AssessmentReport)
                .FirstOrDefaultAsync(r => r.Id == request.Id);

            if (dbRequest == null)
                throw new KeyNotFoundException($"Prequalification Request with ID {request.Id} not found.");

            AssessmentReport report;

            if (dbRequest.AssessmentReport != null)
            {

                report = dbRequest.AssessmentReport;

                report.TechnicalFactoryAuditVisit = CopyQuestionsRateList(reportRequest.TechnicalFactoryAuditVisit);
                report.AuditVisit = CopyQuestionsRateList(reportRequest.AuditVisit);
                report.Timestamp = DateTime.UtcNow;
                report.TotalMarks = reportRequest.TotalMarks;
                report.passed = reportRequest.passed;
                report.Grade = reportRequest.Grade;
            }
            else
            {

                report = new AssessmentReport
                {
                    CreatedById = user.Id,
                    PrequalificationRequestId = dbRequest.Id,
                    TechnicalFactoryAuditVisit = CopyQuestionsRateList(reportRequest.TechnicalFactoryAuditVisit),
                    AuditVisit = CopyQuestionsRateList(reportRequest.AuditVisit),
                    Timestamp = DateTime.UtcNow,
                    TotalMarks = reportRequest.TotalMarks,
                    passed = reportRequest.passed,
                    Grade = reportRequest.Grade
                };

                _context.AssessmentReports.Add(report);
                dbRequest.AssessmentReport = report;
            }

            dbRequest.Status = RequestStatus.FACTORY_VISIT_REPORTED;

            List<User> inspectors = dbRequest.Inspectors?.ToList() ?? new List<User>();

            if (inspectors.Count > 0)
            {

                foreach (User u in inspectors)
                {
                   // u.EvaluationPqId = null;

                    u.RequestsEvaluationIds.Remove(request.Id);
                }
            }


            await _context.SaveChangesAsync();

            return report;
        }

        public async Task<AssessmentReport?> UpdateAssessmentReportAsync(long reportId, UpdateReportRequest reportRequest)
        {
            var existingReport = await _context.AssessmentReports
                .Include(r => r.PrequalificationRequest)
                .FirstOrDefaultAsync(r => r.Id == reportId);

            if (existingReport == null)
            {
                return null;
            }

            if (reportRequest.DocumentationReview != null && reportRequest.DocumentationReview.Any())
            {
                existingReport.DocumentationReview = CopyQuestionsRateList(reportRequest.DocumentationReview);
            }

            if (reportRequest.AuditVisit != null && reportRequest.AuditVisit.Any())
            {
                existingReport.AuditVisit = CopyQuestionsRateList(reportRequest.AuditVisit);
            }
            if (reportRequest.TechnicalFactoryAuditVisit != null && reportRequest.TechnicalFactoryAuditVisit.Any())
            {
                existingReport.TechnicalFactoryAuditVisit = CopyQuestionsRateList(reportRequest.TechnicalFactoryAuditVisit);
            }

            if (reportRequest.TotalMarks != null)
            {
                existingReport.TotalMarks = reportRequest.TotalMarks;
            }
            if (reportRequest.passed != null)
            {
                existingReport.passed = reportRequest.passed;
            }
            if (reportRequest.Grade != null)
            {
                existingReport.Grade = reportRequest.Grade;
            }

            if (existingReport.PrequalificationRequest != null)
            {
                existingReport.PrequalificationRequest.Status = RequestStatus.FACTORY_VISIT_REPORTED;
            }

            await _context.SaveChangesAsync();

            return existingReport;
        }

        private List<QuestionsRate> CopyQuestionsRateList(List<QuestionsRate> source)
        {
            if (source == null) return new List<QuestionsRate>();

            return source.Select(q => new QuestionsRate
            {
                QuestionNumber = q.QuestionNumber,
                Score = q.Score,
                Description = q.Description
            }).ToList();
        }

        public async Task<PagedResult<AssessmentReport>> GetAssessmentReportsPaginatedAsync(
           int page,
           int size,
           long? employeeId,
           string? vendorRepresentativeName)
        {
            var query = _context.AssessmentReports.AsQueryable();

            if (employeeId.HasValue)
            {
                query = query.Where(r => r.CreatedById == employeeId.Value);
            }

            if (!string.IsNullOrEmpty(vendorRepresentativeName))
            {
                var searchName = vendorRepresentativeName.ToLower();
                query = query.Where(r => r.PrequalificationRequest.Vendor.RepresentativeName != null &&
                                         r.PrequalificationRequest.Vendor.RepresentativeName.ToLower().Contains(searchName));
            }

            var totalCount = await query.CountAsync();

            var items = await query
                                   .Include(r => r.CreatedBy)
                                   .Include(r => r.PrequalificationRequest)
                                        .ThenInclude(pr => pr.Vendor)
                                   .OrderByDescending(r => r.Timestamp)
                                   .Skip(page * size)
                                   .Take(size)
                                   .ToListAsync();

            return new PagedResult<AssessmentReport>(items, totalCount, page, size);
        }


        public async Task<AssessmentReport?> UpdateFactoryAuditOutcomeAsync(long reportId, FactoryAuditOutcomeRequest request)
        {
            var existingReport = await _context.AssessmentReports
                .FirstOrDefaultAsync(r => r.Id == reportId);

            if (existingReport == null)
            {
                return null;
            }

            var outcome = existingReport.FactoryAuditOutcome;


            if (outcome == null)
            {
                outcome = new OutcomeFactoryAudit();
                existingReport.FactoryAuditOutcome = outcome;
            }

            outcome.Recommendation = request.Recommendation;
            outcome.AuditDate = request.AuditDate;
            outcome.FirstAuditorName = request.FirstAuditorName;
            outcome.SecondAuditorName = request.SecondAuditorName;
            outcome.TotalMarks = request.TotalMarks;
            outcome.passed = request.passed;
            outcome.Grade = request.Grade;
            outcome.Timestamp = DateTime.UtcNow;

            existingReport.Timestamp = DateTime.UtcNow;

            await _context.SaveChangesAsync();

            return existingReport;
        }

    }
}