using dy.net.model.dto;
using dy.net.service;
using jzc.http.lib;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace dy.net.Controllers
{
    [Route("api/storage/migrations")]
    [ApiController]
    [Authorize]
    public class StorageMigrationsController : ControllerBase
    {
        private readonly StorageMigrationService _service;

        public StorageMigrationsController(StorageMigrationService service) => _service = service;

        [HttpPost("preflight")]
        public async Task<IActionResult> Preflight([FromBody] StorageMigrationPreflightRequest request, CancellationToken cancellationToken) =>
            ApiResult.Success(await _service.PreflightAsync(request?.VerifyCapabilities ?? true, cancellationToken));

        [HttpPost]
        public async Task<IActionResult> Create([FromBody] CreateStorageMigrationRequest request, CancellationToken cancellationToken) =>
            await ExecuteAsync(async () => ApiResult.Success(await _service.CreateAsync(request, cancellationToken)));

        [HttpGet("latest")]
        public async Task<IActionResult> Latest() => ApiResult.Success(await _service.GetLatestAsync());

        [HttpGet("failed-records/preview")]
        public async Task<IActionResult> FailedRecordsPreview() =>
            ApiResult.Success(await _service.PreviewFailedRecordRemovalAsync());

        [HttpPost("failed-records/remove")]
        public async Task<IActionResult> RemoveFailedRecords([FromBody] RemoveFailedMigrationRecordsRequest request) =>
            await ExecuteAsync(async () => ApiResult.Success(await _service.RemoveFailedRecordsAsync(request)));

        [HttpPost("history/archive")]
        public async Task<IActionResult> ArchiveHistory() =>
            await ExecuteAsync(async () => ApiResult.Success(await _service.ArchiveAllSettledAsync()));

        [HttpGet("{id}")]
        public async Task<IActionResult> Get(string id) =>
            await ExecuteAsync(async () => ApiResult.Success(await _service.GetAsync(id)));

        [HttpGet("{id}/items")]
        public async Task<IActionResult> Items(string id, [FromQuery] StorageMigrationItemPageRequest request) =>
            await ExecuteAsync(async () => ApiResult.Success(await _service.GetItemsAsync(id, request)));

        [HttpPost("{id}/pause")]
        public Task<IActionResult> Pause(string id) => ExecuteActionAsync(() => _service.PauseAsync(id));

        [HttpPost("{id}/resume")]
        public Task<IActionResult> Resume(string id) => ExecuteActionAsync(() => _service.ResumeAsync(id));

        [HttpPost("{id}/cancel")]
        public Task<IActionResult> Cancel(string id) => ExecuteActionAsync(() => _service.CancelAsync(id));

        [HttpPost("{id}/retry-failed")]
        public Task<IActionResult> RetryFailed(string id) => ExecuteActionAsync(() => _service.RetryFailedAsync(id));

        [HttpPost("{id}/cleanup")]
        public Task<IActionResult> Cleanup(string id, CancellationToken cancellationToken) =>
            ExecuteActionAsync(() => _service.CleanupAsync(id, cancellationToken));

        [HttpPost("{id}/rollback")]
        public Task<IActionResult> Rollback(string id, CancellationToken cancellationToken) =>
            ExecuteActionAsync(() => _service.RollbackAsync(id, cancellationToken));

        [HttpPost("{id}/archive")]
        public Task<IActionResult> Archive(string id) => ExecuteActionAsync(() => _service.ArchiveAsync(id));

        private async Task<IActionResult> ExecuteActionAsync(Func<Task> action) =>
            await ExecuteAsync(async () =>
            {
                await action();
                return ApiResult.Success("操作已提交");
            });

        private static async Task<IActionResult> ExecuteAsync(Func<Task<IActionResult>> action)
        {
            try { return await action(); }
            catch (Exception ex) when (ex is InvalidOperationException or KeyNotFoundException)
            {
                return ApiResult.Fail(ex.Message);
            }
        }
    }
}