using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Strata.ApiLib.Standard.Models;
using Strata.ContinuousImprovement.Api.Generics;
using Strata.ContinuousImprovement.Biz.Exploration.Filters;
using Strata.ContinuousImprovement.Biz.Exploration.Opportunities;
using Strata.ContinuousImprovement.Biz.Generics;
using Strata.ContinuousImprovement.Biz.OpportunityComments;
using Strata.ContinuousImprovement.Biz.Pagination;
using Strata.ContinuousImprovement.Biz.Shared;
using Strata.ContinuousImprovement.Biz.Utilities;
using Strata.CoreLib.Claims.Extensions;
using Strata.FeatureFlags.Client;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;

namespace Strata.ContinuousImprovement.Api.Controllers
{
    [ApiController]
    [ApiVersion("1.0")]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    public class ExplorationOpportunitiesController : OpportunityController<EXOpportunity>
    {
        private readonly IEXOpportunityService _opportunityService;
        private readonly ICommentService _commentService;
        private readonly IFeatureFlagServiceClient _featureFlagServiceClient;
        private readonly ILogger<ExplorationOpportunitiesController> _logger;

        public ExplorationOpportunitiesController(IEXOpportunityService opportunityService,
            ICommentService commentService,
            IFeatureFlagServiceClient featureFlagServiceClient,
            ILogger<ExplorationOpportunitiesController> logger) : base(opportunityService)
        {
            _opportunityService = opportunityService;
            _commentService = commentService;
            _featureFlagServiceClient = featureFlagServiceClient;
            _logger = logger;
        }

        [HttpGet("[action]")]
        public async Task<bool> GetEnabled(CancellationToken cancellationToken)
        {
            var databaseGuid = User?.GetDatabaseGuid() ?? Guid.Empty;
            var hasFlexibleExplorartion = User.IsSdtEmployee()
                || (await _featureFlagServiceClient.IsEnabledAsync("ciflexibleexplorationenabled", databaseGuid, cancellationToken: cancellationToken));
            var dict = new Dictionary<string, object> { { "isSdtEmployee", User.IsSdtEmployee() }, { "hasFlexibleExploration", hasFlexibleExplorartion } };
            _logger.LogServiceInformation("CI Flexible Exploration Enabled", dict);
            return hasFlexibleExplorartion;
        }

        [HttpPost("")]
        public async Task<PagedApiResponse<EXOpportunity>> GetOpportunities(EXOpportunityLoadOptions loadOptions, CancellationToken cancellationToken)
        {
            return await OpportunityService.GetPagedAsync(loadOptions.PagingOptions, loadOptions.Filters, cancellationToken);
        }

        [HttpGet("{opportunityGuid}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<EXOpportunity>> GetById(Guid opportunityGuid, CancellationToken cancellationToken)
        {
            return Ok(await _opportunityService.GetById(opportunityGuid, cancellationToken));
        }

        [HttpPut("{opportunityGuid}/[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesDefaultResponseType]
        public async Task CheckWorkbook(Guid opportunityGuid, CancellationToken cancellationToken)
            => await _opportunityService.CheckWorkbook(opportunityGuid, cancellationToken);

        [HttpPost("[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<EXOpportunity>> Create(EXOpportunityDto savedOpportunity, CancellationToken cancellationToken)
        {
            var newOpportunity = new EXOpportunity
            {
                ConfigurationGuid = savedOpportunity.ConfigurationGuid,
                Name = savedOpportunity.Name,
                Description = savedOpportunity.Description
            };

            return Ok(await _opportunityService.CreateAsync(newOpportunity, User?.Identity?.Name, cancellationToken));
        }

        [HttpPost("[action]")]
        [ProducesResponseType(StatusCodes.Status201Created)]
        public async Task<IActionResult> Export(EXOpportunityExportOptions exportOptions, CancellationToken cancellationToken)
        {
            var workbook = await ((IEXOpportunityService)OpportunityService).ExportAsync(exportOptions.SortOptions, exportOptions.Filters, cancellationToken);
            return new ExcelContentResult(workbook, "EX_Opportunities");

        }

        [HttpPut("{opportunityGuid}/[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<EXOpportunity>> Update(Guid opportunityGuid, EXOpportunity opportunity, CancellationToken cancellationToken)
        {
            var opp = await _opportunityService.GetById(opportunityGuid, cancellationToken);
            if (opp == null)
            {
                return BadRequest();
            }
            return Ok(await _opportunityService.UpdateAsync(opportunity, cancellationToken));
        }

        [HttpPut("{opportunityGuid}/[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<EXOpportunity>> SetStatus(Guid opportunityGuid, [FromBody] InitiativeStatuses status, CancellationToken cancellationToken)
        {
            var opp = await _opportunityService.GetById(opportunityGuid, cancellationToken);
            if (opp == null)
            {
                return BadRequest();
            }
            opp.InitiativeStatus = status;
            return Ok(await _opportunityService.UpdateAsync(opp, cancellationToken));
        }

        [HttpDelete("{opportunityGuid}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult> Delete(Guid opportunityGuid, CancellationToken cancellationToken)
        {
            var opp = await _opportunityService.GetById(opportunityGuid, cancellationToken);
            if (opp == null)
            {
                return BadRequest();
            }
            await ((IEXOpportunityService)_opportunityService).DeleteAsync(opportunityGuid, cancellationToken);
            var databaseGuid = User?.GetDatabaseGuid() ?? Guid.Empty;
            await _commentService.DeleteCommentsAsync(databaseGuid, (int)OpportunityTypes.Blank, opp.OpportunityId, cancellationToken);
            return Ok();
        }

        [HttpGet("{configurationGuid}/[action]")]
        public async Task<EXFilterOptions> GetFilterOptionsAsync(Guid configurationGuid, CancellationToken cancellationToken)
        {
            return await ((IEXOpportunityService)OpportunityService).GetFilterOptionsAsync(configurationGuid, cancellationToken);
        }

        public class EXOpportunityDto
        {
            [Required]
            [StringLength(200)]
            public string Name { get; set; }
            public string Description { get; set; }
            public Guid ConfigurationGuid { get; set; }
        }

        [ExcludeFromCodeCoverage]
        public class EXOpportunityLoadOptions
        {
            public PagingOptions PagingOptions { get; set; }
            public EXFilters Filters { get; set; }
        }

        [ExcludeFromCodeCoverage]
        public class EXOpportunityExportOptions
        {
            public SortOptions SortOptions { get; set; }
            public EXFilters Filters { get; set; }
        }
    }
}