#!/usr/bin/env python3

'''
Handles the web, http & html part of the application interface.
Uses the tornadoweb framework.
'''


# python standard library
import base64
import functools
import json
import logging.config
import mimetypes
from os import path
import re
import signal
import sys
from timeit import default_timer as timer
import uuid

# user installed libraries
import tornado.ioloop
import tornado.web
# import tornado.websocket
import tornado.httpserver

# this project
from perguntations.parser_markdown import md_to_html


# ----------------------------------------------------------------------------
class WebApplication(tornado.web.Application):
    '''
    Web Application. Routes to handler classes.
    '''
    def __init__(self, testapp, debug=False):
        handlers = [
            (r'/login', LoginHandler),
            (r'/logout', LogoutHandler),
            (r'/review', ReviewHandler),
            (r'/admin', AdminHandler),
            (r'/file', FileHandler),
            # (r'/root', MainHandler),
            # (r'/ws', AdminSocketHandler),
            (r'/adminwebservice', AdminWebservice),
            (r'/studentwebservice', StudentWebservice),
            (r'/', RootHandler),
        ]

        settings = {
            'template_path': path.join(path.dirname(__file__), 'templates'),
            'static_path':   path.join(path.dirname(__file__), 'static'),
            'static_url_prefix': '/static/',
            'xsrf_cookies': True,
            'cookie_secret': base64.b64encode(uuid.uuid4().bytes),
            'login_url': '/login',
            'debug': debug,
        }
        super().__init__(handlers, **settings)
        self.testapp = testapp


# ----------------------------------------------------------------------------
def admin_only(func):
    '''
    Decorator used to restrict access to the administrator.
    Example:

        @admin_only
        def get(self): ...
    '''
    @functools.wraps(func)
    async def wrapper(self, *args, **kwargs):
        if self.current_user != '0':
            raise tornado.web.HTTPError(403)  # forbidden
        await func(self, *args, **kwargs)
    return wrapper


# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class BaseHandler(tornado.web.RequestHandler):
    '''
    Handlers should inherit this one instead of tornado.web.RequestHandler.
    It automatically gets the user cookie, which is required to identify the
    user in most handlers.
    '''

    @property
    def testapp(self):
        '''simplifies access to the application a little bit'''
        return self.application.testapp

    def get_current_user(self):
        '''
        Since HTTP is stateless, a cookie is used to identify the user.
        This function returns the cookie for the current user.
        '''
        cookie = self.get_secure_cookie('perguntations_user')
        if cookie:
            return cookie.decode('utf-8')
        return None


# ----------------------------------------------------------------------------
# class MainHandler(BaseHandler):

#     @tornado.web.authenticated
#     @admin_only
#     def get(self):
#         self.render("admin-ws.html", students=self.testapp.get_students_state())


# # ----------------------------------------------------------------------------
# class AdminSocketHandler(tornado.websocket.WebSocketHandler):
#     waiters = set()
#     # cache = []

#     # def get_compression_options(self):
#     #     return {}   # Non-None enables compression with default options.

#     # called when opening connection
#     def open(self):
#         logging.debug('[AdminSocketHandler.open]')
#         AdminSocketHandler.waiters.add(self)

#     # called when closing connection
#     def on_close(self):
#         logging.debug('[AdminSocketHandler.on_close]')
#         AdminSocketHandler.waiters.remove(self)

#     # @classmethod
#     # def update_cache(cls, chat):
#     #     logging.debug(f'[AdminSocketHandler.update_cache] "{chat}"')
#     #     cls.cache.append(chat)

#     # @classmethod
#     # def send_updates(cls, chat):
#     #     logging.info("sending message to %d waiters", len(cls.waiters))
#     #     for waiter in cls.waiters:
#     #         try:
#     #             waiter.write_message(chat)
#     #         except Exception:
#     #             logging.error("Error sending message", exc_info=True)

#     # handle incomming messages
#     def on_message(self, message):
#         logging.info(f"[AdminSocketHandler.onmessage] got message {message}")
#         parsed = tornado.escape.json_decode(message)
#         print(parsed)
#         chat = {"id": str(uuid.uuid4()), "body": parsed["body"]}
#         print(chat)
#         chat["html"] = tornado.escape.to_basestring(
#             '<div>' + chat['body'] + '</div>'
#             # self.render_string("message.html", message=chat)
#         )
#         print(chat)

#         AdminSocketHandler.update_cache(chat)  # store msgs
#         AdminSocketHandler.send_updates(chat)  # send to clients

# ----------------------------------------------------------------------------
# Test shown to students
# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class RootHandler(BaseHandler):
    '''
    Generates test to student.
    Receives answers, corrects the test and sends back the grade.
    Redirects user 0 to /admin.
    '''

    _templates = {
        # -- question templates --
        'radio':        'question-radio.html',
        'checkbox':     'question-checkbox.html',
        'text':         'question-text.html',
        'text-regex':   'question-text.html',
        'numeric-interval': 'question-text.html',
        'textarea':     'question-textarea.html',
        # -- information panels --
        'information':  'question-information.html',
        'success':      'question-information.html',
        'warning':      'question-information.html',
        'alert':        'question-information.html',
    }

    # --- GET
    @tornado.web.authenticated
    async def get(self):
        '''
        Sends test to student or redirects 0 to admin page
        '''

        uid = self.current_user
        logging.info('"%s" GET /', uid)
        if uid == '0':
            self.redirect('/admin')

        test = self.testapp.get_student_test(uid)  # reloading returns same test
        if test is None:
            test = await self.testapp.generate_test(uid)

        self.render('test.html', t=test, md=md_to_html, templ=self._templates)


    # --- POST
    @tornado.web.authenticated
    async def post(self):
        '''
        Receives answers, fixes some html weirdness, corrects test and
        sends back the grade.

        self.request.arguments = {'answered-0': [b'on'], '0': [b'13.45']}
        builds dictionary ans={0: 'answer0', 1:, 'answer1', ...}
        unanswered questions not included.
        '''
        timeit_start = timer()  # performance timer

        uid = self.current_user
        logging.debug('"%s" POST /', uid)

        try:
            test = self.testapp.get_student_test(uid)
        except KeyError as exc:
            logging.warning('"%s" POST / raised 403 Forbidden', uid)
            raise tornado.web.HTTPError(403) from exc # Forbidden

        ans = {}
        for i, question in enumerate(test['questions']):
            qid = str(i)
            if 'answered-' + qid in self.request.arguments:
                ans[i] = self.get_body_arguments(qid)
                # print(i, ans[i])

                # remove enclosing list in some question types
                if question['type'] == 'radio':
                    if not ans[i]:
                        ans[i] = None
                    else:
                        ans[i] = ans[i][0]
                elif question['type'] in ('text', 'text-regex', 'textarea',
                                          'numeric-interval'):
                    ans[i] = ans[i][0]

        # correct answered questions and logout
        await self.testapp.correct_test(uid, ans)

        # show final grade and grades of other tests in the database
        allgrades = self.testapp.get_student_grades_from_all_tests(uid)

        self.clear_cookie('perguntations_user')
        self.render('grade.html', t=test, allgrades=allgrades)
        self.testapp.logout(uid)

        timeit_finish = timer()
        logging.info('  correction took %fs', timeit_finish-timeit_start)

# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class LoginHandler(BaseHandler):
    '''Handles /login'''

    _prefix = re.compile(r'[a-z]')

    def get(self):
        '''Render login page.'''
        self.render('login.html', error='')

    async def post(self):
        '''Authenticates student and login.'''
        uid = self._prefix.sub('', self.get_body_argument('uid'))
        password = self.get_body_argument('pw')
        login_ok = await self.testapp.login(uid, password)

        if login_ok:
            self.set_secure_cookie('perguntations_user', str(uid), expires_days=1)
            self.redirect('/')
        else:
            self.render('login.html', error='Não autorizado ou senha inválida')


# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class LogoutHandler(BaseHandler):
    '''Handle /logout'''

    @tornado.web.authenticated
    def get(self):
        '''Logs out a user.'''
        self.clear_cookie('perguntations_user')
        self.testapp.logout(self.current_user)
        self.redirect('/')

    def on_finish(self):
        self.testapp.logout(self.current_user)




# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class StudentWebservice(BaseHandler):
    '''
    Receive ajax from students in the test in response from focus, unfocus and
    resize events.
    '''

    @tornado.web.authenticated
    def post(self):
        '''handle ajax post'''
        uid = self.current_user
        cmd = self.get_body_argument('cmd', None)
        value = json.loads(self.get_body_argument('value', None))
        self.testapp.event_test(uid, cmd, value)


# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class AdminWebservice(BaseHandler):
    '''
    Receive ajax requests from admin
    '''

    @tornado.web.authenticated
    @admin_only
    async def get(self):
        '''admin webservices that do not change state'''
        cmd = self.get_query_argument('cmd')
        if cmd == 'testcsv':
            test_ref, data = self.testapp.get_test_csv()
            self.set_header('Content-Type', 'text/csv')
            self.set_header('content-Disposition',
                            f'attachment; filename={test_ref}.csv')
            self.write(data)
            await self.flush()

        if cmd == 'questionscsv':
            test_ref, data = self.testapp.get_questions_csv()
            self.set_header('Content-Type', 'text/csv')
            self.set_header('content-Disposition',
                            f'attachment; filename={test_ref}-detailed.csv')
            self.write(data)
            await self.flush()


# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class AdminHandler(BaseHandler):
    '''Handle /admin'''

    @tornado.web.authenticated
    @admin_only
    async def get(self):
        '''
        Admin page.
        '''
        cmd = self.get_query_argument('cmd', default=None)

        if cmd == 'students_table':
            data = {'data': self.testapp.get_students_state()}
            self.write(json.dumps(data, default=str))
        elif cmd == 'test':
            data = {
                'data': {
                    'title': self.testapp.testfactory['title'],
                    'ref': self.testapp.testfactory['ref'],
                    'filename': self.testapp.testfactory['testfile'],
                    'database': self.testapp.testfactory['database'],
                    'answers_dir': self.testapp.testfactory['answers_dir'],
                    }
                }
            self.write(json.dumps(data, default=str))
        else:
            self.render('admin.html')

    @tornado.web.authenticated
    @admin_only
    async def post(self):
        '''
        Executes commands from the admin page.
        '''
        cmd = self.get_body_argument('cmd', None)
        value = self.get_body_argument('value', None)

        if cmd == 'allow':
            self.testapp.allow_student(value)
        elif cmd == 'deny':
            self.testapp.deny_student(value)
        elif cmd == 'allow_all':
            self.testapp.allow_all_students()
        elif cmd == 'deny_all':
            self.testapp.deny_all_students()
        elif cmd == 'reset_password':
            await self.testapp.update_student_password(uid=value, password='')

        elif cmd == 'insert_student':
            student = json.loads(value)
            self.testapp.insert_new_student(uid=student['number'],
                                            name=student['name'])

        else:
            logging.error('Unknown command: "%s"', cmd)


# ----------------------------------------------------------------------------
# Serves files from the /public subdir of the topics.
# ----------------------------------------------------------------------------
# pylint: disable=abstract-method
class FileHandler(BaseHandler):
    '''
    Handles static files from questions like images, etc.
    '''


    @tornado.web.authenticated
    async def get(self):
        '''
        Returns requested file. Files are obtained from the 'public' directory
        of each question.
        '''

        uid = self.current_user
        ref = self.get_query_argument('ref', None)
        image = self.get_query_argument('image', None)
        content_type = mimetypes.guess_type(image)[0]

        if uid != '0':
            test = self.testapp.get_student_test(uid)
        else:
            logging.error('FIXME Cannot serve images for review.')
            raise tornado.web.HTTPError(404)  # FIXME admin

        if test is None:
            raise tornado.web.HTTPError(404)  # Not Found

        for question in test['questions']:
            # search for the question that contains the image
            if question['ref'] == ref:
                filepath = path.join(question['path'], 'public', image)
                try:
                    file = open(filepath, 'rb')
                except FileNotFoundError:
                    logging.error('File not found: %s', filepath)
                except PermissionError:
                    logging.error('No permission: %s', filepath)
                except OSError:
                    logging.error('Error opening file: %s', filepath)
                else:
                    data = file.read()
                    file.close()
                    self.set_header("Content-Type", content_type)
                    self.write(data)
                    await self.flush()
                break



# --- REVIEW -----------------------------------------------------------------
# pylint: disable=abstract-method
class ReviewHandler(BaseHandler):
    '''
    Show test for review
    '''

    _templates = {
        'radio':        'review-question-radio.html',
        'checkbox':     'review-question-checkbox.html',
        'text':         'review-question-text.html',
        'text-regex':   'review-question-text.html',
        'numeric-interval': 'review-question-text.html',
        'textarea':     'review-question-text.html',
        # -- information panels --
        'information':  'review-question-information.html',
        'success':      'review-question-information.html',
        'warning':      'review-question-information.html',
        'alert':        'review-question-information.html',
    }

    @tornado.web.authenticated
    @admin_only
    async def get(self):
        '''
        Opens JSON file with a given corrected test and renders it
        '''
        test_id = self.get_query_argument('test_id', None)
        logging.info('Review test %s.', test_id)
        fname = self.testapp.get_json_filename_of_test(test_id)

        if fname is None:
            raise tornado.web.HTTPError(404)  # Not Found

        try:
            with open(path.expanduser(fname)) as jsonfile:
                test = json.load(jsonfile)
        except OSError:
            msg = f'Cannot open "{fname}" for review.'
            logging.error(msg)
            raise tornado.web.HTTPError(status_code=404, reason=msg) from None
        except json.JSONDecodeError as exc:
            msg = f'JSON error in "{fname}": {exc}'
            logging.error(msg)
            raise tornado.web.HTTPError(status_code=404, reason=msg)

        self.render('review.html', t=test, md=md_to_html,
                    templ=self._templates)


# ----------------------------------------------------------------------------
def signal_handler(*_):
    '''
    Catches Ctrl-C and stops webserver
    '''
    reply = input(' --> Stop webserver? (yes/no) ')
    if reply.lower() == 'yes':
        tornado.ioloop.IOLoop.current().stop()
        logging.critical('Webserver stopped.')
        sys.exit(0)

# ----------------------------------------------------------------------------
def run_webserver(app, ssl_opt, port, debug):
    '''
    Starts and runs webserver until a SIGINT signal (Ctrl-C) is received.
    '''

    # --- create web application
    logging.info('-----------------------------------------------------------')
    logging.info('Starting WebApplication (tornado)')
    try:
        webapp = WebApplication(app, debug=debug)
    except Exception:
        logging.critical('Failed to start web application.')
        raise

    try:
        httpserver = tornado.httpserver.HTTPServer(webapp, ssl_options=ssl_opt)
    except ValueError:
        logging.critical('Certificates cert.pem, privkey.pem not found')
        sys.exit(1)

    try:
        httpserver.listen(port)
    except OSError:
        logging.critical('Cannot bind port %d. Already in use?', port)
        sys.exit(1)

    logging.info('Webserver listening on %d...  (Ctrl-C to stop)', port)
    signal.signal(signal.SIGINT, signal_handler)

    # --- run webserver
    try:
        tornado.ioloop.IOLoop.current().start()  # running...
    except Exception:
        logging.critical('Webserver stopped!')
        tornado.ioloop.IOLoop.current().stop()
        raise