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

import math

import numpy as np

import tensorflow as tf

from sklearn import metrics

from sklearn.utils import shuffle

import pymrmr

from sklearn.svm import SVR

from sklearn.feature_selection import RFE

from skrebate import ReliefF

from gcforest.gcforest import GCForest

def load_json(path):

    import json

    """

    """

    lines = []

    with open(path) as f:

        for row in f.readlines():

            if row.strip().startswith("//"):

                continue

            lines.append(row)

    return json.loads("\n".join(lines))

def consistency_index(sel1, sel2, num_features):

    """ Compute the consistency index between two sets of features.

    Parameters

    ----------

    sel1: set

        First set of indices of selected features

    sel2: set

        Second set of indices of selected features

    num_features: int

        Total number of features

    Returns

    -------

    cidx: float

        Consistency index between the two sets.

    Reference

    ---------

    Kuncheva, L.I. (2007). A Stability Index for Feature Selection.

    AIAC, pp. 390--395.

    """

    observed = float(len(sel1.intersection(sel2)))

    expected = len(sel1) * len(sel2) / float(num_features)

    maxposbl = float(min(len(sel1), len(sel2)))

    cidx = -1.

    # It's 0 and not 1 as expected if num_features == len(sel1) == len(sel2) => observed = n

    # Because "take everything" and "take nothing" are trivial solutions we don't want to select

    if expected != maxposbl:

        cidx = (observed - expected) / (maxposbl - expected)

    return cidx

def consistency_index_k(sel_list, num_features):

    """ Compute the consistency index between more than 2 sets of features.

    This is done by averaging over all pairwise consistency indices.

    Parameters

    ----------

    sel_list: list of lists

        List of k lists of indices of selected features

    num_features: int

        Total number of features

    Returns

    -------

    cidx: float

        Consistency index between the k sets.

    Reference

    ---------

    Kuncheva, L.I. (2007). A Stability Index for Feature Selection.

    AIAC, pp. 390--395.

    """

    cidx = 0.

    for k1, sel1 in enumerate(sel_list[:-1]):

        # sel_list[:-1] to not take into account the last list.

        # avoid a problem with sel_list[k1+1:] when k1 is the last element,

        # that give an empty list overwise

        # the work is done at the second to last element anyway

        for sel2 in sel_list[k1+1:]:

            cidx += consistency_index(set(sel1), set(sel2), num_features)

    cidx = 2.  * cidx / (len(sel_list) * (len(sel_list) - 1))

    return "{0:.4f}".format(cidx)

def avg_importance(sa, sb):

    sc = sa.add(sb, fill_value=None).dropna() / 2

    sd = sa.add(sb, fill_value=0).drop(sc.index)

    return sc.append(sd)

def weight_variable(shape):

    initial = tf.truncated_normal(shape, stddev=0.1)

    return tf.Variable(initial)

def bias_variable(shape):

    initial = tf.constant(0.1, shape=shape)

    return tf.Variable(initial)

def conv2d(x, w):

    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):

    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

def cnn(x_train, x_test, y_train, y_test):

    L1 = 32  # number of convolutions for first layer

    L2 = 64  # number of convolutions for second layer

    L3 = 512  # number of neurons for dense layer

    learning_date = 1e-4  # learning rate

    epochs = 50  # number of times we loop through training data

    batch_size = 16  # number of data per batch

    display_step = 1

    loss_rec = np.zeros([epochs, 1])

    training_eval = np.zeros([epochs, 2])

    features = x_train.shape[1]

    classes = y_train.shape[1]

    xs = tf.placeholder(tf.float32, [None, features])

    ys = tf.placeholder(tf.float32, [None, classes])

    keep_prob = tf.placeholder(tf.float32)

    x_shape = tf.reshape(xs, [-1, 1, features, 1])

    # first conv

    w_conv1 = weight_variable([5, 5, 1, L1])

    b_conv1 = bias_variable([L1])

    h_conv1 = tf.nn.relu(conv2d(x_shape, w_conv1) + b_conv1)

    h_pool1 = max_pool_2x2(h_conv1)

    # second conv

    w_conv2 = weight_variable([5, 5, L1, L2])

    b_conv2 = bias_variable([L2])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2)

    h_pool2 = max_pool_2x2(h_conv2)

    tmp_shape = (int)(math.ceil(features / 4.0))

    h_pool2_flat = tf.reshape(h_pool2, [-1, 1 * tmp_shape * L2])

    # third dense layer,full connected

    w_fc1 = weight_variable([1 * tmp_shape * L2, L3])

    b_fc1 = bias_variable([L3])

    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)

    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    # fourth layer, output

    w_fc2 = weight_variable([L3, classes])

    b_fc2 = bias_variable([classes])

    y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2)

    cost = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(y_conv), reduction_indices=[1]))

    optimizer = tf.train.AdamOptimizer(learning_date).minimize(cost)

    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(ys, 1))

    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    with tf.Session() as sess:

        sess.run(tf.global_variables_initializer())

        total_batch = int(np.shape(x_train)[0] / batch_size)

        for epoch in range(epochs):

            avg_cost = 0.

            x_tmp, y_tmp = shuffle(x_train, y_train)

            for i in range(total_batch - 1):

                batch_x, batch_y = x_tmp[i * batch_size:i * batch_size + batch_size], \

                                   y_tmp[i * batch_size:i * batch_size + batch_size]

                _, c, acc = sess.run([optimizer, cost, accuracy],

                                     feed_dict={xs: batch_x, ys: batch_y, keep_prob: 0.8})

                avg_cost += c / total_batch

            del x_tmp

            del y_tmp

            ## Display logs per epoch step

            if epoch % display_step == 0:

                loss_rec[epoch] = avg_cost

                acc, y_s = sess.run([accuracy, y_conv],

                                    feed_dict={xs: x_train, ys: y_train, keep_prob: 1})

                auc = metrics.roc_auc_score(y_train, y_s)

                training_eval[epoch] = [acc, auc]

                print("Epoch:", '%d' % (epoch + 1), "cost =", "{:.9f}".format(avg_cost),

                      "Training accuracy:", round(acc, 3), " Training auc:", round(auc, 3))

        y_pred = y_conv.eval(feed_dict={xs: x_test, ys: y_test, keep_prob: 1.0})[:, 1]

        return y_pred

def mRMR(x_train, y_train, n_features):

    x_train.insert(loc=0, column='class', value=y_train)

    features = pymrmr.mRMR(x_train, 'MIQ', n_features)

    column_name = x_train.columns.tolist()

    results = []

    for feature_index in features:

        idx = column_name.index(feature_index)

        results.append(idx)

    return results

def svm_rfe(x_train, y_train, n_features):

    estimator = SVR(kernel="linear")

    selector = RFE(estimator, n_features_to_select=n_features)

    selector = selector.fit(x_train.values, y_train)

    column_name = x_train.columns.tolist()

    features = []

    for feature_name, feature_ind in zip(column_name, selector.ranking_):

        if feature_ind == 1:

            features.append(column_name.index(feature_name))

    return features

def reliefF(x_train, y_train, n_features):

    fs = ReliefF(n_features_to_select=n_features)

    fs.fit(x_train.values, y_train)

    return list(fs.top_features_)[:n_features]

def df(x_train, y_train, n_features):

    config = load_json("demo_ca.json")

    gc = GCForest(config)

    X_train = x_train.values.reshape(-1, 1, len(x_train.columns))

    _, _features = gc.fit_transform(X_train, y_train)

    _features = _features.sort_values(ascending=False)

    return _features.index.values.tolist()[:n_features]