# Example:
#
#   pool = QuestionPool()
#   pool.add_from_files(['file1.yaml', 'file1.yaml'])
#
#   test = []
#   for q in pool.values():
#       test.append(create_question(q))
#
#   test[0]['answer'] = 42           # insert answer
#   grade = test[0].correct()        # correct answer


# Functions:
#    create_question(q)
#           q       - dictionary with question in yaml format
#           returns - question instance with the correct class


# An instance of an actual question is a Question object:
#
# Question          - base class inherited by other classes
# QuestionRadio     - single choice from a list of options
# QuestionCheckbox  - multiple choice, equivalent to multiple true/false
# QuestionText      - line of text compared to a list of acceptable answers
# QuestionTextRegex - line of text matched against a regular expression
# QuestionTextArea  - corrected by an external program
# QuestionInformation - not a question, just a box with content

import yaml
import random
import re
import subprocess
import os.path
import logging


qlogger = logging.getLogger('Questions')
qlogger.setLevel(logging.INFO)

fh = logging.FileHandler('question.log')
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s | %(name)s | %(levelname)s | %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)

qlogger.addHandler(fh)
qlogger.addHandler(ch)

# if an error occurs in a question, the question is replaced by this message
qerror = {
    'filename': 'questions.py',
    'ref': '__error__',
    'type': 'warning',
    'text': 'An error occurred while generating this question.'
    }

# ===========================================================================
class QuestionsPool(dict):
    '''This class contains base questions read from files, but which are
    not ready yet. They have to be instantiated for each student.'''

    #------------------------------------------------------------------------
    def add(self, questions, filename, path):
        # add some defaults if missing from sources
        for i, q in enumerate(questions):
            if not isinstance(q, dict):
                qlogger.error('Question index {0} from file {1} is not a dictionary. Skipped...'.format(i, filename))
                continue

            if q['ref'] in self:
                qlogger.error('Duplicate question "{0}" in files "{1}" and "{2}". Skipped...'.format(q['ref'], filename, self[q['ref']]['filename']))
                continue

            # index is the position in the questions file, 0 based
            q.update({
                'filename': filename,
                'path': path,
                'index': i
                })
            q.setdefault('ref', filename + ':' + str(i)) # 'filename.yaml:3'
            q.setdefault('type', 'information')

            # add question to the pool
            self[q['ref']] = q
            qlogger.debug('Added question "{0}" to the pool.'.format(q['ref']))

    #------------------------------------------------------------------------
    def add_from_files(self, files, path='.'):
        '''Given a list of YAML files, reads them all and tries to add
        questions to the pool.'''
        for filename in files:
            try:
                with open(os.path.normpath(os.path.join(path, filename)), 'r', encoding='utf-8') as f:
                    questions = yaml.load(f)
            except(FileNotFoundError):
                qlogger.error('Questions file "{0}" not found. Skipping this one.'.format(filename))
                continue
            except(yaml.parser.ParserError):
                qlogger.error('Error loading questions from YAML file "{0}". Skipping this one.'.format(filename))
                continue
            self.add(questions, filename, path)
            qlogger.info('Added {0} questions from "{1}" to the pool.'.format(len(questions), filename))


#============================================================================
# Question Factory
# Given a dictionary returns a question instance.
def create_question(q):
    '''To create a question, q must be a dictionary with at least the
    following keys defined:
        filename
        ref
        type
    The remaing keys depend on the type of question.
    '''

    # Depending on the type of question, a different question class is
    # instantiated. All these classes derive from the base class `Question`.
    types = {
        'radio'     : QuestionRadio,
        'checkbox'  : QuestionCheckbox,
        'text'      : QuestionText,
        'text_regex': QuestionTextRegex,
        'textarea'  : QuestionTextArea,
        'information': QuestionInformation,
        'warning'   : QuestionInformation,
    }


    # If `q` is of a question generator type, an external program will be run
    # and expected to print a valid question in yaml format to stdout. This
    # output is then converted to a dictionary and `q` becomes that dict.
    if q['type'] == 'generator':
        qlogger.debug('Generating question "{0}"...'.format(q['ref']))
        q.update(question_generator(q))
    # At this point the generator question was replaced by an actual question.

    # Get the correct question class for the declared question type
    try:
        questiontype = types[q['type']]
    except KeyError:
        qlogger.error('Unsupported question type "{0}" in "{1}:{2}".'.format(q['type'], q['filename'], q['ref']))
        questiontype, q = QuestionWarning, qerror

    # Create question instance and return
    try:
        qinstance = questiontype(q)
    except:
        qlogger.error('Could not create question "{0}" from file "{1}".'.format(q['ref'], q['filename']))
        qinstance = QuestionInformation(qerror)

    return qinstance


# ---------------------------------------------------------------------------
def question_generator(q):
    '''Run an external program that will generate a question in yaml format.
    This function will return the yaml converted back to a dict.'''

    q.setdefault('arg', '')   # will be sent to stdin

    script = os.path.abspath(os.path.normpath(os.path.join(q['path'], q['script'])))
    try:
        p = subprocess.Popen([script], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT)
    except FileNotFoundError:
        qlogger.error('Script "{0}" of question "{2}:{1}" not found'.format(script, q['ref'], q['filename']))
        return qerror
    except PermissionError:
        qlogger.error('Script "{0}" has wrong permissions. Is it executable?'.format(script, q['ref'], q['filename']))
        return qerror

    try:
        qyaml = p.communicate(input=q['arg'].encode('utf-8'), timeout=5)[0].decode('utf-8')
    except subprocess.TimeoutExpired:
        p.kill()
        qlogger.error('Timeout on script "{0}" of question "{2}:{1}"'.format(script, q['ref'], q['filename']))
        return qerror

    return yaml.load(qyaml)


# ===========================================================================
# Questions derived from Question are already instantiated and ready to be
# presented to students.
# ===========================================================================
class Question(dict):
    '''
    Classes derived from this base class are meant to instantiate a question
    to a student.
    Instances can shuffle options, or automatically generate questions.
    '''
    def __init__(self, q):
        super().__init__(q)

        # these are mandatory for any question:
        self.set_defaults({
            'title': '',
            'answer': None,
            })

    def correct(self):
        self['grade'] = 0.0
        return 0.0

    def set_defaults(self, d):
        'Add k:v pairs from default dict d for nonexistent keys'
        for k,v in d.items():
            self.setdefault(k, v)


# ===========================================================================
class QuestionRadio(Question):
    '''An instance of QuestionRadio will always have the keys:
        type (str)
        text (str)
        options (list of strings)
        shuffle (bool, default=True)
        correct (list of floats)
        discount (bool, default=True)
        answer (None or an actual answer)
    '''

    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        # set defaults if missing
        self.set_defaults({
            'text': '',
            'correct': 0,
            'shuffle': True,
            'discount': True,
            })

        n = len(self['options'])

        # always convert to list, e.g.  correct: 2 --> correct: [0,0,1,0,0]
        # correctness levels from 0.0 to 1.0 (no discount here!)
        if isinstance(self['correct'], int):
            self['correct'] = [1.0 if x==self['correct'] else 0.0 for x in range(n)]

        if len(self['correct']) != n:
            qlogger.error('Options and correct mismatch in "{1}", file "{0}".'.format(self['filename'], self['ref']))

        # generate random permutation, e.g. [2,1,4,0,3]
        # and apply to `options` and `correct`
        if self['shuffle']:
            perm = list(range(n))
            random.shuffle(perm)
            self['options'] = [ str(self['options'][i]) for i in perm ]
            self['correct'] = [ float(self['correct'][i]) for i in perm ]

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        if self['answer'] is None:
            x = 0.0      # zero points if no answer given
        else:
            x = self['correct'][int(self['answer'])]
            if self['discount']:
                n = len(self['options'])  # number of options
                x_aver = sum(self['correct']) / n
                x = (x - x_aver) / (1.0 - x_aver)

        self['grade'] = x
        return x


# ===========================================================================
class QuestionCheckbox(Question):
    '''An instance of QuestionCheckbox will always have the keys:
        type (str)
        text (str)
        options (list of strings)
        shuffle (bool, default True)
        correct (list of floats)
        discount (bool, default True)
        answer (None or an actual answer)
    '''

    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        n = len(self['options'])

        # set defaults if missing
        self.set_defaults({
            'text': '',
            'correct': [0.0] * n,     # useful for questionaries
            'shuffle': True,
            'discount': True,
            })

        if len(self['correct']) != n:
            qlogger.error('Options and correct mismatch in "{1}", file "{0}".'.format(self['filename'], self['ref']))

        # generate random permutation, e.g. [2,1,4,0,3]
        # and apply to `options` and `correct`
        if self['shuffle']:
            perm = list(range(n))
            random.shuffle(perm)
            self['options'] = [ str(self['options'][i]) for i in perm ]
            self['correct'] = [ float(self['correct'][i]) for i in perm ]

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        if self['answer'] is None:
            # not answered
            self['grade'] = 0.0
        else:
            # answered
            sum_abs = sum(abs(p) for p in self['correct'])
            if sum_abs < 1e-6:  # case correct [0,...,0] avoid div-by-zero
                self['grade'] = 0.0

            else:
                x = 0.0

                if self['discount']:
                    for i, p in enumerate(self['correct']):
                        x += p if str(i) in self['answer'] else -p
                else:
                    for i, p in enumerate(self['correct']):
                        x += p if str(i) in self['answer'] else 0.0

                self['grade'] = x / sum_abs

        return self['grade']


# ===========================================================================
class QuestionText(Question):
    '''An instance of QuestionText will always have the keys:
        type (str)
        text (str)
        correct (list of str)
        answer (None or an actual answer)
    '''

    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        self.set_defaults({
            'text': '',
            'correct': [],
            })

        # make sure its always a list of possible correct answers
        if not isinstance(self['correct'], list):
            self['correct'] = [self['correct']]

        # make sure all elements of the list are strings
        self['correct'] = [str(a) for a in self['correct']]

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        if self['answer'] is None:
            # not answered
            self['grade'] = 0.0
        else:
            # answered
            self['grade'] = 1.0 if self['answer'] in self['correct'] else 0.0

        return self['grade']


# ===========================================================================
class QuestionTextRegex(Question):
    '''An instance of QuestionTextRegex will always have the keys:
        type (str)
        text (str)
        correct (str with regex)
        answer (None or an actual answer)
    '''

    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        self.set_defaults({
            'text': '',
            'correct': '$.^',   # will always return false
            })

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        if self['answer'] is None:
            # not answered
            self['grade'] = 0.0
        else:
            # answered
            self['grade'] = 1.0 if re.match(self['correct'], self['answer']) else 0.0

        return self['grade']


# ===========================================================================
class QuestionTextArea(Question):
    '''An instance of QuestionTextArea will always have the keys:
        type (str)
        text (str)
        correct (str with script to run)
        answer (None or an actual answer)
        lines (int)
    '''

    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        self.set_defaults({
            'text': '',
            'lines': 8,
            'timeout': 5,  # seconds
            })

        self['correct'] = os.path.abspath(os.path.normpath(os.path.join(self['path'], self['correct'])))

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        if self['answer'] is None:
            # not answered
            self['grade'] = 0.0
        else:
            # answered
            try:
                p = subprocess.run([self['correct']],
                    input=self['answer'],
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    universal_newlines=True,
                    timeout=self['timeout'],
                    )
            except FileNotFoundError:
                qlogger.error('Script "{0}" defined in question "{1}" of file "{2}" could not be found.'.format(self['correct'], self['ref'], self['filename']))
                self['grade'] = 0.0
            except PermissionError:
                qlogger.error('Script "{0}" has wrong permissions. Is it executable?'.format(self['correct']))
                self['grade'] = 0.0
            except subprocess.TimeoutExpired:
                qlogger.warning('Timeout {1}s exceeded while running "{0}"'.format(self['correct'], self['timeout']))
                self['grade'] = 0.0  # student gets a zero if timout occurs
            else:
                if p.returncode != 0:
                    qlogger.warning('Script "{0}" returned error code {1}.'.format(self['correct'], p.returncode))

                try:
                    self['grade'] = float(p.stdout)
                except ValueError:
                    qlogger.error('Correction script of "{0}" returned nonfloat:\n{1}\n'.format(self['ref'], p.stdout))
                    self['grade'] = 0.0

        return self['grade']


# ===========================================================================
class QuestionInformation(Question):
    '''An instance of QuestionInformation will always have the keys:
        type (str)
        text (str)
        points (0.0)
    '''
    #------------------------------------------------------------------------
    def __init__(self, q):
        # create key/values as given in q
        super().__init__(q)

        self.set_defaults({
            'text': '',
            })

        self['points'] = 0.0  # always override the default points of 1.0

    #------------------------------------------------------------------------
    # can return negative values for wrong answers
    def correct(self):
        self['grade'] = 1.0  # always "correct" but points should be zero!
        return self['grade']