import random
import math
import torch
from .Module import Module

# TODO fix THNN...

class SpatialConvolutionMap(Module):

    class maps(object):

        @staticmethod
        def full(nin, nout):
            ft = torch.Tensor(nin*nout, 2)
            p = 0
            for j in range(nout):
                for i in range(nin):
                    ft[p][0] = i
                    ft[p][1] = j
                    p += 1
            return ft

        @staticmethod
        def oneToOne(nfeat):
            ft = torch.Tensor(nfeat, 2)
            for i in range(nfeat):
                ft[i][0] = i
                ft[i][1] = i
            return ft

        @staticmethod
        def random(nin, nout, nto):
            nker = nto * nout
            tbl = torch.Tensor(nker, 2)
            fi = torch.randperm(nin)
            frcntr = 0
            nfi = math.floor(nin / nto) # number of distinct nto chunks
            totbl = tbl.select(1, 1)
            frtbl = tbl.select(1, 0)
            fitbl = fi.narrow(0, 0, (nfi * nto)) # part of fi that covers distinct chunks
            ufrtbl = frtbl.unfold(0, nto, nto)
            utotbl = totbl.unfold(0, nto, nto)
            ufitbl = fitbl.unfold(0, nto, nto)

            # start fill_ing frtbl
            for i in range(nout): # fro each unit in target map
                ufrtbl.select(0, i).copy_(ufitbl.select(0, frcntr))
                frcntr += 1
                if frcntr-1 == nfi: # reset fi
                    fi.copy_(torch.randperm(nin))
                    frcntr = 1

            for tocntr in range(utotbl.size(0)):
                utotbl.select(0, tocntr).fill_(tocntr)

            return tbl

    def __init__(self, conMatrix, kW, kH, dW=1, dH=1):
        super(SpatialConvolutionMap, self).__init__()

        self.kW = kW
        self.kH = kH
        self.dW = dW
        self.dH = dH
        self.connTable = conMatrix
        self.nInputPlane = int(self.connTable.select(1, 0).max()) + 1
        self.nOutputPlane = int(self.connTable.select(1, 1).max()) + 1
        self.weight = torch.Tensor(self.connTable.size(0), kH, kW)
        self.bias = torch.Tensor(self.nOutputPlane)
        self.gradWeight = torch.Tensor(self.connTable.size(0), kH, kW)
        self.gradBias = torch.Tensor(self.nOutputPlane)

        self.reset()

    def reset(self, stdv=None):
        if stdv is not None:
            stdv = stdv * math.sqrt(3)
            self.weight.uniform_(-stdv, stdv)
            self.bias.uniform_(-stdv, stdv)
        else:
            ninp = torch.Tensor(self.nOutputPlane).zero_()
            for i in range(self.connTable.size(0)):
                idx = int(self.connTable[i,1])
                ninp[idx] += 1
            for k in range(self.connTable.size(0)):
                idx = int(self.connTable[k,1])
                stdv = 1. / math.sqrt(self.kW*self.kH*ninp[idx])
                self.weight.select(0, k).uniform_(-stdv, stdv)
            for k in range(self.bias.size(0)):
                stdv = 1. / math.sqrt(self.kW * self.kH * ninp[k])
                # TODO: torch.uniform
                self.bias[k] = random.uniform(-stdv, stdv)

    def updateOutput(self, input):
        self._backend.SpatialConvolutionMap_updateOutput(
            self._backend.library_state,
            input,
            self.output,
            self.weight,
            self.bias,
            self.connTable,
            self.nInputPlane,
            self.nOutputPlane,
            self.dW, self.dH
        )
        return self.output

    def updateGradInput(self, input, gradOutput):
        self._backend.SpatialConvolutionMap_updateGradInput(
            self._backend.library_state,
            input,
            gradOutput,
            self.gradInput,
            self.weight,
            self.bias,
            self.connTable,
            self.nInputPlane,
            self.nOutputPlane,
            self.dW, self.dH
        )
        return self.gradInput

    def accGradParameters(self, input, gradOutput, scale=1):
        self._backend.SpatialConvolutionMap_accGradParameters(
            self._backend.library_state,
            input,
            gradOutput,
            self.gradWeight,
            self.gradBias,
            self.connTable,
            self.nInputPlane,
            self.nOutputPlane,
            self.dW, self.dH,
            scale
        )

