import sys, copy
import theano
from theano import tensor as T
from theano.tensor.nnet import sigmoid
from theano.compile import module
from theano import printing, pprint
from theano import compile

import numpy as N

from ..datasets import make_dataset
from .minimizer import make_minimizer
from .stopper import make_stopper

class RBM(module.FancyModule):

    # is it really necessary to pass ALL of these ? - GD
    def __init__(self,
            nvis=None, nhid=None,
            input=None,
            w=None, hidb=None, visb=None):
        super(RBM, self).__init__()
       
        # symbolic theano stuff
        # what about multidimensional inputs/outputs ? do they have to be 
        # flattened or should we used tensors instead ?
        self.w = w if w is not None else module.Member(T.dmatrix())
        self.visb = visb if visb is not None else module.Member(T.dvector())
        self.hidb = hidb if hidb is not None else module.Member(T.dvector())

        # 1-step Markov chain
        self.hid = sigmoid(T.dot(self.w,self.input) + self.hidb)
        self.hid_sample = self.hid #TODO: sample!
        self.vis = sigmoid(T.dot(self.w.T, self.hid) + self.visb)
        self.vis_sample = self.vis #TODO: sample!
        self.neg_hid = sigmoid(T.dot(self.w, self.vis) + self.hidb)

        # cd1 updates:
        self.params = [self.w, self.visb, self.hidb]
        self.gradients = [
            T.dot(self.hid, self.input) - T.dot(self.neg_hid, self.vis),
            self.input - self.vis,
            self.hid - self.neg_hid ]

    def __instance_initialize(self, obj):
        obj.w = N.random.standard_normal((self.nhid,self.nvis))
        obj.genb = N.zeros(self.nvis)
        obj.hidb = N.zeros(self.nhid)

def RBM_cd():
    pass;

def train_rbm(state, channel=lambda *args, **kwargs:None):
    dataset = make_dataset(**state.subdict(prefix='dataset_'))
    train = dataset.train

    rbm_module = RBM(
            nvis=train.x.shape[1],
            nhid=state.size_hidden)

    batchsize = state.batchsize
    verbose = state.verbose
    iter = [0]

    while iter[0] != state.max_iters:
        for j in xrange(0,len(train.x)-batchsize+1,batchsize):
            rbm.cd1(train.x[j:j+batchsize])
            if verbose > 1:
                print 'estimated train cost...'
            if iter[0] == state.max_iters:
                break
            else:
                iter[0] += 1