from sklearn import preprocessing
from sklearn.preprocessing import OneHotEncoder

class ActionEncoder():
        Class that will be used to encode all the key into
        One Hot Encoder and Label Encoder (map integer into action key)

    def __init__(self):
        self.dict_act_key_to_mirror_key = {}
        self.dict_index_act_to_mirror_index = {}

    def fit(self, list_all_action):
        Fit the encoder of Label Encoder. So it can map an integer to an action key.
        Also fit the One Hot Encoder.
        :param list_all_action: list of all possible action keys in the game
        self.le = preprocessing.LabelEncoder()
        list_all_action = self.le.fit_transform(list_all_action)
        self.shape_all_actions = len(list_all_action)
        self.onehot_encoder = OneHotEncoder(self.shape_all_actions, sparse=False)
        list_all_action = list_all_action.reshape(len(list_all_action), 1)

    def transform(self, data):
        Transform the action key into one hot encoder
        :param data: action key
        data = self.le.transform(data)
        data = data.reshape(len(data), 1)
        data = self.onehot_encoder.transform(data)
        return data

    def inverse_transform(self, data):
        Transform the integer into the action key based on the dictionary
        fitted in the Label Encoder.
        :param data: int, an encoded label integer
        :return: action key
        data = self.le.inverse_transform(data)
        return data

    def create_mirror_dict(self):
        Create the dictionary of the index action's which maps the encoded action into
        its encoded mirror action

        for i in self.le.classes_:
            all_act = self.le.classes_
            from util.state_modifier_util import get_key_mirror_action
            import numpy as np
            self.dict_act_key_to_mirror_key[i] = get_key_mirror_action(i)
            index_orig = np.where(all_act == i)[0][0]
            index_mirror = np.where(all_act == get_key_mirror_action(i))
            self.dict_index_act_to_mirror_index[index_orig] = index_mirror[0].tolist()

    def array_mirrored(self, array):
        Mirror the index of the array that has the shape of the list of action which
         represent the encoded action key into
        the index of its opposite action key.

        :param array:
        import numpy as np
        new_array = np.zeros_like(array)
        index_np = np.where(array > 0)[0]
        new_index = []
        for z in index_np:
        new_index = np.array(new_index)
        new_array[new_index] = array[index_np]
        return new_array