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.DTO.QuestionBank;
using TMSDAL.Query.PaperSection;
using TMSDAL.Query.QuestionBank;

namespace TMSDAL.CustomCode.QuestionBank
{
    public class QuestionBankDAL : IQuestionBankDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

        public QuestionBankDAL(IQueryExecutor queryExecutor, IValidation validation)
        {
            _QueryExecutor = queryExecutor;
            _Validation = validation;
        }


        // =====================================================
        // GET SINGLE
        // =====================================================
        public async Task<string> GetQuestionBank(int questionBankId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { QuestionBankId = questionBankId, TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QuerySingleAsync<QuestionBankDTO>(
                    loginDTO,
                    QuestionBankQB.GET_QUESTIONBANK,
                    parameters);
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception) { throw; }
        }


        // =====================================================
        // GET LIST
        // =====================================================
        public async Task<string> GetQuestionBankList(LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { TenantId = loginDTO.ClientId };
                var result = await _QueryExecutor.QueryAsync<QuestionBankDTO>(
                    loginDTO,
                    QuestionBankQB.GET_QUESTIONBANK_LIST,
                    parameters);
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception) { throw; }
        }


        // =====================================================
        // GET SELECTLIST — Criteria Based
        // =====================================================
        public async Task<string> GetSelectListQuestionBank(CriteriaDTO criteriaDTO, LoginDTO loginDTO)
        {
            var result = await _QueryExecutor.QueryWithCriteriaAsync<QuestionBankDTO>(
                    loginDTO,
                    QuestionBankQB.GET_SELECTLIST_QUESTIONBANK,
                    new { TenantId = loginDTO.ClientId },
                    criteriaDTO);
            return JsonConvert.SerializeObject(result);
        }


        // =====================================================
        // GET QUESTIONS FOR PAPER SECTION
        // Fetches PaperSection criteria then pulls matching questions
        // =====================================================
        public async Task<string> GetQuestionsForSection(int assessmentPaperId, int paperSectionId, LoginDTO loginDTO)
        {
            try
            {
                // Step 1: Get the section to read its filter criteria
                var sectionParams = new { PaperSectionId = paperSectionId };
                var section = await _QueryExecutor.QuerySingleAsync<PaperSectionDTO>(
                    loginDTO,
                    PaperSectionQB.GET_PAPERSECTION,
                    sectionParams);

                if (section == null)
                    return JsonConvert.SerializeObject(new List<QuestionBankItemDTO>());

                // Step 2: Query questions matching section filters
                var questionParams = new
                {
                    TenantId = loginDTO.ClientId,
                    QuestionTypeFilter = section.QuestionTypeFilter,
                    DifficultyFilter = section.DifficultyFilter,
                    IndustryTagFilter = section.IndustryTagFilter,
                    TopicIdFilter = section.TopicIdFilter
                };

                var questions = await _QueryExecutor.QueryAsync<QuestionBankItemDTO>(
                    loginDTO,
                    QuestionBankQB.GET_QUESTIONS_FOR_SECTION,
                    questionParams);

                return JsonConvert.SerializeObject(questions);
            }
            catch (Exception) { throw; }
        }


        // =====================================================
        // SAVE
        // =====================================================
        public async Task<int> SaveQuestionBank(QuestionBankDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    QuestionBankQB.SAVE_QUESTIONBANK,
                    dto);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.SaveErrorMessage);
                throw new Exception(error);
            }
        }


        // =====================================================
        // UPDATE
        // =====================================================
        public async Task<int> UpdateQuestionBank(QuestionBankDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    QuestionBankQB.UPDATE_QUESTIONBANK,
                    dto);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.UpdateErrorMessage);
                throw new Exception(error);
            }
        }


        // =====================================================
        // DELETE
        // =====================================================
        public async Task<string> DeleteQuestionBank(int questionBankId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { QuestionBankId = questionBankId, TenantId = loginDTO.ClientId };
                int rowsAffected = await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    QuestionBankQB.DELETE_QUESTIONBANK,
                    parameters);
                return rowsAffected > 0
                    ? SuccessResponse.DeleteSuccessMessage
                    : ErrorResponse.DeleteNotFoundMessage;
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, ErrorResponse.DeleteErrorMessage);
                throw new Exception(error);
            }
        }


        // =====================================================
        // INCREMENT USAGE COUNT
        // =====================================================
        public async Task<int> IncrementUsageCount(int questionBankId, LoginDTO loginDTO)
        {
            try
            {
                var parameters = new { QuestionBankId = questionBankId };
                return await _QueryExecutor.ExecuteAsync(
                    loginDTO,
                    QuestionBankQB.INCREMENT_USAGE_COUNT,
                    parameters);
            }
            catch (Exception) { throw; }
        }
    }
}