import math
import torch
from torch.autograd import Variable
from torch.nn.parameter import Parameter
import torch.nn.functional as F

from rnn_cell_base import RNNCellBase


# see: https://github.com/jpeg729/pytorch_bits/tree/master/nn         ----------------------------- #
class RAN(RNNCellBase):

    def __init__(self, input_size, hidden_size, device, bias=True, sigmoid=None, tanh=None, base_stack=False):
        super(RAN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.bias = bias
        self.device = device
        self.dense = torch.nn.Linear(hidden_size, 7)
        self.relu = F.relu
        self.base_stack = base_stack
        self.sigmoid = F.sigmoid if sigmoid is None else self.get_activation(sigmoid)
        self.tanh = F.tanh if tanh is None else self.get_activation(tanh)
        self.weight_ih = Parameter(torch.Tensor(3 * hidden_size, input_size))
        self.weight_hh = Parameter(torch.Tensor(2 * hidden_size, hidden_size))
        if bias:
            self.bias_ih = Parameter(torch.Tensor(3 * hidden_size))
            self.bias_hh = Parameter(torch.Tensor(2 * hidden_size))
        else:
            self.register_parameter('bias_ih', None)
            self.register_parameter('bias_hh', None)
        self.reset_parameters()

    def reset_parameters(self):
        stdv = 1.0 / math.sqrt(self.hidden_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, stdv)
        self.hidden = None
    
    def reset_hidden(self):
        self.hidden = None
    
    def detach_hidden(self):
        self.hidden.detach_()

    def forward(self, input_data, future=0):
        timesteps, batch_size, features = input_data.size()
        # print("t %d, b %d, f %d" % (timesteps, batch_size, features))
        outputs = Variable(torch.zeros(timesteps + future, batch_size, self.hidden_size, device=self.device), requires_grad=False)
        
        if self.hidden is None:
            self.hidden = Variable(torch.zeros(batch_size, self.hidden_size, device=self.device), requires_grad=False)
        # else:
        #     self.hidden.detach_()
        
        self.check_forward_input(input_data[0])
        self.check_forward_hidden(input_data[0], self.hidden)
        
        for i, input_t in enumerate(input_data.split(1)):
            
            gi = F.linear(input_t.view(batch_size, features), self.weight_ih, self.bias_ih)
            gh = F.linear(self.hidden, self.weight_hh, self.bias_hh)
            i_i, i_f, i_n = gi.chunk(3, 1)
            h_i, h_f = gh.chunk(2, 1)

            inputgate = self.sigmoid(i_i + h_i)
            forgetgate = self.sigmoid(i_f + h_f)
            newgate = i_n
            self.hidden = inputgate * newgate + forgetgate * self.hidden
            outputs[i] = self.tanh(self.hidden)
        if self.base_stack:
            return outputs
        else:
            out = self.dense(outputs[-1])
            out = self.relu(out)
            return out
# ------------------------------------------------------------------------------------------------- #


# Added a way to stack up to 2 layers. For a stack of 2 the first layer has the same output shape than its input
class RAN_stack(torch.nn.Module):
    def __init__(self, input_size, hidden_size, device, stacks=1, bias=True, sigmoid=None, tanh=None):
        super(RAN_stack, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.stacks = stacks
        self.device = device
        if stacks == 1:
            self.cell1 = RAN(input_size, hidden_size, device, bias, sigmoid, tanh)
        elif stacks == 2:
            self.cell1 = RAN(input_size, 14, device, bias, sigmoid, tanh, base_stack=True)
            self.cell2 = RAN(input_size, hidden_size, device, bias, sigmoid, tanh, base_stack=False)

    def detach_hidden(self):
        self.cell1.detach_hidden()
        if self.stacks == 2:
            self.cell2.detach_hidden()

    def forward(self, input_data, future=0):
        if self.stacks == 1:
            x = self.cell1(input_data)
        elif self.stacks == 2:
            x = self.cell1(input_data)
            x = self.cell2(x)
        return x


if __name__ == "__main__":
    # Displays the number of trainable parameters for different input sizes
    import numpy as np
    for i in [5, 10, 20, 50]:
        Model = RAN_stack(14, i, None, 2)
        model_parameters = filter(lambda p: p.requires_grad, Model.parameters())
        params = sum([np.prod(p.size()) for p in model_parameters])
        print(params)