import time

from DBHelper.MongoHelperInstance import DB_TEST
from Modules.CodeExecutor.PythonCodeExecutor import PythonCodeExecutor
from Modules.Indicators.Tags.TagsImpl import TagsImpl
from Modules.Questions.QuestionsObj import QuestionObj
from Modules.Questions.QuestionsUtils import QuestionUtils


class QuestionImpl(object):

    @staticmethod
    def new_question(**kwargs):
        """新建问题"""
        data = kwargs['data']

        quest = QuestionObj()
        quest.question_id = QuestionUtils.make_new_cid()
        quest.question_name = data['question_name']
        quest.describe = data['describe']
        quest.author = data['author']
        quest.date = time.strftime('%Y-%m-%d', time.localtime())
        quest.tags = list()
        for tag in data['tags']:
            tags = quest.Tags()
            tags.tag_name = tag['tag_name']
            tags.tag_id = tag['tag_id']
            quest.tags.append(tags)
        quest.question_type = data['question_type']

        question_type = data['question_type']

        if question_type == '单选题-多解' or question_type == '多选题-多解':
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.percentage = option['percentage']
                options.describe = option['describe']
                quest.options.append(options)
        elif question_type == '单选题-单解' or question_type == '多选题-单解':
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.correct = option['correct']
                options.describe = option['describe']
                quest.options.append(options)
        elif question_type == '填空题-单解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.answer = decision['answer']
            quest.decision_setting = setting
        elif question_type == '填空题-包含多解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.contain = decision['contain']
            setting.score = decision['score']
            quest.decision_setting = setting
        elif question_type == '填空题-档位多解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.interval = decision['interval']
            setting.score = decision['score']
            quest.decision_setting = setting
        elif question_type == '填空题-指定处理':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting
        elif question_type == '自定义问题':
            input_setting = data['input_setting']
            quest.input_setting = list()
            for input_ in input_setting:
                input_set = quest.InputSetting()
                input_set.input = input_['input']
                input_set.type = input_['type']
                input_set.mark = input_['mark']
                quest.input_setting.append(input_set)
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting

        DB_TEST.upsert_single_data(
            '模型数据',
            '问题数据',
            {'问题名称': data['question_name']},
            quest.fields_toggle()
        )

        quest_data = quest.fields_toggle()
        impl = TagsImpl()
        parameter = {
            "associate_id": quest_data['问题ID'],
            "associate_name": quest_data['问题名称'],
            "associate_type": "question",
            "tags_id": [item['标签ID'] for item in quest_data['标签']]
        }
        impl.associate_tags(data=parameter)

        return '新建成功'

    @staticmethod
    def check_question(**kwargs):
        """校验问题"""
        data = kwargs['data']
        answer = data['question_answer']
        quest = QuestionObj()
        quest.question_name = data['question_name']
        quest.question_type = data['question_type']

        question_type = data['question_type']

        if question_type == '单选题-多解' or question_type == '多选题-多解':
            # 校验数据格式
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.percentage = option['percentage']
                options.describe = option['describe']
                quest.options.append(options)
            # 校验答案
            quest_data = quest.fields_toggle()
            if question_type == '单选题-多解':
                score = 0
                for option_ in quest_data['题目选项']:
                    if option_['描述'] == answer:
                        score = option_['得分比'] * 0.01
                        break
                    else:
                        score = '校验失败，所选结果不在规定选项里'
                return score
            else:
                score = 0
                desc = [des['描述'] for des in quest_data['题目选项']]
                if set(answer) < set(desc):
                    for option_ in quest_data['题目选项']:
                        if option_['描述'] in answer:
                            if option_['得分比'] == 0:
                                score = 0
                                break
                            score += option_['得分比'] * 0.01
                else:
                    score = '校验失败，所选结果不在规定选项里'
                return score
        elif question_type == '单选题-单解' or question_type == '多选题-单解':
            # 校验数据格式
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.correct = option['correct']
                options.describe = option['describe']
                quest.options.append(options)
            # 校验答案
            quest_data = quest.fields_toggle()
            if question_type == '单选题-单解':
                score = 0
                for option_ in quest_data['题目选项']:
                    if option_['描述'] == answer:
                        score = option_['正确']
                        break
                    else:
                        score = '校验失败，所选结果不在规定选项里'
                return score
            else:
                desc = [des['描述'] for des in quest_data['题目选项']]
                right = [des['描述'] for des in quest_data['题目选项'] if des['正确'] == 1]
                if set(answer) < set(desc):
                    if right == answer:
                        score = 1
                    else:
                        score = 0
                else:
                    score = '校验失败，所选结果不在规定选项里'

                return score
        elif question_type == '填空题-单解':
            # 校验数据格式
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.answer = decision['answer']
            quest.decision_setting = setting
            # 校验答案
            quest_data = quest.fields_toggle()
            if answer == quest_data['判定设置']['正确答案']:
                score = 1
            else:
                score = 0
            return score
        elif question_type == '填空题-包含多解':
            # 校验数据格式
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.contain = decision['contain']
            setting.score = decision['score']
            quest.decision_setting = setting
            # 校验答案
            quest_data = quest.fields_toggle()
            score = 0
            for index in range(len(quest_data['判定设置']['包含'])):
                if quest_data['判定设置']['包含'][index] == answer:
                    score = quest_data['判定设置']['得分比'][index] * 0.01
            return score
        elif question_type == '填空题-档位多解':
            # 校验数据格式
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.interval = decision['interval']
            setting.score = decision['score']
            quest.decision_setting = setting
            # 校验答案
            quest_data = quest.fields_toggle()
            score = 0
            for index in range(len(quest_data['判定设置']['区间'])):
                if eval(quest_data['判定设置']['区间'][index].replace('x', str(answer))):
                    score = quest_data['判定设置']['得分比'][index] * 0.01
            return score
        elif question_type == '填空题-指定处理':
            # 校验数据格式
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting
            # 校验答案
            quest_data = quest.fields_toggle()
            if eval(quest_data['判定设置']['指定处理'].replace('x', str(answer))):
                score = 1
            else:
                score = 0
            return score
        elif question_type == '自定义问题':
            # 校验数据格式
            input_setting = data['input_setting']
            quest.input_setting = list()
            for input_ in input_setting:
                input_set = quest.InputSetting()
                input_set.input = input_['input']
                input_set.type = input_['type']
                input_set.mark = input_['mark']
                quest.input_setting.append(input_set)
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting
            # 校验答案
            quest_data = quest.fields_toggle()
            param_dict = dict()
            for param in quest_data['输入设置']:
                param_dict[param['备注']] = param['输入']

            my_exec = PythonCodeExecutor(func_name='check_question', func_text=quest_data['判定设置']['指定处理'], params=param_dict)
            result = my_exec.result
            if isinstance(result, (float, int)):
                return result
            else:
                return '校验成功，结果为{}'.format(result)

    @staticmethod
    def search_question(**kwargs):
        """查询问题"""

        def make_search_body(param):
            body = dict()
            search_keys = list(param.keys())
            if 'question_name' in search_keys:
                body['问题名称'] = {"$regex": param['question_name']}

            if 'author' in search_keys:
                body['作者'] = param['author']

            if 'question_type' in search_keys:
                body['问题类型'] = {"$regex": param['question_type']}

            if 'tags' in search_keys:
                body['标签'] = {"$in": param['tags']}

            return body

        def make_sort_body(param):
            if param == 'asc':
                body = {"日期": 1}
            else:
                body = {"日期": -1}

            return body

        data = kwargs['data']
        sort = data['sort']
        page_size = int(data['page_size'])
        page_no = int(data['page_no'])
        search_body = make_search_body(data)
        sort_body = make_sort_body(sort)
        page_size = 10 if page_size > 10 else page_size

        total = DB_TEST.find_all_data_with_count(
            '模型数据',
            '问题数据',
            search_body
        )

        records = DB_TEST.find_data_by_page_with_sort(
            '模型数据',
            '问题数据',
            search_body,
            ['问题ID', '问题名称', '问题类型', '题目描述', '作者', '日期', '标签'],
            sort_body,
            page_size,
            page_no
        )

        return_list = list()
        if records:
            for record in records:
                return_dict = dict()
                return_dict['question_id'] = record['问题ID']
                return_dict['question_name'] = record['问题名称']
                return_dict['question_type'] = record['问题类型']
                return_dict['describe'] = record['题目描述']
                return_dict['author'] = record['作者']
                return_dict['date'] = record['日期']
                return_dict['tags'] = record['标签']
                return_list.append(return_dict)

        result = {
            "total": total,
            "records": return_list
        }

        return result

    @staticmethod
    def view_question(**kwargs):
        qid = kwargs['qid']
        record = DB_TEST.find_single_data(
            '模型数据',
            '问题数据',
            {'问题ID': qid},
            ['问题ID', '问题名称', '问题类型', '作者', '题目描述', '题目选项', '判定设置', '输入设置', '日期', '标签']
        )

        return_dict = dict()
        if record:
            return_dict['question_id'] = record['问题ID']
            return_dict['question_name'] = record['问题名称']
            return_dict['question_type'] = record['问题类型']
            return_dict['author'] = record['作者']
            return_dict['describe'] = record['题目描述']
            return_dict['date'] = record['日期']
            return_dict['tags'] = list()
            for tag in record['标签']:
                tag_dict = dict()
                tag_dict['tag_name'] = tag['标签名称']
                tag_dict['tag_id'] = tag['标签ID']
                return_dict['tags'].append(tag_dict)

            if return_dict['question_type'] == '单选题-多解' or return_dict['question_type'] == '多选题-多解':
                return_dict['options'] = list()
                for option in record['题目选项']:
                    option_ = dict()
                    option_['percentage'] = option['得分比']
                    option_['describe'] = option['描述']
                    return_dict['options'].append(option_)
            elif return_dict['question_type'] == '单选题-单解' or return_dict['question_type'] == '多选题-单解':
                return_dict['options'] = list()
                for option in record['题目选项']:
                    option_ = dict()
                    option_['correct'] = option['正确']
                    option_['describe'] = option['描述']
                    return_dict['options'].append(option_)
            elif return_dict['question_type'] == '填空题-单解':
                return_dict['decision_setting'] = dict()
                return_dict['decision_setting']['answer'] = record['判定设置']['正确答案']
            elif return_dict['question_type'] == '填空题-包含多解':
                return_dict['decision_setting'] = dict()
                return_dict['decision_setting']['contain'] = record['判定设置']['包含']
                return_dict['decision_setting']['score'] = record['判定设置']['得分比']
            elif return_dict['question_type'] == '填空题-档位多解':
                return_dict['decision_setting'] = dict()
                return_dict['decision_setting']['interval'] = record['判定设置']['区间']
                return_dict['decision_setting']['score'] = record['判定设置']['得分比']
            elif return_dict['question_type'] == '填空题-指定处理':
                return_dict['decision_setting'] = dict()
                return_dict['decision_setting']['assigned'] = record['判定设置']['指定处理']
            elif return_dict['question_type'] == '自定义问题':
                return_dict['decision_setting'] = dict()
                return_dict['decision_setting']['assigned'] = record['判定设置']['指定处理']
                return_dict['input_setting'] = list()
                for input_ in record['输入设置']:
                    _input = dict()
                    _input['input'] = input_['输入']
                    _input['type'] = input_['类型']
                    _input['mark'] = input_['备注']
                    return_dict['input_setting'].append(_input)

        return return_dict

    @staticmethod
    def edit_question(**kwargs):
        """编辑问题"""
        data = kwargs['data']
        question_type = DB_TEST.find_single_column(
            '模型数据',
            '问题数据',
            {'问题ID': data['question_id']},
            '问题类型'
        )
        if not question_type:
            return '该问题不存在'

        quest = QuestionObj()
        quest.question_id = data['question_id']
        quest.question_name = data['question_name']
        quest.describe = data['describe']
        quest.date = time.strftime('%Y-%m-%d', time.localtime())
        quest.tags = data['tags']
        quest.question_type = question_type
        if question_type == '单选题-多解' or question_type == '多选题-多解':
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.percentage = option['percentage']
                options.describe = option['describe']
                quest.options.append(options)
        elif question_type == '单选题-单解' or question_type == '多选题-单解':
            quest.options = list()
            for option in data['options']:
                options = quest.Options()
                options.correct = option['correct']
                options.describe = option['describe']
                quest.options.append(options)
        elif question_type == '填空题-单解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.answer = decision['answer']
            quest.decision_setting = setting
        elif question_type == '填空题-包含多解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.contain = decision['contain']
            setting.score = decision['score']
            quest.decision_setting = setting
        elif question_type == '填空题-档位多解':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.contain = decision['interval']
            setting.score = decision['score']
            quest.decision_setting = setting
        elif question_type == '填空题-指定处理':
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting
        elif question_type == '自定义问题':
            input_setting = data['input_setting']
            quest.input_setting = list()
            for input_ in input_setting:
                input_set = quest.InputSetting()
                input_set.input = input_['input']
                input_set.type = input_['type']
                input_set.mark = input_['mark']
                quest.input_setting.append(input_set)
            decision = data['decision_setting']
            setting = quest.DecisionSetting()
            setting.assigned = decision['assigned']
            quest.decision_setting = setting

        DB_TEST.update_single_data(
            '模型数据',
            '问题数据',
            {'问题ID': data['question_id']},
            quest.fields_toggle()
        )

        return '编辑成功'

    @staticmethod
    def delete_question(**kwargs):
        """删除问题"""
        qid = kwargs['qid']

        tags = DB_TEST.find_single_column(
            '模型数据',
            '问题数据',
            {'问题ID': qid},
            '标签'
        )
        # 删除标签关联的问题
        for tag in tags:
            DB_TEST.update_single_data_by_pull(
                '模型数据',
                '标签数据',
                {'标签名称': tag},
                {"关联函数": {"标签ID": qid}}
            )
        # 删除问题
        DB_TEST.delete_single_data(
            '模型数据',
            '问题数据',
            {'问题ID': qid}
        )

        return '操作成功'