#!/usr/bin/env python2

import logging
import sys
import importlib

import theano

from blocks.extensions import Printing, SimpleExtension, FinishAfter
from blocks.extensions.monitoring import DataStreamMonitoring, TrainingDataMonitoring

from blocks.graph import ComputationGraph
from blocks.main_loop import MainLoop
from blocks.model import Model
from blocks.algorithms import GradientDescent

try:
    from blocks.extras.extensions.plot import Plot
    plot_avail = False
except ImportError:
    plot_avail = False


import datastream
from paramsaveload import SaveLoadParams
from gentext import GenText
from ircext import IRCClientExt

logging.basicConfig(level='INFO')
logger = logging.getLogger(__name__)

sys.setrecursionlimit(500000)


class ResetStates(SimpleExtension):
    def __init__(self, state_vars, **kwargs):
        super(ResetStates, self).__init__(**kwargs)

        self.f = theano.function(
            inputs=[], outputs=[],
            updates=[(v, v.zeros_like()) for v in state_vars])

    def do(self, which_callback, *args):
        self.f()

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print >> sys.stderr, 'Usage: %s [options] config' % sys.argv[0]
        sys.exit(1)
    model_name = sys.argv[-1]
    config = importlib.import_module('%s' % model_name)


    # Build datastream
    train_stream = datastream.setup_datastream('data/logcompil.txt',
                                               config.num_seqs,
                                               config.seq_len,
                                               config.seq_div_size)

    # Build model
    m = config.Model()
    m.pred.name = 'pred'

    # Train the model
    saveloc = 'model_data/%s-%s' % (model_name, config.param_desc)
    train_model(m, train_stream, dump_path=saveloc)


    # Define the model
    model = Model(m.sgd_cost)

    # IRC mode : just load the parameters and run an IRC server
    if '--irc' in sys.argv:
        try:
            extensions.append(FinishAfter(before_training=True, after_n_batches=1))
            print "Initializing main loop"
            main_loop.run()
            print "Jumping into IRC"
            irc.run_forever()
        except KeyboardInterrupt:
            pass
        sys.exit(0)

    # Train the model

    cg = ComputationGraph(m.sgd_cost)
    algorithm = GradientDescent(cost=m.sgd_cost,
                                step_rule=config.step_rule,
                                parameters=cg.parameters)

    algorithm.add_updates(m.states)

    monitor_vars = [v for p in m.monitor_vars for v in p]
    extensions = [
            TrainingDataMonitoring(
                monitor_vars,
                prefix='train', every_n_epochs=1),
            Printing(every_n_epochs=1, after_epoch=False),

            ResetStates([v for v, _ in m.states], after_epoch=True)
    ]
    if plot_avail:
        plot_channels = [['train_' + v.name for v in p] for p in m.monitor_vars]
        extensions.append(
            Plot(document='text_'+model_name,
                 channels=plot_channels,
                 server_url='http://localhost:5006',
                 every_n_epochs=1, after_epoch=False)
        )
    if config.save_freq is not None and dump_path is not None:
        extensions.append(
            SaveLoadParams(path=dump_path+'.pkl',
                           model=model,
                           before_training=True,
                           after_training=True,
                           after_epoch=False,
                           every_n_epochs=config.save_freq)
        )
    if config.sample_freq is not None:
        extensions.append(
            GenText(m, '\nalex\ttu crois ?\n',
                    config.sample_len, config.sample_temperature,
                    every_n_epochs=config.sample_freq,
                    after_epoch=False, before_training=True)
        )
    if config.on_irc:
        irc = IRCClientExt(m, config.sample_temperature,
                           server='clipper.ens.fr',
                           port=6667,
                           nick='frigo',
                           channels=['#frigotest', '#courssysteme'],
                           after_batch=True)
        irc.do('before_training')
        extensions.append(irc)

    if config.on_irc:
        irc = IRCClientExt(m, config.sample_temperature,
                           server='clipper.ens.fr',
                           port=6667,
                           nick='frigo',
                           channels=['#frigotest', '#courssysteme'],
                           after_batch=True)
        irc.do('before_training')
        extensions.append(irc)

	main_loop = MainLoop(
		model=model,
		data_stream=train_stream,
		algorithm=algorithm,
		extensions=extensions
	)
	main_loop.run()

    # IRC mode : just load the parameters and run an IRC server
    if '--irc' in sys.argv:
        try:
            extensions.append(FinishAfter(before_training=True, after_n_batches=1))
            print "Initializing main loop"
            main_loop.run()
            print "Jumping into IRC"
            irc.run_forever()
        except KeyboardInterrupt:
            pass
        sys.exit(0)








#  vim: set sts=4 ts=4 sw=4 tw=0 et :