# We start with an empty QuestionFactory() that will be populated with
# question generators that we can load from YAML files.
# To generate an instance of a question we use the method generate(ref) where
# the argument is the reference of the question we wish to produce.
#
# Example:
#
#   # read everything from question files
#   factory = QuestionFactory()
#   factory.load_files(['file1.yaml', 'file1.yaml'], '/path/to')
#
#   question = factory.generate('some_ref')
#
#   # experiment answering one question and correct it
#   question['answer'] = 42          # insert answer
#   grade = question.correct()       # correct answer

# An instance of an actual question is an object that inherits from Question()
#
# Question          - base class inherited by other classes
# QuestionInformation - not a question, just a box with content
# 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
# QuestionNumericInterval - line of text parsed as a float

# python standard library
from os import path
import logging

# this project
from perguntations.tools import load_yaml, run_script
from perguntations.questions import (QuestionRadio, QuestionCheckbox,
                                     QuestionText, QuestionTextRegex,
                                     QuestionNumericInterval, QuestionTextArea,
                                     QuestionInformation)

# setup logger for this module
logger = logging.getLogger(__name__)


# ============================================================================
class QuestionFactoryException(Exception):
    pass


# ============================================================================
# This class contains a pool of questions generators from which particular
# Question() instances are generated using QuestionsFactory.generate(ref).
# ============================================================================
class QuestionFactory(dict):
    _types = {
        'radio':            QuestionRadio,
        'checkbox':         QuestionCheckbox,
        'text':             QuestionText,
        'text-regex':       QuestionTextRegex,
        'numeric-interval': QuestionNumericInterval,
        'textarea':         QuestionTextArea,
        # -- informative panels --
        'information':      QuestionInformation,
        'success':          QuestionInformation,
        'warning':          QuestionInformation,
        'alert':            QuestionInformation
    }

    # ------------------------------------------------------------------------
    def __init__(self):
        super().__init__()

    # ------------------------------------------------------------------------
    # Add single question provided in a dictionary.
    # After this, each question will have at least 'ref' and 'type' keys.
    # ------------------------------------------------------------------------
    def add_question(self, question):
        q = question

        # if missing defaults to ref='/path/file.yaml:3'
        q.setdefault('ref', f'{q["filename"]}:{q["index"]}')

        if q['ref'] in self:
            logger.error(f'Duplicate reference "{q["ref"]}".')

        q.setdefault('type', 'information')

        self[q['ref']] = q
        logger.debug(f'Added question "{q["ref"]}" to the pool.')

    # ------------------------------------------------------------------------
    # load single YAML questions file
    # ------------------------------------------------------------------------
    def load_file(self, pathfile, questions_dir=''):
        # questions_dir is a base directory
        # pathfile is a path of a file under the questions_dir
        # For example, if
        #    pathfile = 'math/questions.yaml'
        #    questions_dir = '/home/john/questions'
        # then the complete path is
        #    fullpath = '/home/john/questions/math/questions.yaml'
        fullpath = path.normpath(path.join(questions_dir, pathfile))
        (dirname, filename) = path.split(fullpath)

        questions = load_yaml(fullpath, default=[])

        for i, q in enumerate(questions):
            try:
                q.update({
                    'filename': filename,
                    'path': dirname,
                    'index': i              # position in the file, 0 based
                    })
            except AttributeError:
                logger.error(f'Question {pathfile}:{i} not a dictionary!')
            else:
                self.add_question(q)

        logger.info(f'{len(questions):>4} from "{pathfile}"')

    # ------------------------------------------------------------------------
    # load multiple YAML question files
    # ------------------------------------------------------------------------
    def load_files(self, files, questions_dir):
        logger.info(f'Loading questions from files in "{questions_dir}":')
        for filename in files:
            self.load_file(filename, questions_dir)

    # ------------------------------------------------------------------------
    # Given a ref returns an instance of a descendent of Question(),
    # i.e. a question object (radio, checkbox, ...).
    # ------------------------------------------------------------------------
    def generate(self, ref):

        # Shallow copy so that script generated questions will not replace
        # the original generators
        try:
            q = self[ref].copy()
        except KeyError:  # FIXME exception type?
            logger.error(f'Can\'t find question "{ref}".')
            raise QuestionFactoryException()

        # If question is of generator type, an external program will be run
        # which will 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':
            logger.debug(f'Generating "{ref}" from {q["script"]}')
            q.setdefault('args', [])  # optional arguments
            q.setdefault('stdin', '')  # FIXME necessary?
            script = path.join(q['path'], q['script'])
            out = run_script(script=script, args=q['args'], stdin=q['stdin'])
            try:
                q.update(out)
            except Exception:
                q.update({
                    'type': 'alert',
                    'title': 'Erro interno',
                    'text': 'Ocorreu um erro a gerar esta pergunta.'
                    })

        # The generator was replaced by a question but not yet instantiated

        # Finally we create an instance of Question()
        try:
            qinstance = self._types[q['type']](q)  # instance of correct class
        except KeyError:
            logger.error(f'Unknown type {q["type"]} in {q["filename"]}:{ref}.')
            raise
        except Exception:
            logger.error(f'Failed to create question {q["filename"]}:{ref}.')
            raise
        else:
            logger.debug(f'Generated question "{ref}".')
            return qinstance