using Edu.Model.ViewModel.Course;
using Edu.Repository.Course;
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Edu.Model.ViewModel.Question;
using Edu.Repository.Exam;
using Edu.Model.ViewModel.Exam;
using VT.FW.DB;
using Edu.Repository.Question;
using Edu.Module.Question;
using Edu.Common.Plugin;
using Edu.Common.Enum.Question;

namespace Edu.Module.Exam
{
    /// <summary>
    /// 课程预习测试处理类
    /// </summary>
    public class CourseExamModule
    {
        /// <summary>
        /// 课程章节单词处理类对象
        /// </summary>
        private readonly RB_Course_WordsRepository course_WordsRepository = new RB_Course_WordsRepository();

        /// <summary>
        /// 学员单词学习仓储层对象
        /// </summary>
        private readonly RB_StuWords_PrepRepository stuWords_PrepRepository = new RB_StuWords_PrepRepository();

        /// <summary>
        /// 学员单词复习仓储层对象
        /// </summary>
        private readonly RB_StuWords_ReviewRepository stuWords_ReviewRepository = new RB_StuWords_ReviewRepository();

        /// <summary>
        /// 学员单词测试仓储层对象
        /// </summary>
        private readonly RB_StuWords_ExamRepository stuWords_ExamRepository = new RB_StuWords_ExamRepository();

        /// <summary>
        /// 学员单词测试详情仓储层对象
        /// </summary>
        private readonly RB_StuWords_ExamDetailRepository stuWords_ExamDetailRepository = new RB_StuWords_ExamDetailRepository();

        /// <summary>
        /// 问题仓储层对象
        /// </summary>
        private readonly RB_QuestionRepository questionRepository = new RB_QuestionRepository();

        /// <summary>
        /// 问题解析处理类
        /// </summary>
        private readonly AnalysisQuestionTypeModule analysisQuestion = new AnalysisQuestionTypeModule();

        /// <summary>
        /// 题库仓储层对象
        /// </summary>
        private readonly RB_Question_BankRepository question_BankRepository = new RB_Question_BankRepository();

        /// <summary>
        /// 学员练习仓储层对象
        /// </summary>
        private readonly RB_Student_PracticeRepository student_PracticeRepository = new RB_Student_PracticeRepository();

        /// <summary>
        /// 学员练习考试仓储层对象
        /// </summary>
        private readonly RB_Student_ExamRepository student_ExamRepository = new RB_Student_ExamRepository();

        /// <summary>
        /// 学员练习考试详情仓储层对象
        /// </summary>
        private readonly RB_Student_ExamDetailsRepository student_ExamDetailsRepository = new RB_Student_ExamDetailsRepository();

        #region 单词测试和复习
        /// <summary>
        /// 生成课程复习和预习单词
        /// </summary>
        /// <param name="CourseId">课程编号</param>
        /// <param name="ChapterId">当前章节编号</param>
        /// <param name="NextChapterId">下一章节编号</param>
        /// <returns></returns>
        public object CreateCourseExamModule(int CourseId, int ChapterId, int NextChapterId)
        {
            object result = new object();
            var list = course_WordsRepository.GetCourseWordsListRepository(new RB_Course_Words_Extend()
            {
                CourseId = CourseId,
                QChapterIds = ChapterId + "," + NextChapterId
            });

            var totalList = course_WordsRepository.GetCourseWordsListRepository(new RB_Course_Words_Extend()
            {
                CourseId = CourseId,
                LessThanOrEqualChapterId = ChapterId,
            })?.OrderBy(qitem => Guid.NewGuid())?.ToList();
            var reviewList = list?.Where(qitem => qitem.ChapterId == ChapterId)?.OrderBy(qitem => Guid.NewGuid())?.ToList();
            var prepList = list?.Where(qitem => qitem.ChapterId == NextChapterId)?.OrderBy(qitem => Guid.NewGuid())?.ToList();
            List<object> reviewGroupList = new List<object>();
            List<object> prepGroupList = new List<object>();

            if (reviewList != null && reviewList.Count > 0)
            {
                for (var i = 0; i < reviewList.Count; i++)
                {
                    var titleRandomNum = Common.ConvertHelper.CreateRandomNum();
                    var tempWords = reviewList[i];
                    var count = totalList?.Where(qitem => qitem.Id != tempWords.Id)?.Count() ?? 0;
                    //reviewGroupList.Add(CreateSingleModule(tempWords,totalList));
                    //选择题
                    if (titleRandomNum % 2 == 0)
                    {
                        if (count > 2)
                        {
                            reviewGroupList.Add(CreateSingleModule(tempWords, totalList));
                        }
                        else
                        {
                            if (!string.IsNullOrEmpty(tempWords.ChineseMean) || !string.IsNullOrEmpty(tempWords.WordWrite))
                            {
                                reviewGroupList.Add(CreateFillInModule(tempWords));
                            }
                        }
                    }
                    //填空题
                    else
                    {
                        if (!string.IsNullOrEmpty(tempWords.ChineseMean) || !string.IsNullOrEmpty(tempWords.WordWrite))
                        {
                            reviewGroupList.Add(CreateFillInModule(tempWords));
                        }
                    }
                }
            }

            if (prepList != null && prepList.Count > 0)
            {

            }
            result = new
            {
                reviewGroupList,
                prepGroupList,
            };
            return result;
        }

        /// <summary>
        /// 创建填空题
        /// </summary>
        public object CreateFillInModule(RB_Course_Words_Extend item)
        {
            string title = "我是问题";
            List<fillInItem> fillInItems = new List<fillInItem>();
            int randNum = Common.ConvertHelper.CreateRandomNum();
            //根据日语书写填写单词
            if (randNum % 2 == 0)
            {
                if (!string.IsNullOrEmpty(item.WordWrite))
                {
                    title = string.Format("根据日语书写【{0}】,填写单词.", item.WordWrite);
                }
                else
                {

                    title = string.Format("根据中文意思【{0}】,填写单词.", item.ChineseMean);
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(item.ChineseMean))
                {

                    title = string.Format("根据中文意思【{0}】,填写单词.", item.ChineseMean);
                }
                else
                {
                    title = string.Format("根据日语书写【{0}】,填写单词.", item.WordWrite);
                }
            }

            var fillinObj = new
            {
                QuestionTypeName = "填空题",
                QuestionTypeId = 3,
                QuestionTypeKey = "fill-in",
                QuestionContent = "",
                Answer = item.WordContent,
                Title = title,
                item.WordType,
                item.WordContent,
                item.WordTone,
                item.WordWrite,
                item.ChineseMean,
                item.FileUrl,
                IsTrue = 0,
            };
            return fillinObj;
        }

        /// <summary>
        /// 创建单选题
        /// </summary>
        /// <returns></returns>
        public object CreateSingleModule(RB_Course_Words_Extend item, List<RB_Course_Words_Extend> totalList)
        {
            string title = "我是问题";
            int randNum = Common.ConvertHelper.CreateRandomNum();
            List<optionItem> options = new List<optionItem>();
            var tempList = totalList?.OrderBy(qitem => Guid.NewGuid())?.ToList();
            switch (randNum)
            {
                //根据单词选择中文意思
                case 0:
                    title = CreateDefaultQuestion(item, tempList, options);
                    break;
                //根据中文意思选择单词
                case 1:
                    title = string.Format("请选择【{0}】所对应的单词.", item.ChineseMean);
                    options.Add(new optionItem()
                    {
                        Content = item.WordContent,
                        IsAnswer = true,
                        Name = "",
                        ShowName = ""
                    });
                    for (var i = 0; i < 3; i++)
                    {
                        var cItem = tempList[i];
                        string Content = cItem.WordContent;
                        if (string.IsNullOrEmpty(Content))
                        {
                            var cTempList = totalList?.Where(qitem => qitem.Id != cItem.Id && qitem.Id != item.Id && !string.IsNullOrEmpty(qitem.WordContent))?.OrderBy(qitem => Guid.NewGuid());
                            Content = cTempList?.FirstOrDefault()?.WordContent ?? "";
                        }
                        if (options.Where(qitem => qitem.Content.Equals(Content)).Count() > 0)
                        {
                            Content += GetRandWords(i);
                        }
                        options.Add(new optionItem()
                        {
                            Content = Content,
                            IsAnswer = false,
                            Name = "",
                            ShowName = "",
                        });
                    }
                    break;
                //根据日语书写选择中文意思
                case 2:
                    if (!string.IsNullOrEmpty(item.WordWrite) && !string.IsNullOrEmpty(item.WordContent))
                    {
                        title = string.Format("请选择【{0}】所对应的单词.", item.WordWrite);
                        options.Add(new optionItem()
                        {
                            Content = item.WordContent,
                            IsAnswer = true,
                            Name = "",
                            ShowName = ""
                        });
                        for (var i = 0; i < 3; i++)
                        {
                            var cItem = tempList[i];
                            string Content = cItem.WordContent;
                            if (string.IsNullOrEmpty(Content))
                            {
                                Content = (totalList?.OrderBy(qitem => Guid.NewGuid())?.FirstOrDefault(qitem => qitem.Id != cItem.Id && qitem.Id != item.Id && !string.IsNullOrEmpty(qitem.WordContent))?.WordContent ?? "");
                            }
                            if (options.Where(qitem => qitem.Content.Equals(Content)).Count() > 0)
                            {
                                Content += GetRandWords(i);
                            }
                            options.Add(new optionItem()
                            {
                                Content = Content,
                                IsAnswer = false,
                                Name = "",
                                ShowName = "",
                            });
                        }
                    }
                    else
                    {
                        title = CreateDefaultQuestion(item, totalList, options);
                    }
                    break;
                //根据中文意思选日语书写
                case 3:
                    if (!string.IsNullOrEmpty(item.WordWrite) && !string.IsNullOrEmpty(item.ChineseMean))
                    {
                        title = string.Format("请选择【{0}】所对应日语书写.", item.ChineseMean);
                        options.Add(new optionItem()
                        {
                            Content = item.WordWrite,
                            IsAnswer = true,
                            Name = "",
                            ShowName = ""
                        });
                        for (var i = 0; i < 3; i++)
                        {
                            var cItem = tempList[i];
                            string Content = cItem.WordWrite;
                            if (string.IsNullOrEmpty(Content))
                            {
                                Content = totalList
                                    ?.OrderBy(qitem => Guid.NewGuid())
                                    ?.FirstOrDefault(qitem => qitem.Id != cItem.Id && qitem.Id != item.Id && !string.IsNullOrEmpty(qitem.WordWrite))
                                    ?.WordWrite ?? "";
                            }
                            if (options.Where(qitem => qitem.Content.Equals(Content)).Count() > 0)
                            {
                                Content += GetRandWords(i);
                            }
                            options.Add(new optionItem()
                            {
                                Content = Content,
                                IsAnswer = false,
                                Name = "",
                                ShowName = "",
                            });
                        }
                    }
                    else
                    {
                        title = CreateDefaultQuestion(item, totalList, options);
                    }
                    break;
            }

            options = options?.OrderBy(qitem => Guid.NewGuid())?.ToList();
            string Answer = "";
            for (var j = 1; j <= options.Count; j++)
            {
                options[j - 1].Name = Common.Plugin.StringHelper.ReturnEnChar(j);
                options[j - 1].ShowName = Common.Plugin.StringHelper.ReturnEnChar(j);
                if (options[j - 1].IsAnswer)
                {
                    Answer = options[j - 1].Name;
                    options[j - 1].IsAnswer = false;
                }
            }
            var singleObj = new
            {
                QuestionTypeName = "单选题",
                QuestionTypeId = 1,
                QuestionTypeKey = "single",
                QuestionContent = options,
                Answer,
                Title = title,
                item.WordType,
                item.WordContent,
                item.WordTone,
                item.WordWrite,
                item.ChineseMean,
                item.FileUrl,
                IsTrue = 0,
            };
            return singleObj;
        }

        /// <summary>
        /// 获取随机假名
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public string GetRandWords(int index)
        {
            var array = new string[4] { "ん", "ー", "ム", "い" };
            return array[index];
        }


        /// <summary>
        /// 生成默认的选择题
        /// </summary>
        /// <param name="item"></param>
        /// <param name="totalList"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public string CreateDefaultQuestion(RB_Course_Words_Extend item, List<RB_Course_Words_Extend> totalList, List<optionItem> options)
        {
            string title = string.Format("请选择【{0}】单词的正确中文意思.", item.WordContent);
            options.Add(new optionItem()
            {
                Content = item.ChineseMean,
                IsAnswer = true,
                Name = "",
                ShowName = ""
            });
            for (var i = 0; i < 3; i++)
            {
                var cItem = totalList[i];
                string Content = cItem.ChineseMean;
                if (string.IsNullOrEmpty(Content))
                {
                    Content = totalList
                        ?.OrderBy(qitem => Guid.NewGuid())
                        ?.FirstOrDefault(qitem => qitem.Id != cItem.Id && qitem.Id != item.Id && !string.IsNullOrEmpty(qitem.ChineseMean))
                        ?.ChineseMean ?? "";
                }
                if (options.Where(qitem => qitem.Content.Equals(Content)).Count() > 0)
                {
                    Content += GetRandWords(i);
                }
                options.Add(new optionItem()
                {
                    Content = Content,
                    IsAnswer = false,
                    Name = "",
                    ShowName = "",
                });
            }
            return title;
        }

        /// <summary>
        /// 单词学习或复习
        /// </summary>
        /// <param name="CourseId">课程编号</param>
        /// <param name="ChapterId">当前章节编号</param>
        /// <param name="ReviewChapterId">复习章节编号</param>
        /// <returns></returns>
        public object GetStudyCourseWords(int CourseId, int ChapterId, int ReviewChapterId, int Stu_Account_Id)
        {
            List<object> list = new List<object>();
            List<object> reviewList = new List<object>();
            var dataList = course_WordsRepository.GetCourseWordsListRepository(new RB_Course_Words_Extend()
            {
                CourseId = CourseId,
                QChapterIds = ChapterId + "," + ReviewChapterId
            });
            if (dataList != null && dataList.Count > 0)
            {
                foreach (var item in dataList.Where(qitem => qitem.ChapterId == ChapterId))
                {
                    list.Add(new
                    {
                        item.Id,
                        item.CourseId,
                        item.ChapterId,
                        item.WordType,
                        item.WordContent,
                        item.WordTone,
                        item.WordWrite,
                        item.ChineseMean,
                        item.FileUrl
                    });
                }

                foreach (var item in dataList.Where(qitem => qitem.ChapterId == ReviewChapterId))
                {
                    reviewList.Add(new
                    {
                        item.Id,
                        item.CourseId,
                        item.ChapterId,
                        item.WordType,
                        item.WordContent,
                        item.WordTone,
                        item.WordWrite,
                        item.ChineseMean,
                        item.FileUrl
                    });
                }
            }

            var prepModel = GetStuWordsPrepListModule(new RB_StuWords_Prep_Extend()
            {
                Stu_Account_Id = Stu_Account_Id,
                CourseId = CourseId,
                ChapterId = ChapterId,
            })?.FirstOrDefault();
            return new
            {
                StudyList = list,
                ReviewList = reviewList,
                StartIndex = prepModel?.StudyNum ?? 0
            };
        }


        /// <summary>
        /// 获取单词预习列表
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<RB_StuWords_Prep_Extend> GetStuWordsPrepListModule(RB_StuWords_Prep_Extend query)
        {
            var list = stuWords_PrepRepository.GetStuWordsPrepListRepository(query);
            return list;
        }

        /// <summary>
        /// 新增修改学员单词学习
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetStuWordsPrepModule(RB_StuWords_Prep_Extend model)
        {
            bool flag = false;
            var wordsList = course_WordsRepository.GetCourseWordsListRepository(new RB_Course_Words_Extend()
            {
                CourseId = model.CourseId,
                QChapterIds = model.ChapterId + "," + model.ReviewCourseChapterId
            });
            //当前章节单词总数
            var currentChapterCount = wordsList?.Where(qitem => qitem.ChapterId == model.ChapterId)?.Count() ?? 0;
            var oldModel = GetStuWordsPrepListModule(new RB_StuWords_Prep_Extend()
            {
                Stu_Account_Id = model.Stu_Account_Id,
                CourseId = model.CourseId,
                ChapterId = model.ChapterId,
                Group_Id = model.Group_Id
            })?.FirstOrDefault();
            model.Id = oldModel?.Id ?? 0;
            model.TotalNum = oldModel?.TotalNum ?? (wordsList?.Count ?? 0);
            if (model.Id > 0)
            {
                Dictionary<string, object> fileds = new Dictionary<string, object>();
                //预习
                if (model.StudyType == 1)
                {
                    fileds.Add(nameof(RB_StuWords_Prep_Extend.PrepNum), model.PrepNum);
                    model.StudyNum = model.PrepNum;
                }
                //复习
                else
                {
                    fileds.Add(nameof(RB_StuWords_Prep_Extend.ReviewNum), model.ReviewNum);
                    model.StudyNum = oldModel.PrepNum + model.ReviewNum;
                }
                fileds.Add(nameof(RB_StuWords_Prep_Extend.StudyNum), model.StudyNum);
                model.Score = GetScoreModule(model.PrepNum, currentChapterCount);
                fileds.Add(nameof(RB_StuWords_Prep_Extend.Score), model.Score);
                if (model.StudyNum == (wordsList?.Count ?? 0))
                {
                    model.EndTime = DateTime.Now;
                    fileds.Add(nameof(RB_StuWords_Prep_Extend.EndTime), DateTime.Now);
                }
                flag = stuWords_PrepRepository.Update(fileds, new WhereHelper(nameof(RB_StuWords_Prep_Extend.Id), model.Id));
            }
            else
            {
                model.PrepNum = 1;
                model.StudyNum = 1;
                model.Score = GetScoreModule(model.PrepNum, currentChapterCount);
                model.StartTime = DateTime.Now;
                var newId = stuWords_PrepRepository.Insert(model);
                model.Id = newId;
                flag = newId > 0;
            }
            return flag;
        }

        /// <summary>
        /// 获取学习分数
        /// </summary>
        /// <param name="StartNum"></param>
        /// <param name="TotalNum"></param>
        /// <returns></returns>
        public int GetScoreModule(int StartNum, int TotalNum)
        {
            int score = 0;
            if (TotalNum > 0)
            {
                var progress = Convert.ToDecimal(StartNum) / Convert.ToDecimal(TotalNum) * 100;
                if (progress > 0 && progress <= 33)
                {
                    score = 1;
                }
                if (progress > 34 && progress < 66)
                {
                    score = 2;
                }
                if (progress >= 66)
                {
                    score = 3;
                }
            }
            else
            {
                score = 1;
            }
            return score;
        }

        /// <summary>
        /// 新增修改学员复习
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetStuWordsReviewModule(RB_StuWords_Review_Extend model)
        {
            bool flag = false;
            var wordsList = course_WordsRepository.GetCourseWordsListRepository(new RB_Course_Words_Extend()
            {
                CourseId = model.CourseId,
                ChapterId = model.ChapterId
            });
            var oldModel = stuWords_ReviewRepository.GetStuWordsReviewListRepository(new RB_StuWords_Review_Extend()
            {
                Stu_Account_Id = model.Stu_Account_Id,
                CourseId = model.CourseId,
                ChapterId = model.ChapterId,
                Group_Id = model.Group_Id
            })?.FirstOrDefault();
            model.Id = oldModel?.Id ?? 0;
            if (model.Id > 0)
            {
                Dictionary<string, object> fileds = new Dictionary<string, object>()
                {
                    {nameof(RB_StuWords_Review_Extend.ReviewNum),model.ReviewNum },
                };
                model.TotalNum = oldModel?.TotalNum ?? (wordsList?.Count ?? 0);
                if (model.ReviewNum == (wordsList?.Count ?? 0))
                {
                    model.EndTime = DateTime.Now;
                    fileds.Add(nameof(RB_StuWords_Review_Extend.EndTime), DateTime.Now);
                }
                flag = stuWords_ReviewRepository.Update(fileds, new WhereHelper(nameof(RB_StuWords_Review_Extend.Id), model.Id));
            }
            else
            {
                model.ReviewNum = 1;
                model.TotalNum = wordsList?.Count() ?? 0;
                model.StartTime = DateTime.Now;
                var newId = stuWords_ReviewRepository.Insert(model);
                model.Id = newId;
                flag = newId > 0;
            }
            return flag;
        }

        /// <summary>
        /// 提交单词测试
        /// </summary>
        /// <returns></returns>
        public bool SubmitStuWordsExamModule(RB_StuWords_Exam_Extend model)
        {
            bool flag = false;
            int rightCount = model?.ExamDetailList?.Where(qitem => qitem.IsRight == 1)?.Count() ?? 0;
            int totalCount = model?.ExamDetailList?.Count ?? 0;
            model.Score = GetScoreModule(rightCount, totalCount);
            var newId = stuWords_ExamRepository.Insert(model);
            model.Id = newId;
            flag = newId > 0;
            if (flag && model.ExamDetailList != null && model.ExamDetailList.Count > 0)
            {
                foreach (var item in model.ExamDetailList)
                {
                    item.DetailId = 0;
                    item.ExamId = newId;
                    stuWords_ExamDetailRepository.Insert(item);
                }
            }
            return flag;
        }

        /// <summary>
        /// 获取学员单词考试列表
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<RB_StuWords_Exam_Extend> GetStuWordsExamListModule(RB_StuWords_Exam_Extend query)
        {
            var list = stuWords_ExamRepository.GetStuWordsExamListRepository(query);
            return list;
        }

        #endregion

        #region 题库相关测试

        /// <summary>
        /// 题型数量统计
        /// </summary>
        /// <param name="query"></param>
        public object GetAppQuestionStaticModule(RB_Question_ViewModel query, int StudentId)
        {
            object obj = new object();
            int readingTotalCount = 0;
            int readingFinishCount = 0;
            int readingStartId = 0;
            int readingTimes = 1;
            int listeningTotalCount = 0;
            int listeningFinishCount = 0;
            int listeningStartId = 0;
            int listeningTimes = 1;
            int grammarTotalCount = 0;
            int grammarFinishCount = 0;
            int grammarStartId = 0;
            int grammarTimes = 1;
            int wordsTotalCount = 0;
            int wordsFinishCount = 0;
            int wordsStartId = 0;
            int wordsTimes = 1;
            var sQuery = new RB_Student_Practice_Extend()
            {
                StudentId = StudentId,
            };
            sQuery.LevelType = query?.BankType ?? 0;

            //问题列表
            var questionList = questionRepository.GetQuestionCategoryListRepository(query);
            if (questionList != null && questionList.Count > 0)
            {
                readingTotalCount = questionList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ReadingChoose)?.Sum(qitem => qitem.QuestionCount) ?? 0;
                listeningTotalCount = questionList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.Listening)?.Sum(qitem => qitem.QuestionCount) ?? 0;
                grammarTotalCount = questionList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseGrammarUse)?.Sum(qitem => qitem.QuestionCount) ?? 0;
                wordsTotalCount = questionList?.Where(qitem =>
                   qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWord
                || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseMean
                || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWordUse
                )?.Sum(qitem => qitem.QuestionCount) ?? 0;
            }
            //学员完成情况
            var finishList = student_PracticeRepository.GetStudentPracticeListRepository(sQuery);

            //阅读题练习完成列表
            var tempReadingList = finishList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ReadingChoose)?.ToList();
            //听力题练习完成列表
            var tempListeningList = finishList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.Listening)?.ToList();
            //语法题练习完成列表
            var tempGrammarList = finishList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseGrammarUse)?.ToList();
            //单词题练习完成列表
            var tempWordsList = finishList?.Where(qitem =>
                  qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWord
               || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseMean
               || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWordUse
               )?.ToList();

            if (tempReadingList != null && tempReadingList.Count > 0)
            {
                readingTimes = tempReadingList?.Max(qitem => qitem.Times) ?? 1;
                readingFinishCount = tempReadingList?.Where(qitem => qitem.Times == readingTimes)?.Count() ?? 0;
                if (tempReadingList?.Where(qitem => qitem.Times == readingTimes).Count() > 0)
                {
                    readingStartId = tempReadingList?.Where(qitem => qitem.Times == readingTimes)?.Max(qitem => qitem.QuestionId) ?? 0;
                }
                if (readingFinishCount == readingTotalCount)
                {
                    readingStartId = 0;
                    readingTimes = readingTimes + 1;
                }
            }
            if (tempListeningList != null && tempListeningList.Count > 0)
            {
                listeningTimes = tempListeningList?.Max(qitem => qitem.Times) ?? 1;
                listeningFinishCount = tempListeningList ?.Where(qitem => qitem.Times == listeningTimes)?.Count() ?? 0;
                if (tempListeningList?.Where(qitem => qitem.Times == listeningTimes)?.Count() > 0)
                {
                    listeningStartId = tempListeningList?.Where(qitem => qitem.Times == listeningTimes)?.Max(qitem => qitem.QuestionId) ?? 0;
                }
                if (listeningFinishCount == listeningTotalCount)
                {
                    listeningStartId = 0;
                    listeningTimes = listeningTimes + 1;
                }
            }

            if (tempGrammarList != null && tempGrammarList.Count > 0)
            {
                grammarTimes= tempGrammarList?.Max(qitem => qitem.Times) ?? 1;
                grammarFinishCount = tempGrammarList?.Where(qitem => qitem.Times == grammarTimes).Count() ?? 0;
                if (tempGrammarList?.Where(qitem => qitem.Times == grammarTimes).Count() > 0)
                {
                    grammarStartId = tempGrammarList?.Where(qitem => qitem.Times == grammarTimes)?.Max(qitem => qitem.QuestionId) ?? 0;
                }
                if (grammarFinishCount == grammarTotalCount)
                {
                    grammarStartId = 0;
                    grammarTimes = grammarTimes + 1;
                }
            }

            if (tempWordsList != null && tempWordsList.Count > 0)
            {
                wordsTimes = tempWordsList?.Max(qitem => qitem.Times) ?? 1;
                wordsFinishCount = tempWordsList?.Where(qitem=>qitem.Times== wordsTimes)?.Count() ?? 0;
                if (tempWordsList?.Where(qitem => qitem.Times == wordsTimes)?.Count() > 0)
                {
                    wordsStartId = tempWordsList?.Where(qitem => qitem.Times == wordsTimes)?.Max(qitem => qitem.QuestionId) ?? 0;
                }
                if (wordsFinishCount == wordsTotalCount )
                {
                    wordsStartId = 0;
                    wordsTimes = wordsTimes + 1;
                }
            }
            obj = new
            {
                readingFinishCount,
                readingTotalCount,
                readingStartId,
                readingTimes,
                listeningFinishCount,
                listeningTotalCount,
                listeningStartId,
                listeningTimes,
                grammarTotalCount,
                grammarFinishCount,
                grammarStartId,
                grammarTimes,
                wordsTotalCount,
                wordsFinishCount,
                wordsStartId,
                wordsTimes,
            };
            return obj;
        }

        /// <summary>
        /// 根据题目分类获取题目分页列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowsCount"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<object> GetAppQuestionCategoryListModule(int pageIndex, int pageSize, out long rowsCount, RB_Question_ViewModel query)
        {
            List<object> list = new List<object>();
            query.OrderByType = 1;
            var dataList = questionRepository.GetQuestionPageListRepository(pageIndex, pageSize, out rowsCount, query);
            if (dataList != null && dataList.Count > 0)
            {
                foreach (var item in dataList)
                {
                    var QuestionContentObj = analysisQuestion.ParsingQuestion(item.QuestionTypeKey, item.QuestionContent);
                    List<object> quesAnswerList = new List<object>();

                    if (item.QuestionTypeKey == "listening" || item.QuestionTypeKey == "reading-comprehensio")
                    {
                        try
                        {
                            var listenList = JsonHelper.DeserializeObject<List<SubAnswerItem>>(item.Answer);
                            if (listenList != null && listenList.Count > 0)
                            {
                                foreach (var subItem in listenList)
                                {
                                    quesAnswerList.Add(subItem.SubAnswer);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_listening:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }
                    if (item.QuestionTypeKey != "listening" && item.QuestionTypeKey != "reading-comprehensio" && item.Answer!=null && !string.IsNullOrEmpty(item.Answer.ToString()))
                    {
                        try
                        {
                            var tempList = Common.ConvertHelper.StringToFileList(item.Answer);
                            if (tempList != null && tempList.Count > 0)
                            {
                                foreach (var tItem in tempList)
                                {
                                    quesAnswerList.Add(tItem);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_Answer:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }

                    var obj = new
                    {
                        item.QuestionId,
                        item.QuestionTypeId,
                        item.QuestionTypeKey,
                        item.Category,
                        LevelType = item.BankType,
                        item.Title,
                        item.DifficultyType,
                        item.DifficultyTypeStr,
                        item.AnswerParse,
                        item.Answer,
                        QuestionContentObj,
                        QuestionAnswerList = quesAnswerList,
                        StudentAnswer = new List<string>(),
                    };
                    list.Add(obj);
                }
            }
            return list;
        }

        /// <summary>
        /// 获取题库分类统计参与人数
        /// </summary>
        /// <returns></returns>
        public List<object> GetAppBankStaticModule()
        {
            List<object> result = new List<object>();
            var list = student_ExamRepository.GetStudentExamStaticRepository(new RB_Student_Exam_Extend());
            var bankTypeList = Common.Plugin.EnumHelper.EnumToList(typeof(LevelTypeEnum));
            if (bankTypeList != null && bankTypeList.Count > 0)
            {
                foreach (var item in bankTypeList)
                {
                    int joinNum = 0;
                    var tempList = list?.Where(qitem => (int)qitem.BankType == item.Id)?.ToList();
                    joinNum = tempList?.Count ?? 0;
                    result.Add(new
                    {
                        item.Id,
                        item.Name,
                        JoinNum = joinNum
                    });
                }
            }
            return result;
        }

        /// <summary>
        /// 获取题库分页列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowsCount"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<object> GetAppBankPageModule(int pageIndex, int pageSize, out long rowsCount, RB_Question_Bank_ViewModel query)
        {
            List<object> result = new List<object>();
            var bankList = question_BankRepository.GetQuestionBankPageListRepository(pageIndex, pageSize, out rowsCount, query);
            if (bankList != null && bankList.Count > 0)
            {
                string bankIds = string.Join(",", bankList.Select(qitem => qitem.BankId));
                List<RB_Student_Exam_Extend> stuExamList = new List<RB_Student_Exam_Extend>();
                if (!string.IsNullOrEmpty(bankIds))
                {
                    stuExamList = student_ExamRepository.GetStudentExamListRepository(new RB_Student_Exam_Extend()
                    {
                        // GroupId = query.Group_Id,
                        QBankIds = bankIds
                    });
                }
                foreach (var item in bankList)
                {
                    var tempList = stuExamList?.Where(qitem => qitem.BankId == item.BankId && !string.IsNullOrEmpty(Common.ConvertHelper.FormatTime(qitem.EndTime)))?.OrderByDescending(qitem => qitem.Score)?.ToList();
                    string LeastTime = "";//最短时间
                    decimal HighestScore = 0;//最高分
                    string MyUseTime = "";//用时
                    decimal MyScore = 0;//得分
                    int MyRank = 0;//排名
                    int MyTimes = 0;//测评次数
                    if (tempList != null && tempList.Count > 0)
                    {
                        var least = tempList?.Where(qitem => !string.IsNullOrEmpty(Common.ConvertHelper.FormatTime(qitem.EndTime)))?.OrderBy(qitem => qitem.ExamMinutes)?.FirstOrDefault();
                        if (least != null && Common.ConvertHelper.FormatTime(least.EndTime) != "" && Common.ConvertHelper.FormatTime(least.StartTime) != "")
                        {
                            LeastTime = Common.ConvertHelper.CalcMinutesAndSeconds(least.StartTime, least.EndTime);
                        }
                        HighestScore = tempList?.Max(qitem => qitem.Score) ?? 0;
                        var myLast = tempList?.Where(qitem => !string.IsNullOrEmpty(Common.ConvertHelper.FormatTime(qitem.EndTime)) && qitem.StudentId == query.StudentId).OrderByDescending(qitem => qitem.Id)?.FirstOrDefault();
                        if (myLast != null)
                        {
                            MyUseTime = Common.ConvertHelper.CalcMinutesAndSeconds(myLast.StartTime, myLast.EndTime);
                            MyScore = myLast.Score;
                            MyRank = tempList.FindIndex(qitem => qitem.Id == myLast.Id) + 1;
                        }
                        MyTimes = tempList?.Where(qitem => qitem.StudentId == query.StudentId)?.Count() ?? 0;
                    }
                   
                    var obj = new
                    {
                        item.BankId,
                        item.BankName,
                        JoinNum = tempList?.GroupBy(qitem => qitem.StudentId)?.Count(),
                        LeastTime,
                        HighestScore,
                        MyUseTime,
                        MyScore,
                        MyRank,
                        MyTimes,
                    };
                    result.Add(obj);
                }
            }
            return result;
        }

        /// <summary>
        /// 获取题库详情分页列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowsCount"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<object> GetAppBankDetailsPageModule(int pageIndex, int pageSize, out long rowsCount, RB_Question_ViewModel query, int StudentId = 0)
        {
            List<object> result = new List<object>();
            var questionList = questionRepository.GetQuestionPageListRepository(pageIndex, pageSize, out rowsCount, query)?.OrderBy(qitem => qitem.Category)?.ToList();
            List<RB_Student_ExamDetails_Extend> stuExamList = new List<RB_Student_ExamDetails_Extend>();
            if (StudentId > 0)
            {
                stuExamList = student_ExamDetailsRepository.GetStudentExamDetailsListRepository(new RB_Student_ExamDetails_Extend() { BankId = query.BankId, StudentId = StudentId });
            }
            if (questionList != null && questionList.Count > 0)
            {
                foreach (var item in questionList)
                {
                    var tempQuestion = stuExamList?.FirstOrDefault(qitem => qitem.QuestionId == item.QuestionId);
                    decimal Score = 5;
                    var QuestionContentObj = analysisQuestion.ParsingQuestion(item.QuestionTypeKey, item.QuestionContent, isNoAnswer: true);
                    List<object> quesAnswerList = new List<object>();
                    if (item.QuestionTypeKey == "listening" || item.QuestionTypeKey == "reading-comprehensio")
                    {
                        try
                        {

                            var listenList = JsonHelper.DeserializeObject<List<SubAnswerItem>>(item.Answer);
                            if (listenList != null && listenList.Count > 0)
                            {
                                Score = 5 * listenList.Count;
                                foreach (var subItem in listenList)
                                {
                                    quesAnswerList.Add(subItem.SubAnswer);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_listening:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }
                    if (item.QuestionTypeKey != "listening" && item.QuestionTypeKey != "reading-comprehensio" && !string.IsNullOrEmpty(item.Answer))
                    {
                        try
                        {
                            var tempList = Common.ConvertHelper.StringToFileList(item.Answer);
                            if (tempList != null && tempList.Count > 0)
                            {
                                foreach (var tItem in tempList)
                                {
                                    quesAnswerList.Add(tItem);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_Answer:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }
                    List<string> studentAnswerList = new List<string>();
                    if (!string.IsNullOrEmpty(tempQuestion?.StudentAnswer))
                    {
                        studentAnswerList = JsonHelper.DeserializeObject<List<string>>(tempQuestion?.StudentAnswer);
                    }
                    var obj = new
                    {
                        item.QuestionId,
                        item.QuestionTypeId,
                        item.QuestionTypeKey,
                        item.Category,
                        LevelType = item.BankType,
                        item.Title,
                        item.DifficultyType,
                        item.DifficultyTypeStr,
                        item.AnswerParse,
                        QuestionContentObj,
                        QuestionAnswerList = quesAnswerList,
                        StudentAnswer = studentAnswerList,
                        item.Answer,
                        Score,
                        IsAnswer = tempQuestion?.IsAnswer ?? 0,
                        IsWrong = tempQuestion?.IsWrong ?? 0,
                        StudentScore = tempQuestion?.StudentScore ?? 0,
                    };
                    result.Add(obj);
                }
            }
            return result;
        }



        /// <summary>
        /// 新增修改学员练习
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetStudentPracticeModule(RB_Student_Practice_Extend model)
        {
            bool flag = false;
            //var oldModel = student_PracticeRepository.GetStudentPracticeListRepository(new RB_Student_Practice_Extend()
            //{
            //    StudentId = model.StudentId,
            //    QuestionId = model.QuestionId
            //})?.FirstOrDefault();
            //model.Id = oldModel?.Id ?? 0;
            //if (model.Id > 0)
            //{
            //    Dictionary<string, object> fileds = new Dictionary<string, object>()
            //    {
            //        {nameof(RB_Student_Practice_Extend.IsAnswer),model.IsAnswer },
            //        {nameof(RB_Student_Practice_Extend.IsWrong),model.IsWrong },
            //    };
            //    flag = student_PracticeRepository.Update(fileds, new WhereHelper(nameof(RB_Student_Practice_Extend.Id), model.Id));
            //}
            //else
            //{

            //}
            var newId = student_PracticeRepository.Insert(model);
            model.Id = newId;
            flag = newId > 0;
            return flag;
        }

        /// <summary>
        /// 学员开始测试
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetStudentStartExamModule(RB_Student_Exam_Extend model)
        {
            model.StartTime = DateTime.Now;
            model.Times = student_ExamRepository.GetStudentExamTimesRepository(model);
            var newId = student_ExamRepository.Insert(model);
            model.Id = newId;
            return newId > 0;
        }

        /// <summary>
        /// 新增修改学员考试练习
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetStudentExamModule(RB_Student_Exam_Extend model)
        {
            bool flag = false;
            Dictionary<string, object> fileds = new Dictionary<string, object>()
            {
                { nameof(RB_Student_Exam_Extend.EndTime),DateTime.Now}
            };
            decimal totalScore = 0;
            if (model.ExamDetailsList != null && model.ExamDetailsList.Count > 0)
            {

                foreach (var item in model.ExamDetailsList)
                {
                    item.ExamId = model.Id;
                    if (item.QuestionTypeKey == "listening" || item.QuestionTypeKey == "reading-comprehensio")
                    {
                        decimal tempScore = 0;
                        try
                        {
                            var reading_AnswerList = Common.Plugin.JsonHelper.DeserializeObject<List<SubAnswerItem>>(item.Answer.ToString());
                            var reading_Stu_AnswerList = Common.Plugin.JsonHelper.DeserializeObject<List<SubAnswerItem>>(item.StudentAnswer.ToString());
                            if (reading_AnswerList != null && reading_Stu_AnswerList != null
                                && reading_AnswerList.Count > 0 && reading_Stu_AnswerList.Count > 0
                                && reading_AnswerList.Count == reading_Stu_AnswerList.Count)
                            {
                                for (var i = 0; i < reading_AnswerList.Count; i++)
                                {
                                    if (reading_AnswerList[i].SubQuestionKey != "fill-in" && reading_AnswerList[i].SubQuestionKey != "short-answer")
                                    {
                                        if (reading_AnswerList[i].SubAnswer == reading_Stu_AnswerList[i].SubAnswer)
                                        {
                                            tempScore += 5;
                                        }
                                    }
                                }
                            }
                        }
                        catch
                        {

                        }
                        item.StudentScore = tempScore;
                    }
                    else
                    {
                        if (item.IsWrong == 0)
                        {
                            item.StudentScore = item.Score;
                        }
                    }
                }
                flag = student_ExamDetailsRepository.BatchStudentExamDetailsRepository(model.ExamDetailsList);
                totalScore = model.ExamDetailsList.Sum(qitem => qitem.StudentScore);
            }
            fileds.Add(nameof(RB_Student_Exam_Extend.Score), totalScore);
            flag = student_ExamRepository.Update(fileds, new WhereHelper(nameof(RB_Student_Exam_Extend.Id), model.Id));
            return flag;
        }

        /// <summary>
        /// 获取学员练习错题统计
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public object GetPracticeWrongStaticModule(RB_Student_Practice_Extend query)
        {
            int readingWrongTotalCount = 0;
            int readingWrongFinishCount = 0;
            int readingWrongStartId = 0;

            int listeningWrongTotalCount = 0;
            int listeningWrongFinishCount = 0;
            int listeningWrongStartId = 0;

            int grammarWrongTotalCount = 0;
            int grammarWrongFinishCount = 0;
            int grammarWrongStartId = 0;

            int wordsWrongTotalCount = 0;
            int wordsWrongFinishCount = 0;
            int wordsWrongStartId = 0;

            var list = student_PracticeRepository.GetStudentPracticeWrongStaticRepository(query);
            var studuList = student_PracticeRepository.GetStudentPracticeListRepository(new RB_Student_Practice_Extend()
            {
                StudentId = query.StudentId,
                IsQueryReview=1,
                LevelType=query.LevelType
            });
            if (list != null && list.Count > 0)
            {
                var tempReadingList = list?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ReadingChoose)?.ToList();
                if (tempReadingList != null && tempReadingList.Count > 0)
                {
                    readingWrongTotalCount = tempReadingList.Sum(qitem => qitem.WrongCount);
                }

                var tempFinishReadingList = studuList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ReadingChoose)?.ToList();
                if (tempFinishReadingList != null && tempFinishReadingList.Count > 0)
                {
                    readingWrongFinishCount = tempFinishReadingList.Count;
                    readingWrongStartId = tempFinishReadingList.Max(qitem => qitem.Id);
                }

                var tempListeningList = list?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.Listening)?.ToList();
                if (tempListeningList != null && tempListeningList.Count > 0)
                {
                    listeningWrongTotalCount = tempListeningList.Sum(qitem => qitem.WrongCount);
                }
                var tempFinishListeningList = studuList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.Listening)?.ToList();
                if (tempFinishListeningList != null && tempFinishListeningList.Count > 0)
                {
                    listeningWrongFinishCount = tempFinishListeningList.Count;
                    listeningWrongStartId = tempFinishListeningList.Max(qitem => qitem.Id);
                }

                var tempGrammarList = list?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseGrammarUse)?.ToList();
                if (tempGrammarList != null && tempGrammarList.Count > 0)
                {
                    grammarWrongTotalCount = tempGrammarList.Sum(qitem => qitem.WrongCount);
                }

                var tempFinishGrammarList = studuList?.Where(qitem => qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseGrammarUse)?.ToList();
                if (tempFinishGrammarList != null && tempFinishGrammarList.Count > 0)
                {
                    grammarWrongFinishCount = tempFinishGrammarList.Count;
                    grammarWrongStartId = tempFinishGrammarList.Max(qitem => qitem.Id);
                }

                var tempWordsList = list?.Where(qitem =>
                     qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWord
                  || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseMean
                  || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWordUse
                 )?.ToList();
                if (tempWordsList != null && tempWordsList.Count > 0)
                {
                    wordsWrongTotalCount = tempWordsList.Sum(qitem => qitem.WrongCount);
                }

                var tempFinishWordsList = studuList?.Where(qitem => 
                     qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWord
                  || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseMean
                  || qitem.Category == Common.Enum.Course.QuestionCategoryEnum.ChooseWordUse)?.ToList();
                if (tempFinishWordsList != null && tempFinishWordsList.Count > 0)
                {
                    wordsWrongFinishCount = tempFinishWordsList.Count;
                    wordsWrongStartId = tempFinishWordsList.Max(qitem => qitem.Id);
                }
            }
            var obj = new
            {
                readingWrongTotalCount,
                readingWrongFinishCount,
                readingWrongStartId,
                listeningWrongTotalCount,
                listeningWrongFinishCount,
                listeningWrongStartId,
                grammarWrongTotalCount,
                grammarWrongFinishCount,
                grammarWrongStartId,
                wordsWrongTotalCount,
                wordsWrongFinishCount,
                wordsWrongStartId
            };
            return obj;
        }

        /// <summary>
        /// 获取练习错题分页列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowsCount"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<object> GetPracticeWrongPageModule(int pageIndex, int pageSize, out long rowsCount, RB_Student_Practice_Extend query)
        {
            List<object> result = new List<object>();
            var list = student_PracticeRepository.GetStudentPracticePageRepository(pageIndex, pageSize, out rowsCount, query);
            if (list != null && list.Count > 0)
            {
                string questionIds = string.Join(",", list.Select(qitem => qitem.QuestionId));
                var questionList = questionRepository.GetQuestionListRepository(new RB_Question_ViewModel()
                {
                    QuestionIds=questionIds
                });
                foreach (var item in list)
                {
                    var tempQuestion = questionList.Where(qitem => qitem.QuestionId == item.QuestionId).FirstOrDefault();
                    var QuestionContentObj = analysisQuestion.ParsingQuestion(item.QuestionTypeKey, item.QuestionContent, isNoAnswer: false);
                    List<object> quesAnswerList = new List<object>();
                    if (tempQuestion.QuestionTypeKey == "listening" || tempQuestion.QuestionTypeKey == "reading-comprehensio")
                    {
                        try
                        {
                            var listenList = JsonHelper.DeserializeObject<List<SubAnswerItem>>(tempQuestion.Answer);
                            if (listenList != null && listenList.Count > 0)
                            {
                                foreach (var subItem in listenList)
                                {
                                    quesAnswerList.Add(subItem.SubAnswer);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_listening:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }
                    if (tempQuestion.QuestionTypeKey != "listening" && tempQuestion.QuestionTypeKey != "reading-comprehensio" && !string.IsNullOrEmpty(tempQuestion.Answer))
                    {
                        try
                        {
                            var tempList = Common.ConvertHelper.StringToFileList(tempQuestion.Answer);
                            if (tempList != null && tempList.Count > 0)
                            {
                                foreach (var tItem in tempList)
                                {
                                    quesAnswerList.Add(tItem);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Common.Plugin.LogHelper.Write(ex, "GetAppQuestionCategoryListModule_Answer:" + Common.Plugin.JsonHelper.Serialize(item));
                        }
                    }
                    List<string> studentAnswerList = new List<string>();
                    if (!string.IsNullOrEmpty(item?.StudentAnswer))
                    {
                        studentAnswerList = JsonHelper.DeserializeObject<List<string>>(item?.StudentAnswer);
                    }
                    var obj = new
                    {
                        item.Id,
                        item.QuestionId,
                        item.QuestionTypeId,
                        item.QuestionTypeKey,
                        item.Category,
                        item.LevelType,
                        item.Title,
                        item.AnswerParse,
                        QuestionContentObj,
                        QuestionAnswerList = quesAnswerList,
                        StudentAnswer = studentAnswerList,
                        item.Answer,
                        Score=0,
                        IsAnswer = item?.IsAnswer ?? 0,
                        IsWrong = item?.IsWrong ?? 0,
                        StudentScore = 0
                    };
                    result.Add(obj);
                }
            }
            return result;
        }

        /// <summary>
        /// 设置错题已复习
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SetPracticeReviewModule(RB_Student_Practice_Extend model)
        {
            Dictionary<string, object> fileds = new Dictionary<string, object>()
            {
                {nameof(RB_Student_Practice_Extend.IsReview),model.IsReview }
            };
            bool flag = student_PracticeRepository.Update(fileds, new WhereHelper(nameof(RB_Student_Practice_Extend.Id), model.Id));
            return flag;
        }

        #endregion
    }
}