"""
@File  : enose_dataset.py
@Author: tao.jing
@Date  : 2022/5/18
@Desc  :
"""
import numpy as np
from paddle.io import Dataset

from config.root_config import _C, CN

# from pyts.approximation import PiecewiseAggregateApproximation
# from pyts.preprocessing import MinMaxScaler

class EnoseDataset_lstm_mlp(Dataset):
    def __init__(self, data_with_label, data_numbers):
        super().__init__()

        data_mlp,data_lstm, label = data_with_label
        self.data_lstm = data_lstm
        print('data_loader_1D over',len(data_lstm))
        self.data_mlp = data_mlp
        print('data_loader_2D over',len(data_mlp))
        self.label = label

    def __getitem__(self, idx):
        return (
        self.data_lstm[idx].astype(np.float32), self.data_mlp[idx].astype(np.float32), self.label[idx].astype(np.int64))

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


class EnoseDataset(Dataset):
    def __init__(self, data_with_label):
        super().__init__()

        data, label = data_with_label
        print(data.shape)
        data = data[:,:,[0,1,2,3,4,5,6,7,8,9,10,11,13,14,15]]
        print(data.shape)
        self.data = data
        self.label = label
        print('data_loader_1D over')

    def __getitem__(self, idx):
        return (self.data[idx].astype(np.float32), self.label[idx].astype(np.int64))

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


'''
class EnoseDataset_2D(Dataset):
    def __init__(self, data_with_label,data_numbers):
        super().__init__()

        data, label = data_with_label
        Y = data
        gram_num=[]
        for data_number in range(data_numbers):
            gram_channel = []
            for channel in range(16):
                channel_pop = 0
                if channel == 12:
                    channel_pop = 1
                if channel_pop == 0:
                    Y_smooth1 = Y[data_number, 0:250, channel]
                    Y_smooth2 = Y[data_number, 250:1250, channel]
                    Y_smooth3 = Y[data_number, 1250:1500, channel]
                    # print(Y_smooth1.shape, Y_smooth1.size)

                    X_smooth1 = range(250)
                    X_smooth2 = range(1000)
                    X_smooth3 = range(250)

                    smooth1 = [X_smooth1, Y_smooth1]
                    smooth2 = [X_smooth2, Y_smooth2]
                    smooth3 = [X_smooth3, Y_smooth3]
                    # PAA
                    transformer_smooth1 = PiecewiseAggregateApproximation(window_size=50)
                    result1 = transformer_smooth1.transform(smooth1)

                    transformer_smooth2 = PiecewiseAggregateApproximation(window_size=20)
                    result2 = transformer_smooth2.transform(smooth2)

                    transformer_smooth3 = PiecewiseAggregateApproximation(window_size=50)
                    result3 = transformer_smooth3.transform(smooth3)

                    result = np.concatenate((result1, result2, result3), axis=1)

                    # Scaling in interval [0,1]
                    scaler = MinMaxScaler()
                    scaled_X = scaler.transform(result)

                    scaled_X1 = []
                    for data in scaled_X[1, :]:
                        if data >= 1:
                            scaled_X1.append(0.99999)
                        else:
                            scaled_X1.append(data)

                    arccos_X = np.arccos(scaled_X1)

                    field = [a + b for a in arccos_X for b in arccos_X]
                    gram = np.cos(field)
                    gram = gram.reshape(-1, _C.data.image_size)
                    gram_channel.append(gram)
                    # print(np.array(gram_channel).shape)
            gram_num.append(gram_channel)
            # print(np.array(gram_num).shape)

        data = np.array(gram_num)
        print('data_loader_2D over', data.shape)


        self.data = data

        self.label = label

    def __getitem__(self, idx):
        return (self.data[idx].astype(np.float32), self.label[idx].astype(np.int64))

    def __len__(self):
        return len(self.data)
'''


if __name__ == '__main__':
    from data_loader import load_enose_data
    dataset=EnoseDataset_lstm_mlp(load_enose_data())

    for item in dataset:
        data, label = item
        print(data.shape)
        print(label)
        break