# -*- coding: utf-8 -*-
r"""
.. _docs-manifold:

Manifold
========

We define an abstract bounded, connected and contractible
computational domain (manifold) by calling ``ph.manifold`` method,

    .. autofunction:: src.manifold.manifold

A common call is

>>> manifold = ph.manifold(2)

The output, ``manifold``, is an instance of :class:`Manifold`. It is abstract at this stage because we do not
specify any exact parameters, for example size and shape, of it.

    .. autoclass:: src.manifold.Manifold
        :members: m, n

"""
import sys

if './' not in sys.path:
    sys.path.append('./')

from tools.frozen import Frozen
from src.config import get_embedding_space_dim
from src.config import _manifold_default_sym_repr
from src.config import _check_sym_repr
from src.config import _parse_lin_repr
from src.config import _manifold_default_lin_repr
from src.config import _manifold_partition_lin_repr

_global_manifolds = dict()  # all manifolds are cached, and all sym_repr and lin_repr are different.



[docs]
def manifold(
        ndim,
        sym_repr=None,
        lin_repr=None,
        periodic=False
):
    r"""Generate an abstract manifold. It is actually a wrapper of the ``__init__`` method of :class:`Manifold`.

    Parameters
    ----------
    ndim : int
        The dimensions of the manifold. It must be lower than or equal to dimensions of the embedding space.
    sym_repr : {None, str}, optional
        The symbolic representation of the manifold. 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 manifold. If it is ``None``, we will use a pre-set linguistic
        representation. The default is ``None``.
    periodic : bool, optional
        If this is set to ``True``, the manifold is a periodic. Otherwise, it is not periodic.
        The default is ``True``.

    Returns
    -------
    manifold : :class:`Manifold`
        The abstract manifold instance.

    """
    return Manifold(ndim, sym_repr=sym_repr, lin_repr=lin_repr, periodic=periodic)



def find_manifold(manifold_sym_repr):
    r""""""
    return _global_manifolds[manifold_sym_repr]



[docs]
class Manifold(Frozen):

    def __init__(
        self, ndim,
        sym_repr=None,
        lin_repr=None,
        periodic=False,   # means fully periodic
        # add other representations here.
    ):
        r""""""
        embedding_space_ndim = get_embedding_space_dim()
        assert ndim % 1 == 0 and 0 <= ndim <= embedding_space_ndim, \
            f"manifold ndim={ndim} is wrong. Is should be an integer and be in range [0, {embedding_space_ndim}]. " \
            f"You change change the dimensions of the embedding space using function 'config.set_embedding_space_dim'."
        self._ndim = ndim
        if sym_repr is None:
            base_repr = _manifold_default_sym_repr
            number_existing_manifolds = len(_global_manifolds)

            if number_existing_manifolds == 0:
                sym_repr = base_repr
            else:
                sym_repr = base_repr + r'_{' + str(number_existing_manifolds) + '}'
        else:
            pass
        sym_repr = _check_sym_repr(sym_repr)

        if lin_repr is None:
            base_repr = _manifold_default_lin_repr
            number_existing_manifolds = len(_global_manifolds)

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

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

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

        self._sym_repr = sym_repr
        self._lin_repr = lin_repr
        self._pure_lin_repr = pure_lin_repr
        _global_manifolds[sym_repr] = self

        assert isinstance(periodic, bool), f"is_periodic must be bool type."
        self._is_periodic = periodic

        self._udg = None  # if it has an udg_repr representation.
        self._boundary = None
        self._inclusion = None  # not None for boundary manifold. Will be set when initialize a boundary manifold.
        self._sub_manifolds = {  # the sub-manifolds of the same dimensions. Using sym_repr as cache key.
            self._sym_repr: self
        }
        self._partitions = {
            '0': (self, )
        }
        self._covered_by_mesh = None  # if we have generated an abstract mesh for it, return the mesh
        self._freeze()

    @property
    def esd(self):
        r""""""
        return get_embedding_space_dim()

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

    @property
    def ndim(self):
        r""""""
        return self._ndim

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

    @property
    def udg(self):
        r""""""
        return self._udg

    def is_periodic(self):
        r""""""
        return self._is_periodic

    def __repr__(self):
        r""""""
        super_repr = super().__repr__().split('object')[-1]
        return f'<Manifold {self._sym_repr}' + super_repr  # this must be unique.

    def boundary(self, sym_repr=None):
        r""""""
        if self._boundary is None:
            if self.ndim == 0:
                return NullManifold('Null')
            elif self.is_periodic():
                return NullManifold(self.ndim-1)
            else:
                if sym_repr is None:
                    sym_repr = r'\partial' + self._sym_repr
                self._boundary = Manifold(
                    self.ndim-1,
                    sym_repr=sym_repr,
                    lin_repr=f'boundary-of-{self._pure_lin_repr}',
                    periodic=True,
                )
                self._boundary._inclusion = self
        return self._boundary

    def inclusion(self):
        r""""""
        return self._inclusion

    def cap(self, other, sym_repr=None):
        r""""""
        raise NotImplementedError()

    def interface(self, other, sym_repr=None):
        r""""""
        raise NotImplementedError()

    def partition(self, *submanifolds_sym_repr, config_name=None):
        r"""partition of the manifold."""
        for sym_repr in submanifolds_sym_repr:
            assert isinstance(sym_repr, str), f"please put sym_repr of partitions in str."
        num_of_partitions = len(submanifolds_sym_repr)
        assert num_of_partitions >= 2 and num_of_partitions % 2 == 0, f"I need a integer >= 2."
        partitions = tuple()

        for i in range(num_of_partitions):
            sym_repr = submanifolds_sym_repr[i]
            if sym_repr in self._sub_manifolds:
                pass
            else:
                j = len(self._sub_manifolds)
                while 1:
                    lin_repr = self._pure_lin_repr + _manifold_partition_lin_repr + f'{str(j)}'
                    occupied = False
                    for _sub_sym_repr in self._sub_manifolds:
                        if lin_repr == self._sub_manifolds[_sub_sym_repr]:
                            occupied = True
                        else:
                            pass
                    if occupied:
                        j += 1
                    else:
                        break

                self._sub_manifolds[sym_repr] = Manifold(
                    self.ndim,
                    sym_repr=sym_repr,
                    lin_repr=lin_repr,
                )
            partitions += (self._sub_manifolds[sym_repr],)

        if config_name is None:
            i = len(self._partitions)
            while 1:
                if str(i) not in self._partitions:
                    break
                else:
                    i += 1
            config_name = str(i)
        else:
            pass

        partitions_set = set(partitions)
        existing = False
        existing_config = None
        for existing_config in self._partitions:
            existing_partitions = set(self._partitions[existing_config])
            if partitions_set == existing_partitions:
                existing = True
                break
        if existing:
            return self._partitions[existing_config]
        else:
            self._partitions[config_name] = partitions
            return partitions

    def _manifold_text(self):
        r"""generate text for printing representations."""
        return rf'In ${self._sym_repr}\subset\mathbb' + '{R}^{' + str(get_embedding_space_dim()) + '}$, '



class NullManifold(Frozen):
    r""""""

    def __init__(self, ndim):
        r""""""
        self._ndim = ndim
        self._freeze()

    @property
    def ndim(self):
        r""""""
        return self._ndim


if __name__ == '__main__':
    # python src/manifold.py
    import __init__ as ph

    m1 = ph.manifold(3)
    m0 = m1.boundary()
    print(m0, m0.inclusion())