"""
Utility functions for initialize tensors randomly
"""

from __future__ import annotations

import abc
import os
import sys
import warnings

import numpy as np
import jax
import jax.numpy as jnp

from typing import Type, Sequence, Optional
from varipeps.typing import Tensor


class PEPS_Random_Number_Generator:
    """
    Class to maintain a global instance of random number generators
    """

    __instance_jax: Optional[PEPS_Random_Impl] = None
    __instance_np: Optional[PEPS_Random_Impl] = None

    @classmethod
    def get_generator(
        cls, seed: Optional[int] = None, *, backend: str = "jax"
    ) -> PEPS_Random_Impl:
        """
        Class method to obtain the instance of the random number generator for
        the specific backend

        Args:
          seed (:obj:`int`, optional):
            Seed for the random number generator. If there is already a instance
            of the generator, this parameter is ignored.
        Keyword args:
          backend (:obj:`str`, optional):
            Backend which should be used as random number generator. May be
            ``jax`` or ``numpy``. Defaults to ``jax``.
        Returns:
          :obj:`PEPS_Jax_Random` or :obj:`PEPS_Numpy_Random`:
            Instance of random number generator implementation.
        """
        if backend == "jax":
            if cls.__instance_jax is None:
                cls.__instance_jax = PEPS_Jax_Random(seed)
            elif seed is not None:
                warnings.warn(
                    "There is already a random generator instance. The seed parameter is ignored. "
                    "If you want to set a new seed, please call the destroy_state() method before."
                )
            return cls.__instance_jax
        elif backend == "numpy":
            if cls.__instance_np is None:
                cls.__instance_np = PEPS_Numpy_Random(seed)
            elif seed is not None:
                warnings.warn(
                    "There is already a random generator instance. The seed parameter is ignored. "
                    "If you want to set a new seed, please call the destroy_state() method before."
                )
            return cls.__instance_np
        else:
            raise ValueError("Unknown backend")

    @classmethod
    def destroy_state(cls) -> None:
        """
        Destroy the current state of the random number generator.
        """
        cls.__instance_jax = None
        cls.__instance_np = None


class PEPS_Random_Impl(abc.ABC):
    """
    Abstract base class for random number generator implementation.
    """

    @abc.abstractmethod
    def block(
        self, dim: Sequence[int], dtype: Type[np.number], *, normalize: bool = True
    ) -> Tensor:
        """
        Generate a tensor with random numbers.

        Args:
          dim (:term:`sequence` of :obj:`int`):
            Sequence with the dimensions of the tensor
          dtype (:obj:`numpy.dtype` or :obj:`jax.numpy.dtype`):
            Dtype of the generated tensors
        Keyword args:
          normalize (:obj:`bool`, optional):
            Flag if the generated tensors are  normalized. Defaults to True.
        Returns:
          :obj:`jax.numpy.ndarray` or :obj:`numpy.ndarray`:
            Tensor with random numbers and the specified shape.
        """
        pass


class PEPS_Numpy_Random(PEPS_Random_Impl):
    """
    Numpy implementation for the random number generator.

    Args:
      seed (:obj:`int`, optional):
        Seed for the generator.
    """

    def __init__(self, seed: Optional[int] = None):
        self.rng = np.random.default_rng(seed)

    def block(
        self, dim: Sequence[int], dtype: Type[np.number], *, normalize: bool = True
    ) -> np.ndarray:
        if (
            np.dtype(dtype) is np.dtype(np.complex64)
            or np.dtype(dtype) is np.dtype(np.complex128)
            or np.dtype(dtype) is np.dtype(np.complex256)
        ):
            block = self.rng.uniform(-1, 1, dim).astype(dtype) + 1j * self.rng.uniform(
                -1, 1, dim
            ).astype(dtype)
        else:
            block = self.rng.uniform(-1, 1, dim, dtype=dtype)  # type: ignore
        if normalize:
            block /= np.linalg.norm(block)
        return block


class PEPS_Jax_Random(PEPS_Random_Impl):
    """
    Jax implementation for the random number generator.

    Args:
      seed (:obj:`int`, optional):
        Seed for the generator.
    """

    def __init__(self, seed: Optional[int] = None):
        if seed is None:
            seed = int.from_bytes(os.urandom(4), sys.byteorder)

        self.key = jax.random.PRNGKey(seed)

    def block(
        self, dim: Sequence[int], dtype: Type[np.number], *, normalize: bool = True
    ) -> jnp.ndarray:
        if jnp.dtype(dtype) is jnp.dtype(jnp.complex64) or jnp.dtype(
            dtype
        ) is jnp.dtype(jnp.complex128):
            self.key, key1, key2 = jax.random.split(self.key, 3)
            block = jax.random.uniform(key1, dim, minval=-1, maxval=1).astype(
                dtype
            ) + 1j * jax.random.uniform(key2, dim, minval=-1, maxval=1).astype(dtype)
        else:
            self.key, key1 = jax.random.split(self.key, 2)
            block = jax.random.uniform(key1, dim, dtype=dtype, minval=-1, maxval=1)
        if normalize:
            block /= jnp.linalg.norm(block)
        return block

    def positive_block(
        self, dim: Sequence[int], dtype: Type[np.number], *, normalize: bool = True
    ) -> jnp.ndarray:
        if jnp.dtype(dtype) is jnp.dtype(jnp.complex64) or jnp.dtype(
            dtype
        ) is jnp.dtype(jnp.complex128):
            self.key, key1, key2 = jax.random.split(self.key, 3)
            block = jax.random.uniform(key1, dim, minval=0, maxval=1).astype(
                dtype
            ) + 1j * jax.random.uniform(key2, dim, minval=0, maxval=1).astype(dtype)
        else:
            self.key, key1 = jax.random.split(self.key, 2)
            block = jax.random.uniform(key1, dim, dtype=dtype, minval=0, maxval=1)
        if normalize:
            block /= jnp.linalg.norm(block)
        return block

    def semi_positive_block(
        self, dim: Sequence[int], dtype: Type[np.number], *, normalize: bool = True
    ) -> jnp.ndarray:
        if jnp.dtype(dtype) is jnp.dtype(jnp.complex64) or jnp.dtype(
            dtype
        ) is jnp.dtype(jnp.complex128):
            self.key, key1, key2 = jax.random.split(self.key, 3)
            block = jax.random.uniform(key1, dim, minval=-0.3, maxval=1).astype(
                dtype
            ) + 1j * jax.random.uniform(key2, dim, minval=-0.3, maxval=1).astype(dtype)
        else:
            self.key, key1 = jax.random.split(self.key, 2)
            block = jax.random.uniform(key1, dim, dtype=dtype, minval=-0.3, maxval=1)
        if normalize:
            block /= jnp.linalg.norm(block)
        return block


def apply_random_noise_unitcell(unitcell, relative_amplitude=1e-3):
    rng = PEPS_Random_Number_Generator.get_generator()

    def random_noise(a):
        return a + a * rng.block(a.shape, dtype=a.dtype) * relative_amplitude

    new_t = [
        t.replace_tensor(random_noise(t.tensor)) for t in unitcell.get_unique_tensors()
    ]

    return unitcell.replace_unique_tensors(new_t)