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

using vendorApproverBackend.Responses; 
using System.Threading.Tasks;

namespace vendorApproverBackend.Services
{
    public class EvaluationService
{
    private readonly DataContext _context;
    public EvaluationService(DataContext context) => _context = context;

    private async Task PopulateSupplierInfo(EvaluationData eval)
    {
        if (eval == null) return;
        var request = await _context.RequestRenews.FindAsync(eval.RequestRenewId);
        if (request != null)
        {
            var cert = await _context.Certifications.FindAsync(request.CertificationId);
            if (cert != null)
            {
                eval.SupplierName = cert.SupplierName;
                eval.CertificationNumber = cert.CertificationNumber;
            }
        }
    }

   /*  public async Task<EvaluationData> Add(long requestRenewId, EvaluationData data)
    {
        data.RequestRenewId = requestRenewId;
        data.Timestamp = DateTime.UtcNow;
        _context.EvaluationDatas.Add(data);
        await _context.SaveChangesAsync();
        await PopulateSupplierInfo(data);
        return data;
    } */

    public async Task<EvaluationData> Add(long requestRenewId, EvaluationData data)
{
    // 1. Always save EvaluationData (must never fail because of status logic)
    data.RequestRenewId = requestRenewId;
    data.Timestamp = DateTime.UtcNow;

    _context.EvaluationDatas.Add(data);
    await _context.SaveChangesAsync();

    // 2. Best-effort update logic (isolated in try-catch)
    try
    {
        if (data.Status != EvaluationStatusEnum.PENDING)
        {
            var requestRenew = await _context.RequestRenews
                .FirstOrDefaultAsync(r => r.Id == data.RequestRenewId);

            if (requestRenew != null)
            {
                // Map EvaluationStatusEnum → RequestRenewStatus
                requestRenew.Status = (RequestRenewStatus)Enum.Parse(
                    typeof(RequestRenewStatus),
                    data.Status.ToString()
                );

                // If APPROVED → update Certification
                if (data.Status == EvaluationStatusEnum.APPROVED)
                {
                    var certification = await _context.Certifications
                        .FirstOrDefaultAsync(c => c.Id == requestRenew.CertificationId);

                    if (certification != null)
                    {
                        certification.Status = CertificationStatus.ACTIVE;
                        certification.ExpiryDate = certification.ExpiryDate.AddYears(3);
                    }
                }

                await _context.SaveChangesAsync();
            }
        }
    }
    catch (Exception ex)
            {
            
            }

    await PopulateSupplierInfo(data);
    return data;
}

    public async Task<EvaluationData> Update(long id, EvaluationData updatedData)
    {
        var existing = await _context.EvaluationDatas.FindAsync(id);
        if (existing == null) return null;

        if (updatedData.TotalScore != 0) existing.TotalScore = updatedData.TotalScore;
        if (updatedData.EvaluationDate != null) existing.EvaluationDate = updatedData.EvaluationDate;
        if (updatedData.EvaluatedBy != null) existing.EvaluatedBy = updatedData.EvaluatedBy;
        if (updatedData.Evaluation != null) existing.Evaluation = updatedData.Evaluation;

        await _context.SaveChangesAsync();
        await PopulateSupplierInfo(existing);
        return existing;
    }

    public async Task<EvaluationData> GetById(long id)
    {
        var eval = await _context.EvaluationDatas.FindAsync(id);
        await PopulateSupplierInfo(eval);
        return eval;
    }

    public async Task Delete(long id)
    {
        var eval = await _context.EvaluationDatas.FindAsync(id);
        if (eval != null) { _context.EvaluationDatas.Remove(eval); await _context.SaveChangesAsync(); }
    }

    public async Task UpdateStatus(long id, EvaluationStatusEnum status)
    {
        var eval = await _context.EvaluationDatas.FindAsync(id);
        if (eval != null) { eval.Status = status; await _context.SaveChangesAsync(); }
    }

    public async Task<PagedResult<EvaluationData>> GetAll(int page, int size)
        {
            var query = _context.EvaluationDatas.OrderByDescending(e => e.Timestamp);
            var totalCount = await query.CountAsync();
            
            var items = await query
                .Skip(page * size)
                .Take(size)
                .ToListAsync();
            foreach (var item in items) 
            { 
                await PopulateSupplierInfo(item); 
            }


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