using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Migrations;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;
using System.Web.Http.Description;
using Dyntell.OnlineExam.Controllers.Model;
using Dyntell.OnlineExam.DAL;
using Dyntell.OnlineExam.DAL.ExamQuestions;
using Dyntell.OnlineExam.DAL.Exams;
using Dyntell.OnlineExam.DAL.Migrations;
using Dyntell.OnlineExam.DAL.Models.Account.Identity;
using Dyntell.OnlineExam.DAL.Questions;
using Dyntell.OnlineExam.Enums;
using Dyntell.OnlineExam.Models.Email;
using Dyntell.OnlineExam.Models.QueryFilter;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.Owin;
using Quartz.Util;
using Dyntell.OnlineExam.Services;

namespace Dyntell.OnlineExam.Controllers.API
{
    class ExamResponse
    {
        public List<ExamModel> Exams { get; set; }
        public int TotalCount { get; set; }
    }

    [Authorize(Roles = "Admin, Examinee, Examiner")]
    [RoutePrefix("api/Exam")]
    public class ExamController : ApiController
    {
        private static List<int> _questionIds = new List<int>();
        private static DateTime _staticDate = new DateTime(2000,1,1);

        private readonly IOnlineExamContext _dbContext;
        private readonly IExamQuestionService _examQuestionService;
        private readonly IQuestionService _questionService;
        private readonly EmailService _emailService = new EmailService();

        public ExamController(IOnlineExamContext dbContext
            , IExamQuestionService examQuestionService
            , IQuestionService questionService
            )
        {
            _dbContext = dbContext;
            _examQuestionService = examQuestionService;
            _questionService = questionService;
        }

        // GET: api/Exam
        [System.Web.Http.HttpPost]
        [Route("ExamQueryFilter")]
        [ResponseType(typeof(ExamResponse))]
        public async Task<IHttpActionResult> GetExams(ExamQueryFilter examQueryFilter)
        {
            var userId = User.Identity.GetUserId();
            var userManager = Request.GetOwinContext().GetUserManager<ApplicationUserManager>();
            var role = userManager.GetRolesAsync(userId).Result.FirstOrDefault();
            if (role == "Admin")
            {
                /*var exams = _dbContext.Exams
                    .Include(e => e.User)
                    .Include(e => e.CreatedBy).OrderByDescending(e => e.Created)
                    .ToList();*/
                //TODO ezt valahogy meg kellene csinálni hogy csak a szükséges cloumokat includálja LZS
                var exams = _dbContext.Exams.Select(e =>
                    new ExamModel()
                    {
                        ID = e.ID,
                        Activated = e.Activated,
                        Attempt = e.Attempt,
                        Auto = e.Auto,
                        BrakeTime = e.BrakeTime,
                        Break = e.Break,
                        Count = e.Count,
                        Created = e.Created,
                        CreatedBy = null,
                        Duration = e.Duration,
                        CreatedById = e.CreatedById,
                        ExamDate = e.ExamDate,
                        Repeatable = e.Repeatable,
                        Status = e.Status,
                        User = null,
                        UserId = e.UserId,
                        Title = e.Title,
                        TotalScore = e.TotalScore,
                        TotalTimeUsed = e.TotalTimeUsed,
                        LastOrder = e.LastOrder
                    }).ToList();

                foreach (var exam in exams)
                {
                    exam.User = _dbContext.Users.FirstOrDefault(u => u.Id == exam.UserId);
                    exam.CreatedBy = _dbContext.Users.FirstOrDefault(u => u.Id == exam.CreatedById);
                }

                exams = FilterExams(exams, examQueryFilter);
                var totalCount = exams.Count;

                exams = OrderExams(exams, examQueryFilter.ExamOrder, examQueryFilter.IsReverse);
                exams = exams.Skip((examQueryFilter.PageIndex - 1) * examQueryFilter.PageSize).Take(examQueryFilter.PageSize).ToList();
                return Ok(new ExamResponse() {Exams = exams.ToList(), TotalCount = totalCount});
            }
            else
            {
                /*var exams = _dbContext.Exams.Where(e => e.CreatedById == userId)
                    .Include(e => e.User)
                    .Include(e => e.CreatedBy).OrderByDescending(e => e.Created)
                    .ToList();*/
                //TODO ezt valahogy meg kellene csinálni hogy csak a szükséges cloumokat includálja LZS
                var exams = _dbContext.Exams.Select(e =>
                    new ExamModel()
                    {
                        ID = e.ID,
                        Activated = e.Activated,
                        Attempt = e.Attempt,
                        Auto = e.Auto,
                        BrakeTime = e.BrakeTime,
                        Break = e.Break,
                        Count = e.Count,
                        Created = e.Created,
                        CreatedBy = null,
                        Duration = e.Duration,
                        CreatedById = e.CreatedById,
                        ExamDate = e.ExamDate,
                        Repeatable = e.Repeatable,
                        Status = e.Status,
                        User = null,
                        UserId = e.UserId,
                        Title = e.Title,
                        TotalScore = e.TotalScore,
                        TotalTimeUsed = e.TotalTimeUsed,
                        LastOrder = e.LastOrder
                    }).Where(e => e.CreatedById == userId).ToList();

                foreach (var exam in exams)
                {
                    exam.User = _dbContext.Users.FirstOrDefault(u => u.Id == exam.UserId);
                    exam.CreatedBy = _dbContext.Users.FirstOrDefault(u => u.Id == exam.CreatedById);
                }

                var totalCount = exams.Count;

                exams = FilterExams(exams, examQueryFilter);
                exams = OrderExams(exams, examQueryFilter.ExamOrder, examQueryFilter.IsReverse);
                exams = exams.Skip((examQueryFilter.PageIndex - 1) * examQueryFilter.PageSize).Take(examQueryFilter.PageSize).ToList();
                return Ok(new ExamResponse() { Exams = exams.ToList(), TotalCount = totalCount });
            }
        }

        // GET: api/Exam/5
        [ResponseType(typeof(Exam))]
        public async Task<IHttpActionResult> GetExam(Guid id)
        {
            Exam exam = await _dbContext.Exams.Where(e => e.ID == id).FirstOrDefaultAsync();

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

            return Ok(exam);
        }

        // PUT: api/Exam/5
        [ResponseType(typeof(void))]
        public async Task<IHttpActionResult> PutExam(Guid id, Exam exam)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != exam.ID)
            {
                return BadRequest();
            }
            /*var questions = _dbContext.ExamQuestions.Where(e => e.Exam.ID == id);

            int timeUsedMinutes=0;
            int timeUsedSeconds=0;
            //exam.TotalTimeUsed
            foreach (var q in questions)
            {
                timeUsedMinutes += q.TimeUsed.Minutes;
                timeUsedSeconds += q.TimeUsed.Seconds;
            }

            exam.TotalTimeUsed = new TimeSpan(0, timeUsedMinutes, timeUsedSeconds);
            */
            _dbContext.Exams.AddOrUpdate(exam);

            try
            {
                await _dbContext.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ExamExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        // POST: api/Exam
        [ResponseType(typeof(Exam))]
        public async Task<IHttpActionResult> PostExam(Exam exam)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var createdBy = _dbContext.Users.FirstOrDefault(u => u.UserName == exam.CreatedById);
            var candidate = _dbContext.Users.FirstOrDefault(u => u.Id == exam.UserId);

            exam.CreatedBy = createdBy;
            exam.CreatedById = createdBy.Id;
            exam.User = candidate;
            exam.UserId = candidate.Id;
            exam.ExamDate = exam.ExamDate.ToLocalTime();
            exam.ID = Guid.NewGuid();
            exam.Attempt = 3;
            exam.LastOrder = 1;
            exam.BrakeTime = new TimeSpan(0,30,0);

            _dbContext.Exams.Add(exam);
            await _dbContext.SaveChangesAsync();
            try
            {
                //  A selectedmodules alapján a generálás elvégzése és a generált vizsgakérdések db-be mentése
                var examQuestions = new ExamGenerator(_questionService,_dbContext).GenerateExamQuestions(exam);
                if (exam.Created != _staticDate)
                {

                }
                else
                {
                    var counter = 1;
                    examQuestions = new List<ExamQuestion>();
                    var questions = _dbContext.ExamQuestions.Include(q => q.Module).Include(q => q.Choices);
                    foreach (var id in _questionIds)
                    {
                        var question = _dbContext.ExamQuestions.Include(q => q.Module).Include(q => q.Choices).Where(q => q.ID == id).FirstOrDefault();
                        var module = _dbContext.Modules.Where(m => m.ID == question.Module.ID).FirstOrDefault();
                        var choices = _dbContext.Choices.Include(c => c.ExamQuestion).Where(c => c.ExamQuestion.ID == question.ID).ToList();

                        examQuestions.Add(Convert(question, exam));
                    }
                }

                var examLengthSum = examQuestions.Sum(e => e.Duration.TotalSeconds);
                if (examLengthSum > exam.Duration.TotalSeconds || exam.Duration.TotalSeconds <= 0)
                {
                    throw new InvalidOperationException("Kérdések idejének összhossza meghaladja a teljes vizsga idejét");
                }

                //ezt valahogy belekellene irni a exam generatorba
                int i = 1;
                foreach (var examQuestion in examQuestions)
                {
                    examQuestion.Order=i;
                    i++;
                    if (examQuestion.QuestionType == 0) exam.Auto = false;
                }
                //
                exam.Count = examQuestions.Count;
                if (examQuestions.Count > 0)
                {
                    _dbContext.ExamQuestions.AddRange(examQuestions);
                    exam.TotalTimeUsed = new TimeSpan(examQuestions.Sum(x => x.Duration.Ticks));
                    exam.Duration = new TimeSpan(examQuestions.Sum(x => x.Duration.Ticks));
                    _dbContext.Entry(exam).State = EntityState.Modified;
                    await _dbContext.SaveChangesAsync();
                    if (exam.Created != _staticDate)
                    {
                        _staticDate = exam.Created;
                        _questionIds = new List<int>();
                        foreach (var eq in examQuestions)
                        {
                            _questionIds.Add(eq.ID);
                        }
                    }
                }

            }
            catch (DbUpdateException)
            {
                if (ExamExists(exam.ID))
                {
                    return Conflict();
                }
                throw;
            }
            catch (InvalidOperationException ex)
            {
                _dbContext.Exams.Remove(exam);
                await _dbContext.SaveChangesAsync();
                return BadRequest(ex.Message);
            }
            if (_dbContext.EmailNotifications.Where(n => n.Period == 0).FirstOrDefault().IsActive)
            {
                Email email = new Email()
                {
                    From = "dyntellonlineexam@gmail.com",
                    To = exam.User.Email,
                    Host = "smtp.gmail.com",
                    Password = "AdminEbv3fv",
                    Subject = _emailService.GetCreatedMailSubject(),
                    Body = _emailService.GetCreatedEmailBody(exam.User.Name, exam.Title, exam.ExamDate, exam.CreatedBy.Name, exam.Duration)
                };
                _emailService.SendEmail(email);
            }
            return CreatedAtRoute("DefaultApi", new { id = exam.ID }, exam);
        }

        // DELETE: api/Exam/5
        [ResponseType(typeof(Exam))]
        public async Task<IHttpActionResult> DeleteExam(Guid id)
        {
            Exam exam = await _dbContext.Exams.FindAsync(id);
            var examinee = _dbContext.Users.Where(u => u.Id == exam.UserId).Select(u => new {u.Name, u.Email}).FirstOrDefault();
            if (exam == null)
            {
                return NotFound();
            }

            _dbContext.Exams.Remove(exam);
            await _dbContext.SaveChangesAsync();

            Email email = new Email()
            {
                From = "dyntellonlineexam@gmail.com",
                To = examinee.Email,
                Host = "smtp.gmail.com",
                Password = "AdminEbv3fv",
                Subject = _emailService.GetDeletedMailSubject(),
                Body = _emailService.GetDeletedEmailBody(examinee.Name, exam.Title, exam.ExamDate)
            };
            _emailService.SendEmail(email);
            return Ok(exam);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _dbContext.Dispose();
            }
            base.Dispose(disposing);
        }

        private bool ExamExists(Guid id)
        {
            return _dbContext.Exams.Count(e => e.ID == id) > 0;
        }

        private ExamQuestion Convert(ExamQuestion question, Exam exam)
        {
            var list = question.Choices;
            if (question.Choices != null)
            {
                list = new List<Choice>();
                foreach (var choice in question.Choices)
                {
                    list.Add(new Choice()
                    {
                        IsAnswer = choice.IsAnswer,
                        Text = choice.Text,
                        RightAnswer = choice.RightAnswer
                    });
                }
            }
            return new ExamQuestion
            {
                Module = _dbContext.Modules.Single(m => m.ID == question.Module.ID),
                Duration = question.Duration,
                Exam = exam,
                QuestionType = question.QuestionType,
                Text = question.Text,
                Weight = question.Weight,
                Order = question.Order,
                ImageUrl = question.ImageUrl,
                Choices = list,
                Comment = question.Comment,
                Justification = question.Justification
            };
        }


        private List<ExamModel> OrderExams(List<ExamModel> exams, ExamOrderEnum orderBy, bool isReverse)
        {
            switch (orderBy)
            {
                case ExamOrderEnum.Title:
                    exams = isReverse ? exams.OrderBy(e => e.Title).ToList() : exams.OrderByDescending(e => e.Title).ToList();
                    break;
                case ExamOrderEnum.ExaminerName:
                    exams = isReverse ? exams.OrderBy(e => e.User.Name).ToList() : exams.OrderByDescending(e => e.User.Name).ToList();
                    break;
                case ExamOrderEnum.ExamDate:
                    exams = !isReverse ? exams.OrderBy(e => e.ExamDate).ToList() : exams.OrderByDescending(e => e.ExamDate).ToList();
                    break;
                case ExamOrderEnum.Duration:
                    exams = isReverse ? exams.OrderBy(e => e.Duration).ToList() : exams.OrderByDescending(e => e.Duration).ToList();
                    break;
                case ExamOrderEnum.CreatedDate:
                    exams = !isReverse ? exams.OrderBy(e => e.Created).ToList() : exams.OrderByDescending(e => e.Created).ToList();
                    break;
                case ExamOrderEnum.CreatedBy:
                    exams = isReverse ? exams.OrderBy(e => e.CreatedBy).ToList() : exams.OrderByDescending(e => e.CreatedBy).ToList();
                    break;
                case ExamOrderEnum.IsActive:
                    exams = isReverse ? exams.OrderBy(e => e.Activated).ToList() : exams.OrderByDescending(e => e.Activated).ToList();
                    break;
                case ExamOrderEnum.TotalScore:
                    exams = isReverse ? exams.OrderBy(e => e.TotalScore).ToList() : exams.OrderByDescending(e => e.TotalScore).ToList();
                    break;
                case ExamOrderEnum.Status:
                    exams = isReverse ? exams.OrderBy(e => e.Status).ToList() : exams.OrderByDescending(e => e.Status).ToList();
                    break;
                case ExamOrderEnum.FullRemainingTime:
                    exams = isReverse ? exams.OrderBy(e => e.TotalTimeUsed).ToList() : exams.OrderByDescending(e => e.TotalTimeUsed).ToList();
                    break;
            }
            return exams;
        }

        private List<ExamModel> FilterExams(List<ExamModel> exams, ExamQueryFilter examQueryFilter)
        {
            if (!examQueryFilter.TitleFilter.IsNullOrWhiteSpace())
                exams = exams.Where(e => e.Title.ToLower().Contains(examQueryFilter.TitleFilter.ToLower())).ToList();
            if (!examQueryFilter.ExamineeFilter.IsNullOrWhiteSpace())
                exams = exams.Where(e => e.User.Name.ToLower().Contains(examQueryFilter.ExamineeFilter.ToLower())).ToList();
            if (examQueryFilter.ExamDateFilter.HasValue)
                exams = exams.Where(e => e.ExamDate.Date == examQueryFilter.ExamDateFilter.Value.ToLocalTime().Date).ToList();
            if (examQueryFilter.DurationFilter.HasValue)
                exams = exams.Where(q => q.Duration.Ticks == examQueryFilter.DurationFilter.Value.Ticks - 621355932000000000).ToList();
            if (examQueryFilter.CreatedDateFilter.HasValue)
                exams = exams.Where(e => e.Created.Date == examQueryFilter.CreatedDateFilter.Value.ToLocalTime().Date).ToList();
            if (!examQueryFilter.CreatedByFilter.IsNullOrWhiteSpace())
                exams = exams.Where(e => e.CreatedBy.Name.ToLower().Contains(examQueryFilter.CreatedByFilter.ToLower())).ToList();
            if (examQueryFilter.IsActiveFilter.HasValue)
                exams = exams.Where(e => e.Activated == examQueryFilter.IsActiveFilter).ToList();
            if (examQueryFilter.TotalScoreFilter.HasValue)
                exams = exams.Where(e => e.TotalScore == examQueryFilter.TotalScoreFilter).ToList();
            if (!examQueryFilter.StatusFilter.IsNullOrWhiteSpace())
                exams = exams.Where(e => e.Status.ToLower().Contains(examQueryFilter.StatusFilter.ToLower())).ToList();
            if (examQueryFilter.FullRemainingTimeFilter.HasValue)
                exams = exams.Where(e => e.TotalTimeUsed.Value.Ticks == examQueryFilter.FullRemainingTimeFilter.Value.Ticks - 621355932000000000).ToList();
            return exams;
        }
    }
}