#!/usr/bin/env python
# coding: utf-8

# In[1]:


import pandas as pd
import os
import numpy as np


# In[2]:


targets_path=r"C:\Users\jeuux\Desktop\Carrera\MoAI\TFM\AnnotatedData\Accelerometer_Data\Datasets\HAR_Dataset\targets.npy"


# In[54]:


targets=np.load(targets_path)


# In[45]:


#get list of targets
target_list=np.unique(targets)

#split target hierarchy inside each target (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )
targets_list=list(map(lambda target: target.split(" "),target_list))

#selects targets inside current hierarchy
targets_used = list(filter(lambda x: "Or" in x, targets))


# In[27]:


#split target hierarchy inside each target (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )
def _split_target_hierarchy(target_list):
    return list(map(lambda target: target.split(" "),target_list))
def _filter_levels(target,pos):
    target=target[:pos+2]
    return " ".join(target)


# In[46]:


#2nd step
level="Or"
#split hierarchy
targets_used=_split_target_hierarchy(targets_used)
#get pos...
target_ex=targets_used[0]
pos=next(idx for idx,_ in enumerate(target_ex) if level==target_ex[idx])
#filter levels
targets_used=list(map(lambda target: _select_levels(target,pos) ,targets_used))


# # Transformer

# In[71]:


import numpy as np 
from sklearn.base import BaseEstimator, TransformerMixin


class LevelSelector( BaseEstimator, TransformerMixin):
    """Custom Transformer that select the group of behaviours inside a level hierarchy"""

    #Class Constructor 
    def __init__( self,level):
        self._level=level
        
    def _split_target_hierarchy(self,target_list):
        """split target hierarchy inside each target 
        (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )"""
        return list(map(lambda target: target.split(" "),target_list))
    
    def _filter_levels(self,target,pos):
        target=target[:pos+2]
        return " ".join(target)
    
    def _get_pos(self,y):
        y_first=y[0]
        return next(idx for idx,_ in enumerate(y_first) if self._level==y_first[idx])

    def _get_valid_idx(self,y):
        return [idx for idx,target in enumerate (y) if self._level in target]

    def fit(self,y):
        return self 
    
    def transform( self, y ):
        #filter behaviours
        self.valid_idx= self._get_valid_idx(y)
        y = y[self.valid_idx]
        #split hierarchy
        y=self._split_target_hierarchy(y)
        #get pos
        pos=self._get_pos(y)
        #filter levels
        y=list(map(lambda target: self._filter_levels(target,pos) ,y))
        return  y


# In[72]:


level_sel=LevelSelector(level="Or")


# In[73]:


targets_filtered=level_sel.transform(targets)


# In[75]:


level_sel.valid_idx


# In[70]:


y


# In[69]: