# Copyright 2022 NNAISENSE SA
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


from typing import Iterable

import numpy as np
import torch

from evotorch.neuroevolution.net.runningnorm import RunningNorm
from evotorch.neuroevolution.net.runningstat import RunningStat
from evotorch.testing import assert_allclose


def _compute_stats(observations: Iterable) -> dict:
    # Compute stats from a collection of observations.
    # The observations are expected as a 2-dimensional tensor or numpy array.

    if isinstance(observations, np.ndarray):

        def convert(x):
            return x.numpy()

    else:

        def convert(x):
            return x

    observations = torch.as_tensor(observations, dtype=torch.float32)

    # Get the sum of observations, sum of squares, and the number of observations
    sum_of_obs = torch.sum(observations, dim=0)
    sum_of_squares = torch.sum(observations**2, dim=0)
    count = observations.shape[0]

    # Compute E[x] and E[x^2]
    E_x = sum_of_obs / count
    E_x2 = sum_of_squares / count

    # Compute the variance as E[x^2] - E[x]^2
    # Additionally, clip the variance so that it cannot go below 1e-2.
    variance = E_x2 - (E_x**2)
    variance = torch.max(variance, torch.tensor(1e-2, dtype=torch.float32))

    # The mean is E[x] and the standard deviation is the square root of the variance.
    mean = E_x
    stdev = torch.sqrt(variance)

    return dict(
        sum=convert(sum_of_obs),
        sum_of_squares=convert(sum_of_squares),
        count=count,
        mean=convert(mean),
        stdev=convert(stdev),
    )


def test_running_stat():
    tolerance = 1e-4

    # Create some random observations
    all_obs = np.random.randn(10, 5)

    # Get the stats of the observations
    stats = _compute_stats(all_obs)
    mean = stats["mean"]
    stdev = stats["stdev"]

    # Now that we know the mean and the standard deviation of our observations, we instantiate a RunningStat,
    # feed observations to it, and confirm that it also reports the same mean and the same standard deviation.
    rs = RunningStat()

    for obs in all_obs:
        # Feed each observation to the RunningStat instance.
        rs.update(obs)

    # Confirm that the mean and the standard deviation are reported correctly.
    assert_allclose(rs.mean, mean, atol=tolerance)
    assert_allclose(rs.stdev, stdev, atol=tolerance)

    # We now instantiate multiple RunningStat instances: rs1, rs2, and rs3. Each of them will get its own portion of
    # the observations. Then, we will add each of these RunningStat instances to yet another RunningStat.
    # Finally, we will test whether or not this last RunningStat, after collecting the data from rs1, rs2, and rs3,
    # will report the mean and the standard deviation correctly.
    rs1 = RunningStat()
    rs2 = RunningStat()
    rs3 = RunningStat()

    obs_batch1 = all_obs[:3]
    obs_batch2 = all_obs[3:7]
    obs_batch3 = all_obs[7:]

    for obs in obs_batch1:
        rs1.update(obs)

    for obs in obs_batch2:
        rs2.update(obs)

    for obs in obs_batch3:
        rs3.update(obs)

    final_rs = RunningStat()
    final_rs.update(rs3)
    final_rs.update(rs2)
    final_rs.update(rs1)

    # Assert that `final_rs` reports the correct mean and standard deviation
    assert_allclose(final_rs.mean, mean, atol=tolerance)
    assert_allclose(final_rs.stdev, stdev, atol=tolerance)


def _make_random_booleans(*shape):
    x = torch.randn(*shape)
    return x > 0


def test_running_norm():
    tolerance = 1e-4

    # We imagine an environment whose observation length is as follows:
    obs_length = 10

    # We imagine a batch of environments
    num_envs = 50

    # We will have this many batch of observations
    num_timesteps = 30

    # For each timestep, we generate a batch of observations
    all_obs = torch.randn(num_timesteps, num_envs, obs_length)

    # For each timestep, we generate a mask tensor
    # This mask tensor will tell us which environment is active at that timestep
    masks = _make_random_booleans(num_timesteps, num_envs)

    # Now, we compute the overall stats over all observations over all 'active' environments over all timesteps
    overall_stats = _compute_stats(all_obs.reshape(-1, obs_length)[masks.reshape(-1)])
    overall_mean = overall_stats["mean"]
    overall_stdev = overall_stats["stdev"]

    # Make a new RunningNorm instance
    rn = RunningNorm(shape=obs_length, dtype=torch.float32)

    for t in range(num_timesteps):
        # For each timestep, feed the batch of observations and the mask tensor to the normalizer
        obs = all_obs[t]
        active = masks[t]
        rn.update(obs, mask=active)

    # Assert that the reported mean and stdev of the RunningNorm instance are correct
    assert_allclose(rn.mean, overall_mean, atol=tolerance)
    assert_allclose(rn.stdev, overall_stdev, atol=tolerance)