import numpy as np
import random

def quan_detector(dataset,label):
    """
    the percent of zeros(n) promoter
    """
    n = len(dataset[1])
    N = len(dataset)
    p = [0]*n
    count = 0.
    pos_count = 0.
    neg_count = 0.
    for i in range(N):
        d = dataset[i]
        if all(d == p):
            count += 1.
            if label[i][0] == 1:
                pos_count += 1.
            else:
                neg_count += 1.
    return count/N, pos_count,neg_count
#quan_detector([[0,0,0],[0,1,0],[0,2,0],[1,0,1]])

def most_repeared_promoter(dataset,label):
    N = len(dataset)
    n = len(dataset[1])
    zeros = ','.join(map(str,['0']*n))
    # print len(zeros)-n
    dict_count = {}
    for i in range(N):
        str_prom = ','.join(map(str,dataset[i]))
        if str_prom not in dict_count.keys():
            dict_count[str_prom] = [1,0,0]
            if label[i][0] == 1:
                dict_count[str_prom][1] = 1
            else:
                dict_count[str_prom][2] = 1
        else:
            dict_count[str_prom][0] += 1
            if label[i][0] == 1:
                dict_count[str_prom][1] += 1
            else:
                dict_count[str_prom][2] += 1
    if zeros in dict_count.keys():
        dict_count.pop(zeros) # remove without
    count = np.array(dict_count.values())[:,0]
    max_count = max(count)
    for k,v in dict_count.items():
        if v[0] == max_count:
            idx_temp = k
    idx = idx_temp.split(',')
    return idx, max_count, dict_count[idx_temp]

###############################################################
#########          Dataset generation            ##############
###############################################################
def indx(lab):
    #     lab = np.argmax(lab,axis=1)
    p = []  # positive samples index-- ALS
    n = []  # negative samples index-- Non-ALS
    for i in range(len(lab)):
        if lab[i] == 0:
            p.append(i)
        else:
            n.append(i)
    return p, n


def dataset(X, Y, test_ratio):
    lab = np.argmax(Y, axis=1)
    pos_s, neg_s = indx(lab)

    N = len(lab)
    idx = range(N)

    N_te = int(N * test_ratio) / 5 * 5  # number of test samples
    N_tr = N - N_te  # number of training samples

    pos_s_te = int(N_te * 0.5)
    neg_s_te = int(N_te * 0.5)

    random.shuffle(pos_s)
    random.shuffle(neg_s)

    pos_idx_te = pos_s[:pos_s_te]
    neg_idx_te = neg_s[:neg_s_te]

    te_idx = pos_idx_te + neg_idx_te
    tr_idx = list(set(idx) - set(te_idx))

    random.shuffle(te_idx)
    random.shuffle(tr_idx)

    tr_X = X[tr_idx]
    tr_Y = Y[tr_idx]

    te_X = X[te_idx]
    te_Y = Y[te_idx]
    return tr_X, tr_Y, te_X, te_Y