import jax
import jax.numpy as jnp
import ninjax as nj
import numpy as np

from embodied.jax import utils

f32 = jnp.float32
i32 = jnp.int32



class Layer(nj.Module):

  units: int = 8

  def __call__(self, x, c, k):
    assert x.shape[1:] == (self.units,)
    assert c.shape == (7,)
    assert k.shape == (13, 7)
    shape = (x.shape[-1], self.units)
    winit = lambda: jax.random.normal(nj.seed(), shape, f32)
    x = x @ self.value('kernel', winit)
    if 'outer3' not in nj.context():
      nj.context()['outer3'] = jnp.zeros((), i32)
    nj.context()['outer3'] += 1
    nj.context()['outer1'] += 1
    inner = self.value('inner', jnp.array(0))
    self.write('inner', inner + nj.context()['outer2'])
    return x


class Net(nj.Module):

  layers: int = 4
  units: int = 8

  def __call__(self, x):
    if 'outer1' not in nj.context():
      nj.context()['outer1'] = jnp.ones((), i32)
    if 'outer2' not in nj.context():
      nj.context()['outer2'] = jnp.ones((), i32)
    nj.context()['outer1'] += 1

    module = self.sub('linear', Layer, units=self.units)
    c = jnp.zeros((self.layers, 7))
    k = jnp.zeros((13, 7))
    x = utils.LayerScan(module, self.layers)(x, c, k=k)

    return x

  def loss(self, x):
    return self(x).mean()


class TestLayerScan:

  def test_init(self, L=4, B=2, D=8):
    x = np.random.normal(0, 1, (B, D))
    net = Net(layers=L, units=D, name='net')
    params = nj.init(net)({}, x, seed=0)
    assert set(params.keys()) == {
        'outer1', 'outer2', 'outer3',
        'net/linear/kernel', 'net/linear/inner'}
    assert params['net/linear/kernel'].shape == (L, D, D)
    assert params['outer1'] == 1
    assert params['outer2'] == 1
    assert params['outer3'] == 0
    assert params['net/linear/inner'].shape == (L,)
    assert (params['net/linear/inner'] == 0).all()
    for i in range(1, L):
      assert not jnp.allclose(
          params['net/linear/kernel'][0],
          params['net/linear/kernel'][i])

  def test_apply(self, L=4, B=2, D=8):
    x = np.random.normal(0, 1, (B, D))
    net = Net(layers=L, units=D, name='net')
    params = nj.init(net)({}, x, seed=0)
    params, out = nj.pure(net)(params, x)
    assert out.shape == (B, D)
    assert params['outer1'] == L + 2
    assert params['outer2'] == 1
    assert params['outer3'] == L
    assert params['net/linear/inner'].shape == (L,)
    assert (params['net/linear/inner'] == 1).all()

  def test_grad(self, L=4, B=2, D=8):
    x = np.random.normal(0, 1, (B, D))
    net = Net(layers=L, units=D, name='net')
    def fn(x):
      if nj.creating():
        net(x)
      params = {k: v for k, v in net.values.items() if v.dtype == f32}
      params = {net.path + '/' + k: v for k, v in params.items()}
      loss, _, grads = nj.grad(lambda x: net(x).mean(), params.keys())(x)
      params = {k: v - 0.1 * grads[k] for k, v in params.items()}
      nj.context().update(params)
      return loss
    params = nj.init(net)({}, x, seed=0)
    params, loss = nj.pure(fn)(params, x)
    assert loss.shape == ()