'''
Learn application.
This is the main controller of the application.
'''

# python standard library

import asyncio

from collections import defaultdict

from contextlib import contextmanager  # `with` statement in db sessions

from datetime import datetime

import logging

from random import random

from os.path import join, exists

from typing import Any, Dict, Iterable, List, Optional, Tuple, Set, DefaultDict

# third party libraries

import bcrypt

import networkx as nx
import sqlalchemy as sa

# this project
from aprendizations.models import Student, Answer, Topic, StudentTopic

from aprendizations.questions import Question, QFactory, QDict, QuestionException
from aprendizations.student import StudentState
from aprendizations.tools import load_yaml

# setup logger for this module

logger = logging.getLogger(__name__)

# ============================================================================

class LearnException(Exception):

    '''Exceptions raised from the LearnApp class'''

class DatabaseUnusableError(LearnException):

    '''Exception raised if the database fails in the initialization'''

# ============================================================================

class LearnApp():

    '''
    LearnApp - application logic

      self.deps - networkx topic dependencies

      self.courses - dict {course_id: {'title': ...,
                                       'description': ...,
                                       'goals': ...,}, ...}
      self.factory = dict {qref: QFactory()}
      self.online - dict {student_id: {'number': ...,
                                       'name': ...,
                                       'state': StudentState(),
                                       'counter': ...}, ...}
    '''


    # ------------------------------------------------------------------------
    @contextmanager
    def _db_session(self, **kw):
        '''
        helper to manage db sessions using the `with` statement, for example
          with self._db_session() as s:  s.query(...)

        '''

        session = self.Session(**kw)

        try:

            yield session

            session.commit()

        except Exception:

            logger.error('!!! Database rollback !!!')
            session.rollback()

            raise
        finally:

            session.close()

    # ------------------------------------------------------------------------

    def __init__(self,

                 courses: str,  # filename with course configurations
                 prefix: str,   # path to topics

                 db: str,       # database filename

                 check: bool = False) -> None:

        self._db_setup(db)       # setup database and check students

        self.online: Dict[str, Dict] = dict()    # online students

        try:
            config: Dict[str, Any] = load_yaml(courses)
        except Exception as exc:
            msg = f'Failed to load yaml file "{courses}"'
            logger.error(msg)
            raise LearnException(msg) from exc

        # --- topic dependencies are shared between all courses

        self.deps = nx.DiGraph(prefix=prefix)

        logger.info('Populating topic graph:')

        # topics defined directly in the courses file, usually empty

        base_topics = config.get('topics', {})

        self._populate_graph(base_topics)
        logger.info('%6d topics in %s', len(base_topics), courses)

        # load other course files with the topics the their deps
        for course_file in config.get('topics_from', []):
            course_conf = load_yaml(course_file)    # course configuration

            # FIXME set defaults??

            logger.info('%6d topics imported from %s',

                        len(course_conf["topics"]), course_file)
            self._populate_graph(course_conf)

        logger.info('Graph has %d topics', len(self.deps))

        # --- courses dict

        self.courses = config['courses']

        logger.info('Courses:  %s', ', '.join(self.courses.keys()))

        for cid, course in self.courses.items():

            course.setdefault('title', '')  # course title undefined
            for goal in course['goals']:

                if goal not in self.deps.nodes():

                    msg = f'Goal "{goal}" from course "{cid}" does not exist'

                    logger.error(msg)

                    raise LearnException(msg)

                if self.deps.nodes[goal]['type'] == 'chapter':

                    course['goals'] += [g for g in self.deps.predecessors(goal)
                                        if g not in course['goals']]

        # --- factory is a dict with question generators for all topics
        self.factory: Dict[str, QFactory] = self._make_factory()

        # if graph has topics that are not in the database, add them

        self._add_missing_topics(self.deps.nodes())

        if check:

            self._sanity_check_questions()

    # ------------------------------------------------------------------------

    def _sanity_check_questions(self) -> None:
        '''

        Unity tests for all questions

        Generates all questions, give right and wrong answers and corrects.

        '''
        logger.info('Starting sanity checks (may take a while...)')

        errors: int = 0
        for qref in self.factory:
            logger.debug('checking %s...', qref)

            try:

                question = self.factory[qref].generate()

            except QuestionException as exc:
                logger.error(exc)
                errors += 1
                continue  # to next question

            if 'tests_right' in question:
                for right_answer in question['tests_right']:
                    question['answer'] = right_answer
                    question.correct()
                    if question['grade'] < 1.0:

                        logger.error('Failed right answer in "%s".', qref)

                        errors += 1

                        continue  # to next test
            elif question['type'] == 'textarea':

                msg = f'- consider adding tests to {question["ref"]}'

                logger.warning(msg)

            if 'tests_wrong' in question:

                for wrong_answer in question['tests_wrong']:
                    question['answer'] = wrong_answer

                    question.correct()
                    if question['grade'] >= 1.0:
                        logger.error('Failed wrong answer in "%s".', qref)
                        errors += 1

                        continue  # to next test

        if errors > 0:
            logger.error('%6d error(s) found.', errors)  # {errors:>6}
            raise LearnException('Sanity checks')
        logger.info('     0 errors found.')

    # ------------------------------------------------------------------------

    async def login(self, uid: str, password: str) -> bool:
        '''user login'''

        with self._db_session() as sess:
            found = sess.query(Student.name, Student.password) \

                        .filter_by(id=uid) \

                        .one_or_none()

        # wait random time to minimize timing attacks

        await asyncio.sleep(random())

        loop = asyncio.get_running_loop()

        if found is None:

            logger.info('User "%s" does not exist', uid)

            await loop.run_in_executor(None, bcrypt.hashpw, b'',
                                       bcrypt.gensalt())  # just spend time
            return False

        name, hashed_pw = found

        pw_ok: bool = await loop.run_in_executor(None,

                                                 bcrypt.checkpw,
                                                 password.encode('utf-8'),

                                                 hashed_pw)

        if pw_ok:
            if uid in self.online:

                logger.warning('User "%s" already logged in', uid)

                counter = self.online[uid]['counter']
            else:
                logger.info('User "%s" logged in', uid)

                counter = 0

            # get topics of this student and set its current state
            with self._db_session() as sess:

                student_topics = sess.query(StudentTopic) \

                                     .filter_by(student_id=uid)

            state = {t.topic_id: {

                'level': t.level,

                'date': datetime.strptime(t.date, "%Y-%m-%d %H:%M:%S.%f")

                } for t in student_topics}

            self.online[uid] = {

                'number': uid,
                'name': name,
                'state': StudentState(uid=uid, state=state,
                                      courses=self.courses, deps=self.deps,
                                      factory=self.factory),
                'counter': counter + 1,  # counts simultaneous logins

                }

        else:

            logger.info('User "%s" wrong password', uid)

        return pw_ok

    # ------------------------------------------------------------------------
    def logout(self, uid: str) -> None:
        '''User logout'''
        del self.online[uid]
        logger.info('User "%s" logged out', uid)

    # ------------------------------------------------------------------------

    async def change_password(self, uid: str, password: str) -> bool:

        '''
        Change user Password.

        Returns True if password is successfully changed

        '''
        if not password:
            return False

        loop = asyncio.get_running_loop()

        password = await loop.run_in_executor(None,

                                              bcrypt.hashpw,

                                              password.encode('utf-8'),
                                              bcrypt.gensalt())

        with self._db_session() as sess:
            user = sess.query(Student).get(uid)
            user.password = password

        logger.info('User "%s" changed password', uid)

        return True

    # ------------------------------------------------------------------------
    async def check_answer(self, uid: str, answer) -> Question:
        '''
        Checks answer and update database.
        Returns corrected question.
        '''
        student = self.online[uid]['state']

        await student.check_answer(answer)

        topic_id = student.get_current_topic()

        question: Question = student.get_current_question()

        grade = question["grade"]
        ref = question["ref"]

        logger.info('User "%s" got %.2f in "%s"', uid, grade, ref)

        # always save grade of answered question

        with self._db_session() as sess:

            sess.add(Answer(ref=ref,

                            grade=grade,
                            starttime=str(question['start_time']),
                            finishtime=str(question['finish_time']),
                            student_id=uid,
                            topic_id=topic_id))

        return question

    # ------------------------------------------------------------------------
    async def get_question(self, uid: str) -> Optional[Question]:

        '''
        Get the question to show (current or new one)
        If no more questions, save/update level in database
        '''

        student = self.online[uid]['state']

        question: Optional[Question] = await student.get_question()

        # save topic to database if finished
        if student.topic_has_finished():
            topic: str = student.get_previous_topic()

            level: float = student.get_topic_level(topic)

            date: str = str(student.get_topic_date(topic))
            logger.info('User "%s" finished "%s" (level=%.2f)',
                        uid, topic, level)

            with self._db_session() as sess:

                student_topic = sess.query(StudentTopic) \
                                    .filter_by(student_id=uid, topic_id=topic)\

                                    .one_or_none()

                if student_topic is None:

                    # insert new studenttopic into database

                    logger.debug('db insert studenttopic')
                    tid = sess.query(Topic).get(topic)

                    uid = sess.query(Student).get(uid)

                    # association object

                    student_topic = StudentTopic(level=level, date=date,

                                                 topic=tid, student=uid)

                    uid.topics.append(student_topic)
                else:
                    # update studenttopic in database

                    logger.debug('db update studenttopic to level %f', level)

                    student_topic.level = level
                    student_topic.date = date

                sess.add(student_topic)

        return question

    # ------------------------------------------------------------------------

    def start_course(self, uid: str, course_id: str) -> None:
        '''Start course'''

        student = self.online[uid]['state']

        try:

            student.start_course(course_id)

        except Exception as exc:
            logger.warning('"%s" could not start course "%s"', uid, course_id)
            raise LearnException() from exc

        else:

            logger.info('User "%s" started course "%s"', uid, course_id)

    # ------------------------------------------------------------------------
    #
    # ------------------------------------------------------------------------
    async def start_topic(self, uid: str, topic: str) -> None:
        '''Start new topic'''

        student = self.online[uid]['state']
        # if uid == '0':
        #     logger.warning('Reloading "%s"', topic)  # FIXME should be an option
        #     self.factory.update(self._factory_for(topic))

        try:

            await student.start_topic(topic)
        except Exception as exc:
            logger.warning('User "%s" could not start "%s": %s',
                           uid, topic, str(exc))
        else:
            logger.info('User "%s" started topic "%s"', uid, topic)

    # ------------------------------------------------------------------------
    #
    # ------------------------------------------------------------------------

    def _add_missing_topics(self, topics: List[str]) -> None:

        '''
        Fill db table 'Topic' with topics from the graph, if new

        '''

        with self._db_session() as sess:
            new = [Topic(id=t) for t in topics
                   if (t,) not in sess.query(Topic.id)]

            if new:
                sess.add_all(new)
                logger.info('Added %d new topic(s) to the database', len(new))

    # ------------------------------------------------------------------------
    def _db_setup(self, database: str) -> None:

        '''setup and check database contents'''

        logger.info('Checking database "%s":', database)
        if not exists(database):

            raise LearnException('Database does not exist. '

                                 'Use "initdb-aprendizations" to create')

        engine = sa.create_engine(f'sqlite:///{database}', echo=False)
        self.Session = sa.orm.sessionmaker(bind=engine)
        try:
            with self._db_session() as sess:
                count_students: int = sess.query(Student).count()
                count_topics: int = sess.query(Topic).count()
                count_answers: int = sess.query(Answer).count()
        except Exception as exc:
            logger.error('Database "%s" not usable!', database)

            raise DatabaseUnusableError() from exc

        else:

            logger.info('%6d students', count_students)
            logger.info('%6d topics', count_topics)

            logger.info('%6d answers', count_answers)

    # ------------------------------------------------------------------------
    def _populate_graph(self, config: Dict[str, Any]) -> None:
        '''
        Populates a digraph.

        Nodes are the topic references e.g. 'my/topic'
          g.nodes['my/topic']['name']      name of the topic

          g.nodes['my/topic']['questions'] list of question refs

        Edges are obtained from the deps defined in the YAML file for each topic.

        '''

        defaults = {

            'type': 'topic',  # chapter

            'file': 'questions.yaml',
            'shuffle_questions': True,

            'choose': 99,

            'forgetting_factor': 1.0,  # no forgetting

            'max_tries': 1,            # in every question

            'append_wrong': True,

            'min_level': 0.01,         # to unlock topic

        }
        defaults.update(config.get('defaults', {}))

        # iterate over topics and populate graph

        topics: Dict[str, Dict] = config.get('topics', {})

        self.deps.add_nodes_from(topics.keys())

        for tref, attr in topics.items():

            logger.debug('       + %s', tref)
            for dep in attr.get('deps', []):
                self.deps.add_edge(dep, tref)

            topic = self.deps.nodes[tref]  # get current topic node
            topic['name'] = attr.get('name', tref)

            topic['questions'] = attr.get('questions', [])  # FIXME unused??

            for k, default in defaults.items():

                topic[k] = attr.get(k, default)

            # prefix/topic

            topic['path'] = join(self.deps.graph['prefix'], tref)

    # ========================================================================
    # methods that do not change state (pure functions)
    # ========================================================================

    # ------------------------------------------------------------------------

    def _make_factory(self) -> Dict[str, QFactory]:

        '''

        Buils dictionary of question factories

          - visits each topic in the graph,
          - adds factory for each topic.
        '''

        logger.info('Building questions factory:')

        factory = dict()
        for tref in self.deps.nodes():

            factory.update(self._factory_for(tref))

        logger.info('Factory has %s questions', len(factory))
        return factory

    # ------------------------------------------------------------------------
    # makes factory for a single topic
    # ------------------------------------------------------------------------
    def _factory_for(self, tref: str) -> Dict[str, QFactory]:

        factory: Dict[str, QFactory] = dict()
        topic = self.deps.nodes[tref]  # get node

        # load questions as list of dicts

        try:
            fullpath: str = join(topic['path'], topic['file'])
        except Exception as exc:
            msg = f'Invalid topic "{tref}". Check dependencies of: ' + \
                    ', '.join(self.deps.successors(tref))
            logger.error(msg)
            raise LearnException(msg) from exc

        logger.debug('  Loading %s', fullpath)
        try:

            questions: List[QDict] = load_yaml(fullpath)

        except Exception as exc:
            if topic['type'] == 'chapter':

                return factory  # chapters may have no "questions"

            msg = f'Failed to load "{fullpath}"'

            logger.error(msg)

            raise LearnException(msg) from exc

        if not isinstance(questions, list):

            msg = f'File "{fullpath}" must be a list of questions'

            logger.error(msg)

            raise LearnException(msg)

        # update refs to include topic as prefix.

        # refs are required to be unique only within the file.

        # undefined are set to topic:n, where n is the question number

        # within the file
        localrefs: Set[str] = set()  # refs in current file
        for i, question in enumerate(questions):
            qref = question.get('ref', str(i))  # ref or number

            if qref in localrefs:

                msg = f'Duplicate ref "{qref}" in "{topic["path"]}"'

                raise LearnException(msg)

            localrefs.add(qref)

            question['ref'] = f'{tref}:{qref}'

            question['path'] = topic['path']

            question.setdefault('append_wrong', topic['append_wrong'])

        # if questions are left undefined, include all.

        if not topic['questions']:

            topic['questions'] = [q['ref'] for q in questions]

        topic['choose'] = min(topic['choose'], len(topic['questions']))

        for question in questions:
            if question['ref'] in topic['questions']:

                factory[question['ref']] = QFactory(question)

                logger.debug('       + %s', question["ref"])

        logger.info('%6d questions in %s', len(topic["questions"]), tref)

        return factory

    # ------------------------------------------------------------------------

    def get_login_counter(self, uid: str) -> int:

        '''login counter''' # FIXME

        return int(self.online[uid]['counter'])

    # ------------------------------------------------------------------------

    def get_student_name(self, uid: str) -> str:

        '''Get the username'''

        return self.online[uid].get('name', '')

    # ------------------------------------------------------------------------

    def get_student_state(self, uid: str) -> List[Dict[str, Any]]:
        '''Get the knowledge state of a given user'''

        return self.online[uid]['state'].get_knowledge_state()

    # ------------------------------------------------------------------------

    def get_student_progress(self, uid: str) -> float:

        '''Get the current topic progress of a given user'''

        return float(self.online[uid]['state'].get_topic_progress())

    # ------------------------------------------------------------------------
    def get_current_question(self, uid: str) -> Optional[Question]:

        '''Get the current question of a given user'''
        question: Optional[Question] = self.online[uid]['state'].get_current_question()

        return question

    # ------------------------------------------------------------------------

    def get_current_question_id(self, uid: str) -> str:

        '''Get id of the current question for a given user'''
        return str(self.online[uid]['state'].get_current_question()['qid'])

    # ------------------------------------------------------------------------
    def get_student_question_type(self, uid: str) -> str:
        '''Get type of the current question for a given user'''

        return str(self.online[uid]['state'].get_current_question()['type'])

    # ------------------------------------------------------------------------

    # def get_student_topic(self, uid: str) -> str:

    #     return str(self.online[uid]['state'].get_current_topic())

    # ------------------------------------------------------------------------
    def get_student_course_title(self, uid: str) -> str:

        '''get the title of the current course for a given user'''
        return str(self.online[uid]['state'].get_current_course_title())

    # ------------------------------------------------------------------------
    def get_current_course_id(self, uid: str) -> Optional[str]:
        '''get the current course (id) of a given user'''

        cid: Optional[str] = self.online[uid]['state'].get_current_course_id()
        return cid

    # ------------------------------------------------------------------------

    # def get_topic_name(self, ref: str) -> str:

    #     return str(self.deps.nodes[ref]['name'])

    # ------------------------------------------------------------------------
    def get_current_public_dir(self, uid: str) -> str:
        '''
        Get the path for the 'public' directory of the current topic of the
        given user.

        E.g. if the user has the active topic 'xpto',

        then returns 'path/to/xpto/public'.
        '''
        topic: str = self.online[uid]['state'].get_current_topic()
        prefix: str = self.deps.graph['prefix']
        return join(prefix, topic, 'public')

    # ------------------------------------------------------------------------

    def get_courses(self) -> Dict[str, Dict[str, Any]]:

        '''
        Get dictionary with all courses {'course1': {...}, 'course2': {...}}

        '''

        return self.courses

    # ------------------------------------------------------------------------

    def get_course(self, course_id: str) -> Dict[str, Any]:

        '''
        Get dictionary {'title': ..., 'description':..., 'goals':...}
        '''

        return self.courses[course_id]

    # ------------------------------------------------------------------------

    def get_rankings(self, uid: str, course_id: str) -> Iterable[Tuple[str, str, float, float]]:

        '''
        Returns rankings for a certain course_id.

        User where uid have <=2 chars are considered ghosts are hidden from

        the rankings. This is so that there can be users for development or

        testing purposes, which are not real users.
        The user_id of real students must have >2 chars.
        '''