from webob.dec import wsgify
from webob.exc import *
from webob import Response

import anki
from anki.facts import Fact
from anki.models import Model, CardModel, FieldModel

from threading import Thread
from Queue import Queue

try:
    import simplejson as json
except ImportError:
    import json

import os, errno, time, logging

__all__ = ['DeckThread']

def ExternalModel():
    m = Model(u'External')
    # we can only guarantee that the Front will be unique because it will
    # be based on the headword, language, pos.  The Back could be anything!
    m.addFieldModel(FieldModel(u'Front', True, True))
    # while I think that Back should be required, I don't really want this to
    # fail just because of that!!
    m.addFieldModel(FieldModel(u'Back', False, False))
    m.addFieldModel(FieldModel(u'External ID', True, True))

    front = u'<span style="font-family: Arial; font-size: 20px; color: #000000; white-space: pre-wrap;">{{{Front}}}</span>'
    back = u'<span style="font-family: Arial; font-size: 20px; color: #000000; white-space: pre-wrap;">{{{Back}}}</span>'
    m.addCardModel(CardModel(u'Forward', front, back))
    m.addCardModel(CardModel(u'Reverse', back, front))

    m.tags = u"External"
    return m

class DeckWrapper(object):
    def __init__(self, path):
        self.path = os.path.abspath(path)
        self._deck = None

    def _create_deck(self):
        # mkdir -p the path, because it might not exist
        dir = os.path.dirname(self.path)
        try:
            os.makedirs(dir)
        except OSError, exc:
            if exc.errno == errno.EEXIST:
                pass
            else:
                raise

        deck = anki.DeckStorage.Deck(self.path)
        try:
            deck.initUndo()
            deck.addModel(ExternalModel())
            deck.save()
        except Exception, e:
            deck.close()
            deck = None
            raise e

        return deck

    def open(self):
        if self._deck is None:
            if os.path.exists(self.path):
                self._deck = anki.DeckStorage.Deck(self.path)
            else:
                self._deck = self._create_deck()
        return self._deck

    def close(self):
        if self._deck is None:
            return

        self._deck.close()
        self._deck = None

        # delete the cache for 'External ID' on this deck
        if hasattr(self, '_external_field_id'):
            delattr(self, '_external_field_id')

    def opened(self):
        return self._deck is not None

    @property
    def external_field_id(self):
        if not hasattr(self, '_external_field_id'):
            # find a field model id for a field named "External ID"
            deck = self.open()
            self._external_field_id = deck.s.scalar("SELECT id FROM fieldModels WHERE name = :name", name=u'External ID')
        if self._external_field_id is None:
            raise HTTPBadRequest("No field model named 'External ID'")
        return self._external_field_id

    def find_fact(self, external_id):
        deck = self.open()
        return deck.s.scalar("""
            SELECT factId FROM fields WHERE fieldModelId = :fieldModelId AND
                value = :externalId""", fieldModelId=self.external_field_id, externalId=external_id)

class DeckThread(object):
    def __init__(self, path):
        self.path = os.path.abspath(path)
        self.wrapper = DeckWrapper(path)

        self._queue = Queue()
        self._thread = None
        self._running = False
        self.last_timestamp = time.time()

    @property
    def running(self):
        return self._running

    def qempty(self):
        return self._queue.empty()

    def current(self):
        from threading import current_thread
        return current_thread() == self._thread

    def execute(self, func, args=[], kw={}, waitForReturn=True):
        """ Executes a given function on this thread with the *args and **kw.

        If 'waitForReturn' is True, then it will block until the function has
        executed and return its return value.  If False, it will return None
        immediately and the function will be executed sometime later.
        """

        if waitForReturn:
            return_queue = Queue()
        else:
            return_queue = None

        self._queue.put((func, args, kw, return_queue))

        if return_queue is not None:
            ret = return_queue.get(True)
            if isinstance(ret, Exception):
                raise ret
            return ret

    def _run(self):
        logging.info('DeckThread[%s]: Starting...', self.path)

        try:
            while self._running:
                func, args, kw, return_queue = self._queue.get(True)

                logging.info('DeckThread[%s]: Running %s(*%s, **%s)', self.path, func.func_name, repr(args), repr(kw))
                self.last_timestamp = time.time()

                try:
                    ret = func(*args, **kw)
                except Exception, e:
                    logging.error('DeckThread[%s]: Unable to %s(*%s, **%s): %s',
                        self.path, func.func_name, repr(args), repr(kw), e, exc_info=True)
                    # we return the Exception which will be raise'd on the other end
                    ret = e

                if return_queue is not None:
                    return_queue.put(ret)
        except Exception, e:
            logging.error('DeckThread[%s]: Thread crashed! Exception: %s', e, exc_info=True)
        finally:
            self.wrapper.close()
            # clean out old thread object
            self._thread = None
            # in case we got here via an exception
            self._running = False

            logging.info('DeckThread[%s]: Stopped!' % self.path)

    def start(self):
        if not self._running:
            self._running = True
            assert self._thread is None
            self._thread = Thread(target=self._run)
            self._thread.start()

    def stop(self):
        def _stop():
            self._running = False
        self.execute(_stop, waitForReturn=False)

    def stop_and_wait(self):
        """ Tell the thread to stop and wait for it to happen. """
        self.stop()
        if self._thread is not None:
            self._thread.join()

class DeckThreadPool(object):
    def __init__(self):
        self.threads = {}

        self.monitor_frequency = 15
        self.monitor_inactivity = 90

        monitor = Thread(target=self._monitor_run)
        monitor.daemon = True
        monitor.start()
        self._monitor_thread = monitor

    # TODO: it would be awesome to have a safe way to stop inactive threads completely!
    def _monitor_run(self):
        """ Monitors threads for inactivity and closes the deck on them
        (leaves the thread itself running -- hopefully waiting peacefully with only a
        small memory footprint!) """
        while True:
            cur = time.time()
            for path, thread in self.threads.items():
                if thread.running and thread.wrapper.opened() and thread.qempty() and cur - thread.last_timestamp >= self.monitor_inactivity:
                    logging.info('Monitor is closing deck on inactive DeckThread[%s]' % thread.path)
                    def closeDeck(wrapper):
                        wrapper.close()
                    thread.execute(closeDeck, [thread.wrapper], waitForReturn=False)
            time.sleep(self.monitor_frequency)

    def start(self, path):
        path = os.path.abspath(path)

        try:
            thread = self.threads[path]
        except KeyError:
            thread = self.threads[path] = DeckThread(path)

        thread.start()

        return thread

    def shutdown(self):
        for thread in self.threads.values():
            thread.stop()
        self.threads = {}

thread_pool = DeckThreadPool()

#def defer(*func, **opts):
#    def decorator(func):
#        def newFunc(*args, **kw):
#            (self, thread) = args[0:2]
#            if thread.current():
#                ret = func(*args, **kw)
#                # don't return 'ret' if this isn't a wait function, to keep the API
#                # consistent even when inside the thread itself (hopefully, help
#                # avoid weird problems in the future)
#                if opts.get('waitForReturn', True):
#                    return ret
#            else:
#                return thread.execute(func, args, kw, **opts)
#        newFunc.func_name = func.func_name
#        return newFunc
#
#    if len(func) == 1:
#        return decorator(func[0])
#    elif len(func) > 1:
#        raise TypeError
#
#    return decorator

def opts(**opts):
    def dec(func):
        func.opts = opts
        return func
    return dec

class DeckAppHandler(object):
    def __init__(self, wrapper):
        self.wrapper = wrapper

    def _output_fact(self, fact):
        res = dict(zip(fact.keys(), fact.values()))
        res['id'] = str(fact.id)
        return res

    def _output_card(self, card):
        return {
            'id': card.id,
            'question': card.question,
            'answer': card.answer,
        }

    @opts(waitForReturn=False)
    def setup(self):
        # will create the deck if it doesn't exist
        self.wrapper.open()

    @opts(waitForReturn=False)
    def add_fact(self, fields):
        fact_id = self.wrapper.find_fact(fields['External ID'])
        if fact_id is not None:
            fields['id'] = fact_id
            self.save_fact(fields)
        else:
            deck = self.wrapper.open()
            fact = deck.newFact()
            for key in fact.keys():
                fact[key] = unicode(fields[key])

            deck.addFact(fact)
            deck.save()

    @opts(waitForReturn=False)
    def save_fact(self, fact):
        deck = self.wrapper.open()
        newFact = deck.s.query(Fact).get(int(fact['id']))
        for key in newFact.keys():
            newFact[key] = fact[key]

        newFact.setModified(textChanged=True, deck=deck)
        deck.setModified()
        deck.save()

    def find_fact(self, external_id):
        factId = self.wrapper.find_fact(external_id)
        if not factId:
            # we need to signal somehow to the calling application that no such
            # deck exists, but without it being considered a "bad error".  404 is 
            # inappropriate that refers to the resource (ie. /find_fact) which is
            # here obviously.
            return None

        deck = self.wrapper.open()
        fact = deck.s.query(Fact).get(factId)
        return self._output_fact(fact)

    @opts(waitForReturn=False)
    def delete_fact(self, fact_id=None, external_id=None):
        if fact_id is None and external_id is not None:
            fact_id = self.wrapper.find_fact(external_id)
        if fact_id is not None:
            deck = self.wrapper.open()
            deck.deleteFact(int(fact_id))
            deck.save()

    def resync_facts(self, external_ids):
        from anki.facts import fieldsTable
        from sqlalchemy.sql import select, and_, not_

        deck = self.wrapper.open()

        # remove extra cards
        selectExtra = select([fieldsTable.c.factId],
            and_(
                fieldsTable.c.fieldModelId == self.wrapper.external_field_id,
                not_(fieldsTable.c.value.in_(external_ids))
            )
        )
        for factId, in deck.s.execute(selectExtra).fetchall():
            deck.deleteFact(factId)
        deck.save()

        # find ids that should be on this deck but which aren't
        missing_ids = []
        for external_id in external_ids:
            if self.wrapper.find_fact(external_id) is None:
                missing_ids.append(external_id)

        return {'missing':missing_ids}

    def get_card(self):
        deck = self.wrapper.open()
        card = deck.getCard()
        if card:
            # grab the interval strings
            intervals = []
            for i in range(1, 5):
                intervals.append(deck.nextIntervalStr(card, i))

            card = self._output_card(card)
            card['intervals'] = intervals
            card['finished'] = False
        else:
            # copied from Deck.nextDueMsg() in libanki/anki/deck.py
            newCount = deck.newCardsDueBy(deck.dueCutoff + 86400)
            newCardsTomorrow = min(newCount, deck.newCardsPerDay)
            cards = deck.cardsDueBy(deck.dueCutoff + 86400)

            card = {
                'finished': True,
                'new_count': newCardsTomorrow,
                'reviews_count': cards
            }

            # TODO: clean up a bit, now that we've finished this review

        return card

    @opts(waitForReturn=False)
    def setup_scheduler(self, name):
        deck = self.wrapper.open()
        if name == 'standard':
            deck.setupStandardScheduler()
        elif name == 'reviewEarly':
            deck.setupReviewEarlyScheduler()
        elif name == 'learnMore':
            deck.setupLearnMoreScheduler()
        deck.refreshSession()
        deck.reset()

    def get_options(self):
        deck = self.wrapper.open()

        return {
            'new_cards': {
                'cards_per_day': deck.newCardsPerDay,
                'order': deck.newCardOrder,
                'spacing': deck.newCardSpacing,
            },
            'reviews': {
                'failed_card_max': deck.failedCardMax,
                'order': deck.revCardOrder,
                'failed_policy': deck.getFailedCardPolicy(),
            }
        }

    @opts(waitForReturn=False)
    def set_options(self, study_options):
        deck = self.wrapper.open()

        # new card options
        deck.newCardsPerDay = int(study_options['new_cards']['cards_per_day'])
        deck.newCardOrder = int(study_options['new_cards']['order'])
        if deck.newCardOrder == anki.deck.NEW_CARDS_RANDOM:
            deck.randomizeNewCards()
        deck.newCardSpacing = int(study_options['new_cards']['spacing'])

        # reviews options
        deck.setFailedCardPolicy(int(study_options['reviews']['failed_policy']))
        deck.failedCardMax = int(study_options['reviews']['failed_card_max'])
        deck.revCardOrder = int(study_options['reviews']['order'])

        deck.flushMod()
        deck.reset()
        deck.save()

    def answer_card(self, card_id, ease):
        ease = int(ease)
        deck = self.wrapper.open()
        card = deck.cardFromId(card_id)
        if card:
            try:
                deck.answerCard(card, ease)
            except:
                import sys, traceback
                exc_info = sys.exc_info()
                print exc_info[1]
                print traceback.print_tb(exc_info[2])
                return False
            deck.save()
        return True

class DeckApp(object):
    """ Our WSGI app. """

    direct_operations = ['add_fact', 'save_fact', 'find_fact', 'delete_fact', 'resync_facts',
        'get_card', 'answer_card']

    def __init__(self, data_root, allowed_hosts):
        self.data_root = os.path.abspath(data_root)
        self.allowed_hosts = allowed_hosts

    def _get_path(self, path):
        npath = os.path.normpath(os.path.join(self.data_root, path))
        if npath[0:len(self.data_root)] != self.data_root:
            # attempting to escape our data jail!
            raise HTTPBadRequest('"%s" is not a valid path/id' % path)
        return npath

    @wsgify
    def __call__(self, req):
        global thread_pool

        if self.allowed_hosts != '*':
            try:
                remote_addr = req.headers['X-Forwarded-For']
            except KeyError:
                remote_addr = req.remote_addr
            if remote_addr != self.allowed_hosts:
                raise HTTPForbidden()

        if req.method != 'POST':
            raise HTTPMethodNotAllowed(allow=['POST'])

        # get the deck and function to call from the path
        func = req.path
        if func[0] == '/':
            func = func[1:]
        parts = func.split('/')
        path = '/'.join(parts[:-1])
        func = parts[-1]
        if func[0] == '_' or not hasattr(DeckAppHandler, func) or not callable(getattr(DeckAppHandler, func)):
            raise HTTPNotFound()
        thread = thread_pool.start(self._get_path(path))
        handler = DeckAppHandler(thread.wrapper)
        func = getattr(handler, func)
        try:
            opts = func.opts
        except AttributeError:
            opts = {}

        try:
            input = json.loads(req.body)
        except ValueError, e:
            logging.error(req.path+': Unable to parse JSON: '+str(e), exc_info=True)
            raise HTTPBadRequest()
        # make the keys into non-unicode strings
        input = dict([(str(k), v) for k, v in input.items()])

        # debug
        from pprint import pprint
        pprint(input)

        # run it!
        try:
            output = thread.execute(func, [], input, **opts)
        except Exception, e:
            logging.error(e)
            return HTTPInternalServerError()

        if output is None:
            return Response('', content_type='text/plain')
        else:
            return Response(json.dumps(output), content_type='application/json')

# Our entry point
def make_app(global_conf, **local_conf):
    # setup the logger
    logging_config_file = local_conf.get('logging.config_file')
    if logging_config_file:
        # monkey patch the logging.config.SMTPHandler if necessary
        import sys
        if sys.version_info[0] == 2 and sys.version_info[1] == 5:
            import AnkiServer.logpatch

        # load the config file
        import logging.config
        logging.config.fileConfig(logging_config_file)

    return DeckApp(
        data_root=local_conf.get('data_root', '.'),
        allowed_hosts=local_conf.get('allowed_hosts', '*')
    )