using Microsoft.AspNetCore.Authorization;
using vendorApproverBackend.Requests;
using vendorApproverBackend.Responses;
using vendorApproverBackend.Services;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;

[Route("api/assessment-reports")]
[ApiController]
public class AssessmentReportController : ControllerBase
{
    private readonly AssessmentReportService _assessmentReportService;
    private readonly PrequalificationRequestService _requestService;

    private readonly UserService _userService;

    public AssessmentReportController(
        UserService userService,
        AssessmentReportService assessmentReportService,
        PrequalificationRequestService requestService)
    {
        _assessmentReportService = assessmentReportService;
        _requestService = requestService;
        _userService = userService;
    }

    [HttpGet("get-report-by-id/{id}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> GetAssessmentReport(long id)
    {
        var report = await _assessmentReportService.FindAssessmentReportByIdAsync(id);

        if (report == null)
        {
            return NotFound("Assessment Report not found.");
        }

        return Ok(report);
    }

    [HttpGet("get-report-by-request-id/{prequalificationRequestId}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> GetAssessmentReportByRequestId(long prequalificationRequestId)
    {
        var report = await _assessmentReportService.GetAssessmentReportByPrequalificationRequestIdAsync(prequalificationRequestId);

        if (report == null)
        {
            return NotFound($"Assessment Report not found for Request ID {prequalificationRequestId}.");
        }

        return Ok(report);
    }

    [HttpPost("add-evaluator-report/{requestId}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> CreateAssessmentReport(
        [FromBody] AssessmentReportRequest request, long requestId)
    {
        var username = User.FindFirstValue(ClaimTypes.Name);

        if (string.IsNullOrEmpty(username))
        {
            return Unauthorized("Username claim not found in token.");
        }
        var currentUser = await _userService.FindByUsernameAsync(username);

        if (currentUser == null)
        {
            return NotFound("User not found.");
        }

        var prequalRequest = await _requestService.GetRequestByIdAsync(requestId);

        if (prequalRequest == null)
        {
            return NotFound($"Prequalification Request with ID {requestId} not found.");
        }

        try
        {
            var report = await _assessmentReportService.AddAssessmentReportAsync(
                currentUser,
                prequalRequest,
                request
            );

            return CreatedAtAction(nameof(GetAssessmentReport), new { id = report.Id }, report);
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }


    [HttpPost("add-inspector-report/{requestId}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> CreateAssessmenInspectorReport(
    [FromBody] InspectorReportRequest request, long requestId)
    {
        var username = User.FindFirstValue(ClaimTypes.Name);

        if (string.IsNullOrEmpty(username))
            return Unauthorized("Username claim not found in token.");

        var currentUser = await _userService.FindByUsernameAsync(username);

        if (currentUser == null)
            return NotFound("User not found.");

        var prequalRequest = await _requestService.GetRequestByIdAsync(requestId);

        if (prequalRequest == null)
            return NotFound($"Prequalification Request with ID {requestId} not found.");

        try
        {
            var report = await _assessmentReportService.AddInspectorReportAsync(
                currentUser,
                prequalRequest,
                request
            );

            return CreatedAtAction(nameof(GetAssessmentReport), new { id = report.Id }, report);
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }


    [HttpPatch("update-repport/{reportId}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> UpdateAssessmentReport(
        long reportId,
        [FromBody] UpdateReportRequest request)
    {
        var updatedReport = await _assessmentReportService.UpdateAssessmentReportAsync(reportId, request);

        if (updatedReport == null)
        {
            return NotFound("Assessment Report not found for update.");
        }

        return Ok(updatedReport);
    }

    [HttpGet("get-reports-paginator")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<PagedResult<AssessmentReport>>> GetAssessmentReports(
       [FromQuery] int page = 0,
       [FromQuery] int size = 5,
       [FromQuery] long? employeeId = null,
       [FromQuery] string? vendorRepresentativeName = null)
    {
        var result = await _assessmentReportService.GetAssessmentReportsPaginatedAsync(
            page,
            size,
            employeeId,
            vendorRepresentativeName
        );

        return Ok(result);
    }


    [HttpPatch("add-factory-audit-outcome/{repportId}")]
    [Authorize(Roles = "ADMIN,EMPLOYEE,VENDOR,FINANCIAL")]
    public async Task<ActionResult<AssessmentReport>> UpdateFactoryAuditOutcome(
       long repportId,
       [FromBody] FactoryAuditOutcomeRequest request)
    {
        var updatedReport = await _assessmentReportService.UpdateFactoryAuditOutcomeAsync(repportId, request);

        if (updatedReport == null)
        {
            return NotFound("Assessment Report not found for audit outcome update.");
        }

        return Ok(updatedReport);
    }
}