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 SRU(RNNCellBase):

    def __init__(self, input_size, hidden_size, device, bias=True, sigmoid=None, tanh=None, gpu=False, base_stack=False):
        super(SRU, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.bias = bias
        self.device = device
        self.gpu = gpu
        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))
        if bias:
            self.bias_ih = Parameter(torch.Tensor(3 * hidden_size))
        else:
            self.register_parameter('bias_ih', 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)
        
        self.check_forward_input(input_data[0])
        self.check_forward_hidden(input_data[0], self.hidden)
        
        if self.gpu:
            gis = F.linear(input_data, self.weight_ih, self.bias_ih)
            
            for i, gi in enumerate(gis.split(1)):
                i_r, i_f, i_n = gi.squeeze().chunk(3, 1)

                readgate = self.sigmoid(i_r)
                forgetgate = self.sigmoid(i_f)
                newgate = i_n
                self.hidden = newgate + forgetgate * (self.hidden - newgate)
                outputs[i] = newgate + readgate * (self.tanh(self.hidden) - newgate)
        else:
            for i, input_t in enumerate(input_data.split(1)):
                x = input_t.view(batch_size, features)
                gi = F.linear(x, self.weight_ih, self.bias_ih)
                i_r, i_f, i_n = gi.chunk(3, 1)

                readgate = self.sigmoid(i_r)
                forgetgate = self.sigmoid(i_f)
                newgate = i_n
                self.hidden = newgate + forgetgate * (self.hidden - newgate)
                outputs[i] = newgate + readgate * (self.tanh(self.hidden) - newgate)
        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 SRU_stack(torch.nn.Module):
    def __init__(self, input_size, hidden_size, device, stacks=1, bias=True, sigmoid=None, tanh=None):
        super(SRU_stack, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.stacks = stacks
        self.device = device
        if stacks == 1:
            self.cell1 = SRU(input_size, hidden_size, device, bias, sigmoid, tanh)
        elif stacks == 2:
            self.cell1 = SRU(input_size, 14, device, bias, sigmoid, tanh, base_stack=True)
            self.cell2 = SRU(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 = SRU_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)