def RCL(input_shape,
        rec_conv_layers, 
        dense_layers,
        output_layer=[1, 'sigmoid'],
        padding='same', 
        optimizer='adam',
        loss='binary_crossentropy'):
    """Summary
    
    Args:
        input_shape (tuple): The shape of the input layer.
        output_nodes (int): Number of nodes in the output layer. It depends on the loss function used.
        rec_conv_layers (list): RCL descriptor 
                                [
                                  [
                                    [(filter, kernel), (pool_size, stride), leak, drop],
                                    [(filter, kernel), (pool_size, stride), leak, drop],
                                    [(filter, kernel), (pool_size, stride), leak, drop, timesteps],
                                  ],
                                  ...
                                  [
                                    [],[],[]
                                  ]
                                ]
        dense_layers (TYPE): Dense layer descriptor [[fully_connected, leak, drop], ... []]
        padding (str, optional): Type of padding for conv and pooling layers
        optimizer (str or object optional): Keras optimizer as string or keras optimizer
    
    Returns:
        model: The compiled Kears model, ready for training.
    """
    
    inputs = Input(shape=input_shape)
    
    for i, c in enumerate(rec_conv_layers):
        
        conv = Conv1D(c[0][0][0], c[0][0][1], padding=padding)(inputs)
        batch = BatchNormalization()(conv)
        act = LeakyReLU(alpha=c[0][2])(batch)
        pool = MaxPooling1D(pool_size=c[0][1][0], strides=c[0][1][1], padding=padding)(act)
        d1 = Dropout(c[0][3])(pool)
        
        inner = time_steps( input=d1,
                            conv_layer=c[1],
                            time_conv_layer=c[2],
                            padding=padding)
    
    drop = Flatten()(inner)

    for i, d in enumerate(dense_layers):
        dense = Dense(d[0], activation='relu')(drop)
        bn = BatchNormalization()(dense)
        act = LeakyReLU(alpha=d[1])(bn)
        drop = Dropout(d[2])(act)
    
    output = Dense(output_layer[0], activation=output_layer[1])(drop)
    
    model = Model(inputs=inputs, outputs=output)
        
    model.compile(loss=loss, optimizer=optimizer, metrics=['accuracy'])
    
    return model