using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;
using TMSDAL.DTO.Assessment;
using TMSDAL.Query.Assessment;
using TMSDAL.Query.AssessmentPaper;
using TMSDAL.Query.AttemptResponse;
using TMSDAL.Query.TrainingNeed;

namespace TMSDAL.CustomCode.Assessment
{
    public class AssessmentDAL : IAssessmentDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

        public AssessmentDAL(IQueryExecutor queryExecutor, IValidation validation)
        {
            _QueryExecutor = queryExecutor;
            _Validation = validation;
        }
        public async Task<string> GetAssessmentList(LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QueryAsync<SessionAssessmentDTO>(loginDTO, AssessmentQB.GET_ASSESSMENT_LIST, parameters);
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception) { throw; }
        }

        public async Task<SessionAssessmentDTO?> GetAssessment(int assessmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, TenantId = loginDTO.ClientId };
                return await _QueryExecutor.QuerySingleAsync<SessionAssessmentDTO>(loginDTO, AssessmentQB.GET_ASSESSMENT, parameters);
            }
            catch (Exception) { throw; }
        }

        public async Task<List<AssessmentQuestionDTO>> GetSimpleQuestions(int assessmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QueryAsync<AssessmentQuestionDTO>(loginDTO, AssessmentQB.GET_SIMPLE_QUESTIONS, parameters);
                return result.ToList();
            }
            catch (Exception) { throw; }
        }

        public async Task<string> GetSelectList(CriteriaDTO criteriaDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            var result = await _QueryExecutor.QueryWithCriteriaAsync<dynamic>(
                loginDTO,
                AssessmentQB.GET_SELECT_LIST,
                new { TenantId = loginDTO.ClientId },
                criteriaDTO,
                ct);
            return JsonConvert.SerializeObject(result);
        }

        public async Task<AssessmentPaperDTO?> GetAssessmentPaper(int assessmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, TenantId = loginDTO.ClientId };
                return await _QueryExecutor.QuerySingleAsync<AssessmentPaperDTO>(loginDTO, AssessmentQB.GET_ASSESSMENT_PAPER, parameters);
            }
            catch (Exception) { throw; }
        }

        public async Task<List<PaperSectionDTO>> GetPaperSections(int paperId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { PaperId = paperId, TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QueryAsync<PaperSectionDTO>(loginDTO, AssessmentQB.GET_PAPER_SECTIONS, parameters);
                return result.ToList();
            }
            catch (Exception) { throw; }
        }

        public async Task<List<QuestionBankItemDTO>> GetSectionQuestions(int sectionId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { SectionId = sectionId, TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QueryAsync<QuestionBankItemDTO>(loginDTO, AssessmentQB.GET_SECTION_QUESTIONS, parameters);
                return result.ToList();
            }
            catch (Exception) { throw; }
        }

        public async Task<int> GetAttemptCount(int assessmentId, int enrollmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, EnrollmentId = enrollmentId, TenantId = loginDTO.ClientId };
                return await _QueryExecutor.ExecuteScalarAsync<int>(loginDTO, AssessmentQB.GET_ATTEMPT_COUNT, parameters);
            }
            catch (Exception) { throw; }
        }

        public async Task<int> SaveAssessment(SessionAssessmentDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.SAVE_ASSESSMENT, dto);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task<int> UpdateAssessment(SessionAssessmentDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.UPDATE_ASSESSMENT, dto);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task<int> DeleteAssessment(int assessmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, TenantId = loginDTO.ClientId };
                return await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.DELETE_ASSESSMENT, parameters);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.DeleteErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task SaveQuestion(AssessmentQuestionDTO dto, LoginDTO loginDTO)
        {
            try
            {
                await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.SAVE_QUESTION, dto);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage);
                throw new Exception(error);
            }
        }

        public async Task DeleteAttemptResponsesByAssessment(int assessmentId, LoginDTO loginDTO)
        {
            await _QueryExecutor.ExecuteAsync(loginDTO,
                AttemptResponseQB.DELETE_ATTEMPTRESPONSES_BY_ASSESSMENT,
                new { AssessmentId = assessmentId });
        }

        public async Task DeleteAttemptsByAssessment(int assessmentId, LoginDTO loginDTO)
        {
            await _QueryExecutor.ExecuteAsync(loginDTO,
                AttemptResponseQB.DELETE_ATTEMPTS_BY_ASSESSMENT,
                new { AssessmentId = assessmentId });
        }

        public async Task DeleteQuestions(int assessmentId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { AssessmentId = assessmentId, TenantId = loginDTO.ClientId };
                await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.DELETE_QUESTIONS, parameters);
            }
            catch (Exception) { throw; }
        }

        //public async Task SaveAttemptWithResponses(AssessmentAttemptDTO attempt, LoginDTO loginDTO)
        //{
        //    var tx = await _QueryExecutor.BeginTransactionAsync(loginDTO);
        //    try
        //    {
        //        await _QueryExecutor.ExecuteAsync(loginDTO, AssessmentQB.SAVE_ATTEMPT, attempt, tx);

        //        if (attempt.Responses != null && attempt.Responses.Count > 0)
        //            await _QueryExecutor.BulkInsertAsync(loginDTO, AssessmentQB.BULK_INSERT_RESPONSES, attempt.Responses);

        //        await _QueryExecutor.CommitAsync(tx);
        //    }
        //    catch
        //    {
        //        await _QueryExecutor.RollbackAsync(tx);
        //        throw;
        //    }
        //}
    }
}