using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AutoMapper;
using AutoMapper.QueryableExtensions;
using InternshipSystem.Api.Queries.SearchQuery;
using InternshipSystem.Api.Result;
using InternshipSystem.Api.Security;
using InternshipSystem.Repository;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace InternshipSystem.Api.Controllers
{
    [ApiController]
    [Route("editionManagement")]
    public class EditionManagementController : ControllerBase
    {
        private InternshipDbContext Context { get; }
        private IMapper Mapper { get; }
        
        public EditionManagementController(IMapper mapper, InternshipDbContext context)
        {
            Context = context;
            Mapper = mapper;
        }

        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [Authorize(Policy = Policies.IsOverseer)]
        public async Task<ActionResult<IReadOnlyCollection<EditionManagementResult>>> GetEditions([FromQuery] EditionSearchQuery searchQuery, CancellationToken token) =>
            await Context.Editions
                .Include(e => e.Course)
                .ProjectTo<EditionManagementResult>(Mapper.ConfigurationProvider)
                .Skip(searchQuery.Page * searchQuery.PerPage)
                .Take(searchQuery.PerPage)
                .ToListAsync(token);

        [HttpGet("{editionId}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [Authorize(Policy = Policies.IsOverseer)]
        public async Task<ActionResult<EditionFullResult>> GetFullEdition(CancellationToken token)
        {
            var edition = await Context.Editions
                .Include(e => e.Course)
                .Include(e => e.AvailableSubjects)
                    .ThenInclude(s => s.Subject)
                .Include(e => e.AvailableInternshipTypes)
                    .ThenInclude(i => i.InternshipType)
                .ProjectTo<EditionFullResult>(Mapper.ConfigurationProvider)
                .FirstOrDefaultAsync(token);

            if (edition == null)
            {
                return NotFound();
            }

            return Ok(edition);
        }
        
        [HttpPut]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [Authorize(Policy = Policies.IsOverseer)]
        public async Task<ActionResult> UpsertEdition(EditionForm editionForm, CancellationToken token)
        {
            var validator = new EditionForm.Validator();
            // TODO: complete validation rules
            var validationResult = await validator.ValidateAsync(editionForm, token);

            if (!validationResult.IsValid)
            {
                return BadRequest(validationResult.ToString());
            }
            
            // TODO: complete add/update

            return Ok();
        }
        
        [HttpDelete("{editionId}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status409Conflict)]
        [Authorize(Policy = Policies.IsOverseer)]
        public async Task<ActionResult> DeleteEdition(Guid editionId, CancellationToken token)
        {
            var editionToDelete = await Context.Editions
                .Include(e => e.AvailableSubjects)
                .Include(e => e.AvailableInternshipTypes)
                .FirstOrDefaultAsync(e => e.Id.Equals(editionId), token);

            if (editionToDelete == null)
            {
                return NotFound();
            }

            var referencedInternships = 
                await Context
                    .Entry(editionToDelete)
                    .Collection(e => e.Internships)
                    .Query()
                    .CountAsync(token);

            if (referencedInternships > 0)
            {
                return Conflict();
            }
            
            Context.Editions.Attach(editionToDelete);
            Context.Editions.Remove(editionToDelete);
            await Context.SaveChangesAsync(token);
            return Ok();
        }
    }
}