# 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 sys
import os.path


# ===========================================================================
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):
                print('[ WARNG ]  Question with index {0} in file {1} is not a dict. Ignoring...'.format(i, filename))
                continue

            if q['ref'] in self:
                print('[ ERROR ]  Duplicate question "{0}" in files "{1}" and "{2}".'.format(q['ref'], filename, self[q['ref']]['filename']))
                sys.exit(1)

            # filename and index (number in the file, 0 based)
            q['filename'] = filename
            q['path'] = path
            q['index'] = i

            # ref  (if missing, add 'filename.yaml:3')
            q['ref'] = str(q.get('ref', filename + ':' + str(i)))

            # type  (default type is 'information')
            q['type'] = str(q.get('type', 'information'))

            # optional title (default empty string)
            q['title'] = str(q.get('title', ''))

            # add question to the pool
            self[q['ref']] = q

    #------------------------------------------------------------------------
    def add_from_files(self, files, path='.'):
        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):
                print('[ ERROR ]  Questions file "{0}" not found.'.format(filename))
                continue
            except(yaml.parser.ParserError):
                print('[ ERROR ] Error loading questions in YAML file "{0}".'.format(filename))
                continue
            self.add(questions, filename, path)


#============================================================================
# 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.
    '''

    # 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':
        q.update(question_generator(q))
    # At this point the generator question was replaced by an actual 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,
        # 'text-regex': QuestionTextRegex,
        # 'regex'     : QuestionTextRegex,
        'textarea'  : QuestionTextArea,
        'information': QuestionInformation,
        'warning'   : QuestionInformation,
        # 'info'      : QuestionInformation,
        # ''          : QuestionInformation,  # default
    }

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

    # Create question instance and return
    try:
        qinstance = questiontype(q)
    except:
        print('[ ERROR ]  Creating question "{0}" from file "{1}".'.format(q['ref'], q['filename']))
        # FIXME if here, then no qinstance is defined to return...

    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['arg'] = q.get('arg', '')  # send this string 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:
        print('[ ERROR ]  Script "{0}" of question "{2}:{1}" not found'.format(script, q['ref'], q['filename']))
        sys.exit(1)
    except PermissionError:
        print('[ ERROR ]  Script "{0}" of question "{2}:{1}" has wrong permissions. Is it executable?'.format(script, q['ref'], q['filename']))
        sys.exit(1)

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

    return yaml.load(qyaml)


# ===========================================================================
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 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,
            'answer': None,
            })

        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:
            print('[ 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,
            'answer': None,
            })

        if len(self['correct']) != n:
            print('[ 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': [],
            'answer': None,
            })

        # 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
            'answer': None,
            })

    #------------------------------------------------------------------------
    # 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': '',
            'answer': None,
            'lines': 8,
            })

        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

            # The correction program expects data from stdin and prints the result to stdout.
            # The result should be a string that can be parsed to a float.
            try:
                p = subprocess.Popen([self['correct']],
                    stdout=subprocess.PIPE,
                    stdin=subprocess.PIPE,
                    stderr=subprocess.STDOUT)
            except FileNotFoundError as e:
                print('[ ERROR ]  Script "{0}" defined in question "{1}" of file "{2}" could not be found'.format(self['correct'], self['ref'], self['filename']))
                raise e
            except PermissionError as e:
                print('[ ERROR ]  Script "{0}" has wrong permissions. Is it executable?'.format(self['correct']))
                raise e

            try:
                value = p.communicate(input=self['answer'].encode('utf-8'), timeout=5)[0].decode('utf-8')
            except subprocess.TimeoutExpired:
                p.kill()
                value = 0.0  # student gets a zero if timout occurs
                print('[ WARNG ]  Timeout in correction script "{0}"'.format(self['correct']))

            # In case the correction program returns a non float value, we assume an error
            # has occurred (for instance, invalid input). We just assume its the student's
            # fault and give him Zero.
            try:
                self['grade'] = float(value)
            except ValueError as e:
                self['grade'] = 0.0
                print('[ ERROR ]  Correction of question "{0}" returned nonfloat:\n{1}\n'.format(self['ref'], value))
                raise e

        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'] = 0.0  # always "correct" but points should be zero!
        return self['grade']