from functools import partial

import jax.numpy as jnp
from jax import jit

from varipeps.peps import PEPS_Tensor
from varipeps.contractions import apply_contraction

from typing import Sequence, List, Tuple, Literal

Corner_Literal = Literal["top-left", "top-right", "bottom-left", "bottom-right"]


@partial(jit, static_argnums=(5, 6))
def _three_site_triangle_workhorse(
    top_left: jnp.ndarray,
    top_right: jnp.ndarray,
    bottom_left: jnp.ndarray,
    bottom_right: jnp.ndarray,
    gates: Tuple[jnp.ndarray, ...],
    traced: Corner_Literal,
    real_result: bool = False,
) -> List[jnp.ndarray]:
    if traced == "top-left":
        one_physical_sites = jnp.tensordot(top_left, top_right, ((3, 4, 5), (2, 3, 4)))
        two_physical_sites = jnp.tensordot(
            bottom_right, bottom_left, ((5, 6, 7), (2, 3, 4))
        )
        transpose_order = (0, 4, 2, 1, 5, 3)
    elif traced == "top-right":
        one_physical_sites = jnp.tensordot(
            top_right, bottom_right, ((3, 4, 5), (2, 3, 4))
        )
        two_physical_sites = jnp.tensordot(
            bottom_left, top_left, ((5, 6, 7), (2, 3, 4))
        )
        transpose_order = (4, 2, 0, 5, 3, 1)
    elif traced == "bottom-left":
        one_physical_sites = jnp.tensordot(
            bottom_left, top_left, ((3, 4, 5), (2, 3, 4))
        )
        two_physical_sites = jnp.tensordot(
            top_right, bottom_right, ((5, 6, 7), (2, 3, 4))
        )
        transpose_order = (0, 2, 4, 1, 3, 5)
    elif traced == "bottom-right":
        one_physical_sites = jnp.tensordot(
            bottom_right, bottom_left, ((3, 4, 5), (2, 3, 4))
        )
        two_physical_sites = jnp.tensordot(top_left, top_right, ((5, 6, 7), (2, 3, 4)))
        transpose_order = (2, 4, 0, 3, 5, 1)
    else:
        raise ValueError('Invalid argument for parameter "traced".')

    density_matrix = jnp.tensordot(
        one_physical_sites, two_physical_sites, ((0, 1, 2, 5, 6, 7), (7, 8, 9, 2, 3, 4))
    )

    density_matrix = density_matrix.transpose(transpose_order)
    density_matrix = density_matrix.reshape(
        density_matrix.shape[0] * density_matrix.shape[1] * density_matrix.shape[2],
        density_matrix.shape[3] * density_matrix.shape[4] * density_matrix.shape[5],
    )

    norm = jnp.trace(density_matrix)

    if real_result:
        return [
            jnp.real(jnp.tensordot(density_matrix, g, ((0, 1), (0, 1))) / norm)
            for g in gates
        ]
    else:
        return [
            jnp.tensordot(density_matrix, g, ((0, 1), (0, 1))) / norm for g in gates
        ]


def calc_three_sites_triangle_without_top_left_multiple_gates(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gates: Sequence[jnp.ndarray],
) -> List[jnp.ndarray]:
    """
    Calculate the three site expectation values for three as triangle ordered
    PEPS tensor and their environment without the top-left tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-right, bottom-left, bottom-right].

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Sequence with the gates which should be applied to the PEPS tensors.
        Gates are expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`list` of :obj:`jax.numpy.ndarray`:
        List with the calculated expectation values of each gate.
    """
    traced_density_matrix_top_left = apply_contraction(
        "ctmrg_top_left", [peps_tensors[0]], [peps_tensor_objs[0]], []
    )

    density_matrix_top_right = apply_contraction(
        "density_matrix_four_sites_top_right",
        [peps_tensors[1]],
        [peps_tensor_objs[1]],
        [],
    )

    density_matrix_bottom_left = apply_contraction(
        "density_matrix_four_sites_bottom_left",
        [peps_tensors[2]],
        [peps_tensor_objs[2]],
        [],
    )

    density_matrix_bottom_right = apply_contraction(
        "density_matrix_four_sites_bottom_right",
        [peps_tensors[3]],
        [peps_tensor_objs[3]],
        [],
    )

    real_result = all(jnp.allclose(g, g.T.conj()) for g in gates)

    return _three_site_triangle_workhorse(
        traced_density_matrix_top_left,
        density_matrix_top_right,
        density_matrix_bottom_left,
        density_matrix_bottom_right,
        tuple(gates),
        "top-left",
        real_result,
    )


def calc_three_sites_triangle_without_top_left_single_gate(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gate: jnp.ndarray,
) -> jnp.ndarray:
    """
    Calculate the two site expectation value for three as triangle ordered
    PEPS tensor and their environment without the top-left tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-right, bottom-left, bottom-right].

    This function just wraps
    :obj:`~varipeps.expectation.three_sites.calc_three_sites_triangle_without_top_left_multiple_gates`.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Gate which should be applied to the PEPS tensors.
        The gate is expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`jax.numpy.ndarray`:
        Calculated expectation value of the gate.
    """
    return calc_three_sites_triangle_without_top_left_multiple_gates(
        peps_tensors, peps_tensor_objs, (gate,)
    )[0]


def calc_three_sites_triangle_without_top_right_multiple_gates(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gates: Sequence[jnp.ndarray],
) -> List[jnp.ndarray]:
    """
    Calculate the three site expectation values for three as triangle ordered
    PEPS tensor and their environment without the top-right tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-left, bottom-left, bottom-right].

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Sequence with the gates which should be applied to the PEPS tensors.
        Gates are expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`list` of :obj:`jax.numpy.ndarray`:
        List with the calculated expectation values of each gate.
    """
    density_matrix_top_left = apply_contraction(
        "density_matrix_four_sites_top_left",
        [peps_tensors[0]],
        [peps_tensor_objs[0]],
        [],
    )

    traced_density_matrix_top_right = apply_contraction(
        "ctmrg_top_right",
        [peps_tensors[1]],
        [peps_tensor_objs[1]],
        [],
    )

    density_matrix_bottom_left = apply_contraction(
        "density_matrix_four_sites_bottom_left",
        [peps_tensors[2]],
        [peps_tensor_objs[2]],
        [],
    )

    density_matrix_bottom_right = apply_contraction(
        "density_matrix_four_sites_bottom_right",
        [peps_tensors[3]],
        [peps_tensor_objs[3]],
        [],
    )

    real_result = all(jnp.allclose(g, g.T.conj()) for g in gates)

    return _three_site_triangle_workhorse(
        density_matrix_top_left,
        traced_density_matrix_top_right,
        density_matrix_bottom_left,
        density_matrix_bottom_right,
        tuple(gates),
        "top-right",
        real_result,
    )


def calc_three_sites_triangle_without_top_right_single_gate(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gate: jnp.ndarray,
) -> jnp.ndarray:
    """
    Calculate the two site expectation value for three as triangle ordered
    PEPS tensor and their environment without the top-right tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-left, bottom-left, bottom-right].

    This function just wraps
    :obj:`~varipeps.expectation.three_sites.calc_three_sites_triangle_without_top_right_multiple_gates`.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Gate which should be applied to the PEPS tensors.
        The gate is expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`jax.numpy.ndarray`:
        Calculated expectation value of the gate.
    """
    return calc_three_sites_triangle_without_top_right_multiple_gates(
        peps_tensors, peps_tensor_objs, (gate,)
    )[0]


def calc_three_sites_triangle_without_bottom_left_multiple_gates(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gates: Sequence[jnp.ndarray],
) -> List[jnp.ndarray]:
    """
    Calculate the three site expectation values for three as triangle ordered
    PEPS tensor and their environment without the bottom-left tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-left, top-right, bottom-right].

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Sequence with the gates which should be applied to the PEPS tensors.
        Gates are expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`list` of :obj:`jax.numpy.ndarray`:
        List with the calculated expectation values of each gate.
    """
    density_matrix_top_left = apply_contraction(
        "density_matrix_four_sites_top_left",
        [peps_tensors[0]],
        [peps_tensor_objs[0]],
        [],
    )

    density_matrix_top_right = apply_contraction(
        "density_matrix_four_sites_top_right",
        [peps_tensors[1]],
        [peps_tensor_objs[1]],
        [],
    )

    traced_density_matrix_bottom_left = apply_contraction(
        "ctmrg_bottom_left",
        [peps_tensors[2]],
        [peps_tensor_objs[2]],
        [],
    )

    density_matrix_bottom_right = apply_contraction(
        "density_matrix_four_sites_bottom_right",
        [peps_tensors[3]],
        [peps_tensor_objs[3]],
        [],
    )

    real_result = all(jnp.allclose(g, g.T.conj()) for g in gates)

    return _three_site_triangle_workhorse(
        density_matrix_top_left,
        density_matrix_top_right,
        traced_density_matrix_bottom_left,
        density_matrix_bottom_right,
        tuple(gates),
        "bottom-left",
        real_result,
    )


def calc_three_sites_triangle_without_bottom_left_single_gate(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gate: jnp.ndarray,
) -> jnp.ndarray:
    """
    Calculate the two site expectation value for three as triangle ordered
    PEPS tensor and their environment without the bottom-left tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-left, top-right, bottom-right].

    This function just wraps
    :obj:`~varipeps.expectation.three_sites.calc_three_sites_triangle_without_bottom_left_multiple_gates`.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Gate which should be applied to the PEPS tensors.
        The gate is expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`jax.numpy.ndarray`:
        Calculated expectation value of the gate.
    """
    return calc_three_sites_triangle_without_bottom_left_multiple_gates(
        peps_tensors, peps_tensor_objs, (gate,)
    )[0]


def calc_three_sites_triangle_without_bottom_right_multiple_gates(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gates: Sequence[jnp.ndarray],
) -> List[jnp.ndarray]:
    """
    Calculate the three site expectation values for three as triangle ordered
    PEPS tensor and their environment without the bottom-right tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-left].

    The gate is applied in the order [top-left, top-right, bottom-left].

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Sequence with the gates which should be applied to the PEPS tensors.
        Gates are expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`list` of :obj:`jax.numpy.ndarray`:
        List with the calculated expectation values of each gate.
    """
    density_matrix_top_left = apply_contraction(
        "density_matrix_four_sites_top_left",
        [peps_tensors[0]],
        [peps_tensor_objs[0]],
        [],
    )

    density_matrix_top_right = apply_contraction(
        "density_matrix_four_sites_top_right",
        [peps_tensors[1]],
        [peps_tensor_objs[1]],
        [],
    )

    density_matrix_bottom_left = apply_contraction(
        "density_matrix_four_sites_bottom_left",
        [peps_tensors[2]],
        [peps_tensor_objs[2]],
        [],
    )

    traced_density_matrix_bottom_right = apply_contraction(
        "ctmrg_bottom_right",
        [peps_tensors[3]],
        [peps_tensor_objs[3]],
        [],
    )

    real_result = all(jnp.allclose(g, g.T.conj()) for g in gates)

    return _three_site_triangle_workhorse(
        density_matrix_top_left,
        density_matrix_top_right,
        density_matrix_bottom_left,
        traced_density_matrix_bottom_right,
        tuple(gates),
        "bottom-right",
        real_result,
    )


def calc_three_sites_triangle_without_bottom_right_single_gate(
    peps_tensors: Sequence[jnp.ndarray],
    peps_tensor_objs: Sequence[PEPS_Tensor],
    gate: jnp.ndarray,
) -> jnp.ndarray:
    """
    Calculate the two site expectation value for three as triangle ordered
    PEPS tensor and their environment without the bottom-left tensor.

    The order of the PEPS sequence have to be
    [top-left, top-right, bottom-left, bottom-right].

    The gate is applied in the order [top-left, top-right, bottom-left].

    This function just wraps
    :obj:`~varipeps.expectation.three_sites.calc_three_sites_triangle_without_bottom_right_multiple_gates`.

    Args:
      peps_tensors (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        The PEPS tensor arrays. Have to be the same objects as the tensor
        attribute of the `peps_tensor_obj` argument.
      peps_tensor_objs (:term:`sequence` of :obj:`~varipeps.peps.PEPS_Tensor`):
        PEPS tensor objects.
      gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
        Gate which should be applied to the PEPS tensors.
        The gate is expected to be a matrix with first axis corresponding to
        the Hilbert space and the second axis corresponding to the dual room.
    Returns:
      :obj:`jax.numpy.ndarray`:
        Calculated expectation value of the gate.
    """
    return calc_three_sites_triangle_without_bottom_right_multiple_gates(
        peps_tensors, peps_tensor_objs, (gate,)
    )[0]