using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Strata.Analytics.Biz.ContentMigration.Services;
using Strata.Analytics.Biz.ContentMigration.Models;
using Microsoft.AspNetCore.Http;
using System;
using Microsoft.AspNetCore.Authorization;
using Strata.Analytics.Api.Authorization;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Strata.Analytics.Biz.ContentMigration.Models.MigrationPlan;

namespace Strata.Analytics.Api.Controllers
{
    [ApiController]
    [ApiVersion("1.0")]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    public class ContentMigrationController : ControllerBase
    {
        private readonly IContentMigrationService _contentMigrationService;

        public ContentMigrationController(IContentMigrationService contentMigrationService)
        {
            _contentMigrationService = contentMigrationService;
        }

        [HttpGet("legacy-reports")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public async Task<IEnumerable<ReReportDisplay>> GetAdHocReports(CancellationToken cancellationToken)
        {
            return await _contentMigrationService.GetAdHocReports(cancellationToken);
        }

        [HttpPost("{reportGuid}/migrate")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<AdhocMigrationResult>> MigrateReport([FromRoute] Guid reportGuid, [FromQuery, BindRequired] int workbookId, [FromQuery, BindRequired] int dataSourceId, [FromBody] Plan plan, CancellationToken cancellationToken)
        {
            var migratedReport = await _contentMigrationService.MigrateReport(reportGuid, workbookId, dataSourceId, plan, cancellationToken);
            if (migratedReport == null)
            {
                return NotFound();
            }
            return Ok(migratedReport);
        }

        [HttpPost("{reportGuid}/migrateExtract")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<ExtractMigrationResult>> MigrateReportToExtract([FromRoute] Guid reportGuid, [FromQuery, BindRequired] int dataSourceId, [FromBody] Plan plan, CancellationToken cancellationToken)
        {
            var migratedReport = await _contentMigrationService.MigrateReportToExtract(reportGuid, dataSourceId, plan, cancellationToken);
            if (migratedReport == null)
            {
                return NotFound();
            }
            return Ok(migratedReport);
        }

        [HttpGet("migrationPlan")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<Plan>> GetMigrationPlan([FromQuery, BindRequired] Guid reportGuid, [FromQuery, BindRequired] int dataSourceId, CancellationToken cancellationToken)
        {
            var migrationPlan = await _contentMigrationService.GetMigrationPlan(reportGuid, dataSourceId, cancellationToken);
            if (migrationPlan == null)
            {
                return NotFound();
            }
            return Ok(migrationPlan);
        }

        [HttpPut("dataMappings")]
        [Authorize(Policy = Policies.StrataOnly)]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<DataMapping>> UpdateDataMapping([FromBody] DataMapping dataMapping, CancellationToken cancellationToken)
        {
            var updatedDataMapping = await _contentMigrationService.UpdateDataMapping(dataMapping, cancellationToken);
            if (updatedDataMapping == null)
            {
                return NotFound();
            }
            return Ok(updatedDataMapping);
        }

        [HttpGet("dataMappings")]
        [Authorize(Policy = Policies.StrataOnly)]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public async Task<ActionResult<IEnumerable<DataMapping>>> GetDataMappings(CancellationToken cancellationToken)
        {
            var dataMappings = await _contentMigrationService.GetDataMappings(cancellationToken);
            return Ok(dataMappings);
        }

        [HttpPost("dataMappings")]
        [Authorize(Policy = Policies.StrataOnly)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        public async Task<ActionResult> AddDataMappings([FromBody] IEnumerable<DataMapping> dataMappings, CancellationToken cancellationToken)
        {
            await _contentMigrationService.AddDataMappings(dataMappings, cancellationToken);
            return NoContent();
        }

        [HttpDelete("dataMappings/{dataMappingId}")]
        [Authorize(Policy = Policies.StrataOnly)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult> DeleteDataMapping([FromRoute] int dataMappingId, CancellationToken cancellationToken)
        {
            var mapping = await _contentMigrationService.GetDataMapping(dataMappingId, cancellationToken);
            if (mapping == null)
            {
                return NotFound();
            }

            await _contentMigrationService.DeleteDataMapping(mapping, cancellationToken);
            return NoContent();
        }
    }
}