# -*- coding: utf-8 -*-

from __future__ import print_function

Interactive evaluation for the RTE networks.

import argparse
import tensorflow as tf
import numpy as np
import matplotlib
matplotlib.use('TKAgg')  # necessary on OS X
from matplotlib import pyplot as pl

from classifiers import multimlp
import utils
import ioutils

class SentenceWrapper(object):
    Class for the basic sentence preprocessing needed to make it readable
    by the networks.
    def __init__(self, sentence, word_dict, lowercase, language='en'):
        self.sentence = sentence
        tokenize = utils.get_tokenizer(language)
        if lowercase:
            pre_tokenize = sentence.lower()
            pre_tokenize = sentence
        self.tokens = tokenize(pre_tokenize)
        self.indices = [word_dict[token] for token in self.tokens_with_null]
        self.padding_index = word_dict[utils.PADDING]

    def __len__(self):
        return len(self.tokens)

    def tokens_with_null(self):
        return [utils.GO] + self.tokens

    def convert_sentence(self):
        Convert a sequence of tokens into the input array used by the network
        :return: the vector to be given to the network
        indices = np.array(self.indices)
        # padded = np.pad(indices, (0, num_time_steps - len(indices)),
        #                 'constant', constant_values=self.padding_index)
        return indices.reshape((1, -1))

def print_attention(tokens1, tokens2, attention):
    Print the attention from tokens1 over tokens2
    # multiply by 10 to make it easier to visualize
    attention_bigger = attention * 10
    max_length_sent1 = max([len(t) for t in tokens1])

    # create formatting string to match the size of the tokens
    att_formatters = ['{:>%d.2f}' % len(t) for t in tokens2]

    # first line has whitespace in the first sentence column and
    # then the second one
    blank = ' ' * max_length_sent1

    # take at least length 4 to fit the 9.99 format
    formatted_sent2 = ['{:>4}'.format(token) for token in tokens2]
    first_line = blank + '\t' + '\t'.join(formatted_sent2)

    for token, att in zip(tokens1, attention_bigger):

        values = [fmt.format(x)
                  for x, fmt in zip(att, att_formatters)]
        fmt_str = '{:>%d}' % max_length_sent1
        formatted_token = fmt_str.format(token)
        line = formatted_token + '\t' + '\t'.join(values)
        print (line)

def plot_attention(tokens1, tokens2, attention):
    Print a colormap showing attention values from tokens 1 to
    tokens 2.
    len1 = len(tokens1)
    len2 = len(tokens2)
    extent = [0, len2, 0, len1]
    pl.matshow(attention, extent=extent, aspect='auto')
    ticks1 = np.arange(len1) + 0.5
    ticks2 = np.arange(len2) + 0.5
    pl.xticks(ticks2, tokens2, rotation=45)
    pl.yticks(ticks1, reversed(tokens1))
    ax = pl.gca()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('load', help='Directory with saved model files')
    parser.add_argument('embeddings', help='Text or numpy file with word embeddings')
    parser.add_argument('--vocab', help='Vocabulary file (only needed if numpy'
                                        'embedding file is given)')
    parser.add_argument('-a', help='Plot attention values graph', dest='attention',
    parser.add_argument('-i', help='Run inference classifier', dest='inference',
    args = parser.parse_args()

    logger = utils.get_logger()
    params = ioutils.load_params(args.load)
    if args.inference:
        label_dict = ioutils.load_label_dict(args.load)
        number_to_label = {v: k for (k, v) in label_dict.items()}

    logger.info('Reading model')
    sess = tf.InteractiveSession()
    model_class = utils.get_model_class(params)
    model = model_class.load(args.load, sess)
    word_dict, embeddings = ioutils.load_embeddings(args.embeddings, args.vocab,
    model.initialize_embeddings(sess, embeddings)

    ops = []
    if args.inference:
    if args.attention:

    while True:
        sent1 = raw_input('Type sentence 1: ').decode('utf-8')
        sent2 = raw_input('Type sentence 2: ').decode('utf-8')
        sent1 = SentenceWrapper(sent1, word_dict,
                                params['lowercase'], params['language'])
        sent2 = SentenceWrapper(sent2, word_dict,
                                params['lowercase'], params['language'])

        vector1 = sent1.convert_sentence()
        vector2 = sent2.convert_sentence()
        size1 = len(sent1.tokens_with_null)
        size2 = len(sent2.tokens_with_null)

        feeds = {model.sentence1: vector1,
                 model.sentence2: vector2,
                 model.sentence1_size: [size1],
                 model.sentence2_size: [size2],
                 model.dropout_keep: 1.0}

        results = sess.run(ops, feed_dict=feeds)
        if args.inference:
            answer = results.pop(0)
            print('Model answer:', number_to_label[answer[0]])

        if args.attention:
            att1 = results.pop(0)
            att2 = results.pop(0)
            print('Attention sentence 1:')
                            sent2.tokens_with_null, att1[0])
                           sent2.tokens_with_null, att1[0])
            print('Attention sentence 2:')
                            sent1.tokens_with_null, att2[0])
                           sent1.tokens_with_null, att2[0])