using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using InternshipSystem.Api.Commands;
using InternshipSystem.Api.Security;
using InternshipSystem.Api.UseCases;
using InternshipSystem.Repository;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization;
using InternshipSystem.Api.Services;
using InternshipSystem.Core;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace InternshipSystem.Api.Controllers
{
    [Route("internshipRegistration")]
    public class InternshipRegistrationController : ControllerBase
    {
        private readonly InternshipDbContext _context;

        public InternshipRegistrationController(InternshipDbContext dbContext)
        {
            _context = dbContext;
        }
        
        /// <summary>
        /// Validate and add filled internship registration form 
        /// </summary>
        /// <response code="200">If registration form was successfully added</response>
        /// <response code="400">If the provided registration query was malformed</response>
        /// <response code="401">This action is only available for authorized student registered for current edition</response>
        [HttpPut]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [Authorize(Policy = Policies.RegisteredOnly)]
        public async Task<ActionResult> SubmitRegistrationForm(
            UpdateRegistrationForm registrationCommand, 
            [FromServices] User user, 
            CancellationToken cancellationToken)
        {
            var edition = await _context.Editions.FirstAsync(e => e.Id == user.EditionId, cancellationToken);

            var internshipRegistration =
                await _context
                    .Entry(edition)
                    .Collection(e => e.Internships)
                    .Query()
                    .Where(i => i.Student.Id == user.PersonNumber)
                    .Select(i => i.InternshipRegistration)
                        .Include(r => r.BranchAddress)
                        .Include(r => r.Type)
                        .Include(r => r.Subjects)
                        .Include(r => r.Company)
                        .Include(r => r.Company.Branches)
                    .FirstAsync(cancellationToken);
            
            var useCase = new UpdateInternshipRegistrationUseCase(_context, internshipRegistration, edition, user);
            
            var result = await useCase.UpdateInternshipRegistration(registrationCommand, cancellationToken);
            
            await _context.SaveChangesAsync(cancellationToken);

            return Ok(result);
        }

        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [Authorize(Policy = Policies.RegisteredOnly)]
        public async Task<ActionResult<Internship>> GetCurrentEditionInternship([FromServices] User user, CancellationToken cancellationToken)
        {
            var edition = await _context.Editions
                .FindAsync(user.EditionId);
            
            var internship = await _context.Entry(edition)
                .Collection(e => e.Internships)
                .Query()
                .Include(i => i.Student)
                .Include(i => i.InternshipRegistration)
                .Include(i => i.InternshipRegistration.Company)
                .Include(i => i.InternshipRegistration.BranchAddress)
                .Include(i => i.InternshipRegistration.Type)
                .Include(i => i.Report)
                .Include(i => i.Approvals)
                .Include(i => i.Documentation)
                .SingleAsync(i => i.Student.Id == user.PersonNumber, cancellationToken);

            internship.Edition = null;
            return Ok(internship);
        }
    }
}