using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;


/// <summary>
/// Batch CRUD, document upload, and assignment for the digitization workflow.
/// </summary>
[ApiController]
[Route("api/v1/digitization-batches")]
[Produces("application/json")]
[Authorize]
public class DigitizationBatchesController : ControllerBase
{
    private readonly IBatchService _batches;
    private readonly IDocumentStorageService _storage;

    private static readonly HashSet<string> _allowedMimeTypes = new()
    {
        "application/pdf", "image/jpeg", "image/png"
    };

    public DigitizationBatchesController(IBatchService batches, IDocumentStorageService storage)
    {
        _batches = batches;
        _storage = storage;
    }

    /// <summary>
    /// Uploads a scanned document and creates a new digitization batch.
    /// </summary>
    [HttpPost]
    [Consumes("multipart/form-data")]
    [ProducesResponseType(typeof(ApiResponse<BatchDetailResponse>), StatusCodes.Status201Created)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status400BadRequest)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status409Conflict)]
    [RequestSizeLimit(25 * 1024 * 1024)]
    public async Task<IActionResult> Create([FromForm] CreateBatchForm form)
    {
        if (form.File is null || form.File.Length == 0)
            return BadRequest(ApiResponse<object>.Fail(400, "File is required.", "EMPTY_FILE"));

        if (!_allowedMimeTypes.Contains(form.File.ContentType))
            return BadRequest(ApiResponse<object>.Fail(400,
                "Accepted formats: PDF, JPEG, PNG.", "INVALID_MIME_TYPE"));

        var req = form.ToMetadata();
        var parsedBatchType = BatchTypeExtensions.FromDbString(req.BatchType.ToUpperInvariant());
        var parsedTrack = string.IsNullOrEmpty(req.Track)
            ? BatchTrack.Backfill
            : BatchTrackExtensions.FromDbString(req.Track.ToUpperInvariant());
        var actorUserId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);

        using var stream = form.File.OpenReadStream();
        var batch = await _batches.CreateAsync(
            stream, form.File.ContentType, parsedBatchType, parsedTrack, req.PatientId, actorUserId);
        return StatusCode(201, ApiResponse<BatchDetailResponse>.Created(BatchDetailResponse.FromEntity(batch)));
    }

    /// <summary>
    /// Gets a batch by ID with a presigned document URL (15-minute expiry).
    /// </summary>
    [HttpGet("{id:guid}")]
    [ProducesResponseType(typeof(ApiResponse<BatchDetailResponse>), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Get(Guid id)
    {
        var batch = await _batches.GetByIdAsync(id);
        var presignedUrl = await _storage.GetPresignedUrlAsync(batch.DocumentRef);

        return Ok(ApiResponse<BatchDetailResponse>.Ok(
            BatchDetailResponse.FromEntity(batch, presignedUrl)));
    }

    /// <summary>
    /// Lists batches with optional filters and pagination.
    /// </summary>
    [HttpGet]
    [ProducesResponseType(typeof(ApiResponse<BatchListResponse>), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status401Unauthorized)]
    public async Task<IActionResult> List(
        [FromQuery] string? status,
        [FromQuery] string? batchType,
        [FromQuery] Guid? assignedTo,
        [FromQuery] string? track,
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 20)
    {
        BatchStatus? parsedStatus = string.IsNullOrEmpty(status) ? null : BatchStatusExtensions.FromDbString(status.ToUpperInvariant());
        BatchType? parsedBatchType = string.IsNullOrEmpty(batchType) ? null : BatchTypeExtensions.FromDbString(batchType.ToUpperInvariant());
        BatchTrack? parsedTrack = string.IsNullOrEmpty(track) ? null : BatchTrackExtensions.FromDbString(track.ToUpperInvariant());

        var result = await _batches.ListAsync(parsedStatus, parsedBatchType, assignedTo, parsedTrack, page, pageSize);
        return Ok(ApiResponse<BatchListResponse>.Ok(new BatchListResponse(
            result.Items.Select(b => BatchDetailResponse.FromEntity(b)).ToList(),
            result.Page,
            result.PageSize,
            result.TotalCount,
            result.TotalPages)));
    }

    /// <summary>
    /// Assigns a batch to an entry clerk. Uses Redis lock to prevent double-assignment.
    /// </summary>
    [HttpPatch("{id:guid}/assign")]
    [ProducesResponseType(typeof(ApiResponse<BatchDetailResponse>), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status401Unauthorized)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status409Conflict)]
    public async Task<IActionResult> Assign(Guid id, [FromBody] AssignBatchRequest req)
    {
        var actorUserId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);
        var batch = await _batches.AssignAsync(id, req.EntryClerkUserId, actorUserId);
        return Ok(ApiResponse<BatchDetailResponse>.Ok(BatchDetailResponse.FromEntity(batch)));
    }
}