using System.Security.Claims;
using BMA.EHR.Recurit.Exam.Service.Core;
using BMA.EHR.Recurit.Exam.Service.Data;
using BMA.EHR.Recurit.Exam.Service.Models;
using Microsoft.EntityFrameworkCore;

namespace BMA.EHR.Recurit.Exam.Service.Services
{
    public class PeriodExamService
    {
        #region " Fields "

        private readonly ApplicationDbContext _context;
        private readonly IHttpContextAccessor _httpContextAccessor;

        #endregion

        #region " Constructor and Destructor "

        public PeriodExamService(ApplicationDbContext context,
                                     IHttpContextAccessor httpContextAccessor)
        {
            _context = context;
            _httpContextAccessor = httpContextAccessor;
        }

        #endregion

        #region " Properties "

        private string? UserId => _httpContextAccessor?.HttpContext?.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;

        private string? FullName => _httpContextAccessor?.HttpContext?.User?.FindFirst("name")?.Value;

        #endregion

        #region " Methods "

        public async Task<IEnumerable<PeriodExam>> GetsAsync(bool showAll = true)
        {
            if (showAll)
                return await _context.PeriodExams.AsQueryable()
                                .OrderBy(d => d.Name)
                                .ToListAsync();
            else
                return await _context.PeriodExams.AsQueryable()
                    .Where(p => p.IsActive)
                    .OrderBy(d => d.Name)
                    .ToListAsync();
        }

        public async Task<PeriodExam?> GetsExamAndCandidateAsync(string examId, bool showAll = true)
        {
            var periodExam = await _context.PeriodExams.AsQueryable()
                            .FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));

            if (periodExam == null)
                throw new Exception(GlobalMessages.ExamNotFound);

            return periodExam;
        }

        public async Task CreateAsync(PeriodExam inserted)
        {
            var periodExam = new PeriodExam
            {
                Name = inserted.Name,
                StartDate = inserted.StartDate,
                EndDate = inserted.EndDate,
                Round = inserted.Round,
                Fee = inserted.Fee,
                Year = inserted.Year,
                Detail = inserted.Detail,
                AnnounceDate = inserted.AnnounceDate,
                CreatedAt = DateTime.Now,
                CreatedUserId = UserId ?? "",
                LastUpdatedAt = DateTime.Now,
                LastUpdateUserId = UserId ?? "",
                CreatedFullName = FullName ?? "",
                LastUpdateFullName = FullName ?? "",
            };

            await _context.PeriodExams.AddAsync(periodExam);

            await _context.SaveChangesAsync();
        }

        public async Task UpdateAsync(string examId, PeriodExam updated)
        {
            var periodExam = await _context.PeriodExams.AsQueryable()
                            .FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));

            if (periodExam == null)
                throw new Exception(GlobalMessages.ExamNotFound);

            periodExam.Name = updated.Name;
            periodExam.StartDate = updated.StartDate;
            periodExam.EndDate = updated.EndDate;
            periodExam.Round = updated.Round;
            periodExam.Fee = updated.Fee;
            periodExam.Year = updated.Year;
            periodExam.Detail = updated.Detail;
            periodExam.AnnounceDate = updated.AnnounceDate;
            periodExam.IsActive = updated.IsActive;
            periodExam.LastUpdatedAt = DateTime.Now;
            periodExam.LastUpdateUserId = UserId ?? "";
            periodExam.LastUpdateFullName = FullName ?? "";

            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(string examId)
        {
            var periodExam = await _context.PeriodExams.AsQueryable()
                            .FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));

            if (periodExam == null)
                throw new Exception(GlobalMessages.ExamNotFound);

            _context.PeriodExams.Remove(periodExam);
            await _context.SaveChangesAsync();
        }

        public async Task<IEnumerable<Candidate?>> GetsCandidateByStatusAsync(string examId, string status)
        {
            var periodExam = await _context.PeriodExams.AsQueryable()
                            .FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));

            if (periodExam == null)
                throw new Exception(GlobalMessages.ExamNotFound);

            if (status == "all")
            {
                return await _context.Candidates.AsQueryable()
                                .Where(x => x.PeriodExam == periodExam && x.Status != "register" && x.Status != "rejectRegister")
                                .ToListAsync();
            }
            else
            {
                return await _context.Candidates.AsQueryable()
                                .Where(x => x.PeriodExam == periodExam && x.Status == status)
                                .ToListAsync();
            }
        }

        public async Task<CandidateInformationResponseItem?> GetsAsyncInformation(string candidateId)
        {
            return await _context.Candidates.AsQueryable()
                            .Where(x => x.Id == Guid.Parse(candidateId))
                            .Select(x => new CandidateInformationResponseItem
                            {
                                Prefix = x.Prefix,
                                PrefixId = x.Prefix != null ? x.Prefix.Id.ToString() : null,
                                FirstName = x.FirstName,
                                LastName = x.LastName,
                                Nationality = x.Nationality,
                                DateOfBirth = x.DateOfBirth,
                                Relationship = x.Relationship,
                                RelationshipId = x.Relationship != null ? x.Relationship.Id.ToString() : null,
                                CitizenProvince = x.CitizenProvince,
                                CitizenProvinceId = x.CitizenProvince != null ? x.CitizenProvince.Id.ToString() : null,
                                CitizenDistrict = x.CitizenDistrict,
                                CitizenDistrictId = x.CitizenDistrict != null ? x.CitizenDistrict.Id.ToString() : null,
                                CitizenDate = x.CitizenDate,
                                Email = x.Email,
                                CitizenId = x.CitizenId,
                                Telephone = x.Telephone,
                                MobilePhone = x.MobilePhone,
                                Knowledge = x.Knowledge,
                            })
                            .FirstOrDefaultAsync();
        }
        #endregion
    }
}