# -*- coding: utf-8 -*-
# noinspection PyUnresolvedReferences
r"""
.. _docs-mesh:

Mesh
====

We define an abstract mesh based on an abstract manifold by calling ``ph.mesh`` method,

    .. autofunction:: src.mesh.mesh

As an example,

>>> mesh = ph.mesh(manifold)

The output, ``mesh``, is an instance of :class:`Mesh`. And similarly, it is abstract at this stage.

    .. autoclass:: src.mesh.Mesh
        :members: m, n, manifold

You can print a list of defined meshes by

>>> ph.list_meshes()  # doctest: +ELLIPSIS
Existing meshes:...

"""
from tools.frozen import Frozen
from src.config import _mesh_default_sym_repr
from src.config import _check_sym_repr
from src.config import _parse_lin_repr
from src.config import _mesh_default_lin_repr
from src.spaces.main import set_mesh

from src.config import _mesh_partition_sym_repr, _mesh_partition_lin_repr

_global_meshes = dict()    # all meshes are cached, and all sym_repr and lin_repr are different.



[docs]
def mesh(manifold, sym_repr=None, lin_repr=None):
    """Generate an abstract mesh over an abstract manifold.
    It is actually a wrapper of the ``__init__`` method of :class:`Mesh`.

    Parameters
    ----------
    manifold : :class:`Manifold`
        The abstract manifold this mesh is built on.
    sym_repr : {None, str}, optional
        The symbolic representation of the mesh. If it is ``None``, we will use a pre-set symbolic
        representation. The default is ``None``.
    lin_repr : {None, str}, optional
        The linguistic representation of the mesh. If it is ``None``, we will use a pre-set linguistic
        representation. The default is ``None``.

    Returns
    -------
    mesh : :class:`Mesh`
        The abstract mesh instance.

    """
    return Mesh(
        manifold,
        sym_repr=sym_repr,
        lin_repr=lin_repr,
    )



def _list_meshes():
    """"""
    from src.config import RANK, MASTER_RANK
    if RANK != MASTER_RANK:
        return
    else:
        pass

    print('Existing meshes:')
    print('{:>25} - {}'.format('---------------- symbolic', '<manifold> -------------------------'))
    for rp in _global_meshes:
        print('{:>25} | {}'.format(rp, _global_meshes[rp].manifold))



[docs]
class Mesh(Frozen):   # Mesh -

    def __init__(self, manifold, sym_repr=None, lin_repr=None):
        self._objective = None
        # when initializing, it has no objective instance. And when we generate an objective of this
        # abstract mesh, we store the last objective one with this attribute.

        assert manifold.__class__.__name__ == 'Manifold', f"I need a manifold."
        self._manifold = manifold
        assert manifold._covered_by_mesh is None, f"we already made an abstract mesh for this manifold."
        manifold._covered_by_mesh = self

        if sym_repr is None:
            number_existing_meshes = len(_global_meshes)
            base_repr = _mesh_default_sym_repr
            if number_existing_meshes == 0:
                sym_repr = base_repr
            else:
                sym_repr = base_repr + r'_{' + str(number_existing_meshes) + '}'
        else:
            pass
        sym_repr = _check_sym_repr(sym_repr)

        if lin_repr is None:
            base_repr = _mesh_default_lin_repr
            number_existing_meshes = len(_global_meshes)

            if number_existing_meshes == 0:
                lin_repr = base_repr
            else:
                lin_repr = base_repr + str(number_existing_meshes)

        assert sym_repr not in _global_meshes, \
            f"Manifold symbolic representation is illegal, pls specify a symbolic representation other than " \
            f"{set(_global_meshes.keys())}"

        for _ in _global_meshes:
            _m = _global_meshes[_]
            assert lin_repr != _m._lin_repr
        lin_repr, pure_lin_repr = _parse_lin_repr('mesh', lin_repr)

        self._sym_repr = sym_repr
        self._lin_repr = lin_repr
        self._pure_lin_repr = pure_lin_repr
        _global_meshes[sym_repr] = self
        if len(_global_meshes) == 1:  # we just initialize the first mesh
            set_mesh(self)  # we set it as the default mesh

        self._boundary = None
        self._interface = None
        self._inclusion = None
        self._freeze()

    @property
    def ndim(self):
        """"""
        return self._manifold.ndim

    @property
    def n(self):
        """The dimensions of the manifold."""
        return self.ndim

    @property
    def m(self):
        """The dimensions of the embedding space."""
        return self._manifold.m

    def __repr__(self):
        """"""
        super_repr = super().__repr__().split('object')[-1]
        return '<Mesh ' + self._sym_repr + super_repr  # this will be unique.

    @property
    def manifold(self):
        """The manifold this mesh is built on."""
        return self._manifold

    # it is regarded as an operator, so do not use @property
    def boundary(self):
        """Give a mesh of dimensions (n-1) on the boundary manifold."""
        if self._boundary is None:
            manifold_boundary = self.manifold.boundary()
            if manifold_boundary.__class__.__name__ == 'Manifold':
                self._boundary = Mesh(
                    manifold_boundary,
                    sym_repr=r'\eth' + self._sym_repr,
                    lin_repr=r'boundary-of-' + self._pure_lin_repr
                )
                self._boundary._inclusion = self
            elif manifold_boundary.__class__.__name__ == 'NullManifold':
                self._boundary = NullMesh(manifold_boundary)
            else:
                raise NotImplementedError()
        return self._boundary

    def inclusion(self):
        """Give the mesh of dimensions (n+1) on the inclusion manifold."""
        return self._inclusion

    def boundary_partition(self, *sym_reprs, config_name=None):
        """Define boundary sections by partition the mesh boundary into sections defined by `*sym_reprs`."""
        if self._boundary is None:
            _ = self.boundary()
        else:
            pass

        _boundary = self.manifold.boundary()
        sub_manifolds = _boundary.partition(*sym_reprs, config_name=config_name)
        for sub_manifold in sub_manifolds:
            sr0, sr1 = _mesh_partition_sym_repr
            if sub_manifold._covered_by_mesh is None:
                self.__class__(
                    sub_manifold,
                    sym_repr=sr0 + sub_manifold._sym_repr + sr1,
                    lin_repr=_mesh_partition_lin_repr + sub_manifold._pure_lin_repr,
                )  # it will be automatically saved to _global_meshes.
            else:
                pass



class NullMesh(Frozen):
    """A mesh that is constructed upon a null manifold."""

    def __init__(self, null_manifold):
        self._null_manifold = null_manifold
        self._freeze()

    @property
    def ndim(self):
        return self._null_manifold.ndim