# -*- coding: utf-8 -*-
# noinspection PyUnresolvedReferences
r"""

.. note::

    *phyem* is ready by itself with default global parameters. You can direct initialize a simulation with these
    default global parameters.

If you want to customize global parameters, you can do use following functions:

    .. autofunction:: set_embedding_space_dim

    .. autofunction:: set_high_accuracy

    .. autofunction:: set_pr_cache

For example,

>>> ph.config.set_embedding_space_dim(2)
>>> ph.config.set_high_accuracy(True)
>>> ph.config.set_pr_cache(False)

These commands set the embedding space to be 2-dimensional, ask *phyem* to have a high accuracy and not
to use *pr* cache (or to present *pr* outputs in real time). These parameters are same to the default values; they have
no effects (thus we preferably omit them).

"""

_global_variables = {
    'embedding_space_dim': 2,      # default embedding_space_dim is 2.
    'zero_entry_threshold': 1e-12  # set to be zero when it is lower than this
}


# MPI setting
try:
    from mpi4py import MPI
    COMM = MPI.COMM_WORLD
    RANK: int = COMM.Get_rank()
    SIZE: int = COMM.Get_size()
except ModuleNotFoundError:  # no `mpi4py` installed.
    COMM = None
    RANK = 0
    SIZE: int = 1

MASTER_RANK: int = 0  # DO NOT change this


_setting = {
    "block": True,   # matplot block
    "cache_folder": '__phcache__',  # the default cache folder name
    "pr_cache": False,   # if this is True, all pr will save to the cache folder and will not show()
    "pr_cache_maximum": 3,  # We clean toward this number when it is more than twice
    "pr_cache_counter": 0,  # we have cache how many times?
    "pr_cache_subfolder": '',  # we cache where in particular?
    "pr_cache_folder_prefix": 'Pr_',  # we cache where in particular?
    "pr_cache_current_folder": 'current',  # we cache where in particular?
    "high_accuracy": True,  # influence sparsity of some matrices.
    "auto_cleaning": True,  # automatic memory saving
}



[docs]
def set_embedding_space_dim(ndim):
    """To set the dimensions of the space where our simulation problem is defined, i.e., the embedding space.
    The default dimensions are 2.

    Parameters
    ----------
    ndim : {1, 2, 3}
        *phyem* can only simulate problems in 1-, 2- or 3-d space.

    """
    assert ndim % 1 == 0 and ndim > 0, f"ndim={ndim} is wrong, it must be a positive integer."
    _global_variables['embedding_space_dim'] = ndim
    _clear_all()   # whenever we change or reset the space dim, we clear all abstract objects.
    _clear_pr_cache()




[docs]
def set_high_accuracy(_bool):
    """*phyem* may trade for higher accuracy in the cost of losing a little performance. Turn this feature
    on or off through this function. The default value is ``True``.

    For example, *phyem* can use numerical quadrature of a higher degree (thus of higher accuracy)
    to compute the mass matrices, which could
    decrease the sparsity and sequentially slow down the assembling and solving processes slightly.

    Parameters
    ----------
    _bool : bool
        If ``_bool`` is ``True``, *phyem* occasionally has a higher accuracy.
        The real effect depends on the problem you are solving.
    """
    assert isinstance(_bool, bool), f"give me True or False"
    _setting['high_accuracy'] = _bool




[docs]
def set_pr_cache(_bool):
    """ The abbreviation `pr` stands for `print representation`.
    Many classes in *phyem* have the ``pr`` method. Calling it of an instance by ``.pr()`` will usually invoke
    the ``matplotlib`` and ``LaTeX`` pakages to render a picture which proper illustrates the instance.
    By turning the *pr* cache on, all outputs resulting from ``pr`` methods will be saved to
    ``./__phcache__/Pr_current/`` instead of being shown in real time.

    The default value is ``False``.

    Parameters
    ----------
    _bool : bool
        If ``_bool`` is ``True``, all outputs resulting from ``pr`` methods will be saved
        to ``./__phcache__/Pr_current/``.

    """
    assert isinstance(_bool, bool), f"give me True or False"
    _setting['pr_cache'] = _bool



def set_auto_cleaning(_bool_or_factor):
    """

    Parameters
    ----------
    _bool_or_factor

    Returns
    -------

    """
    if isinstance(_bool_or_factor, bool):
        pass
    elif isinstance(_bool_or_factor, (int, float)):
        _bool_or_factor = int(_bool_or_factor)
        assert _bool_or_factor >= 2, f"must set clean factor >= 2."
    else:
        raise Exception(f"clean factor to be a bool or a positive integer.")
    _setting['auto_cleaning'] = _bool_or_factor


def _pr_cache(fig, filename=None):
    """

    Parameters
    ----------
    fig
    filename :
        The filename received from particular pr method. It will be put into the final filename.

    Returns
    -------

    """
    if RANK != MASTER_RANK:
        return
    else:
        pass

    from tools.os_ import mkdir, empty_dir, isdir
    phcache_folder = _setting[r'cache_folder']
    if isdir(phcache_folder):
        pass
    else:
        mkdir(phcache_folder)

    from time import time
    from tools.miscellaneous.random_ import string_digits
    import matplotlib.pyplot as plt
    import matplotlib
    matplotlib.use('TkAgg')

    if filename is None:
        filename_personal = rf'/{_setting["pr_cache_counter"]}.png'
    else:
        filename_personal = rf'/{_setting["pr_cache_counter"]}_{filename}.png'

    if _setting["pr_cache_counter"] == 0:
        str_time = str(time()).split('.')[0]
        subfolder_name = (
            phcache_folder + r"/" + _setting["pr_cache_folder_prefix"] +
            str_time + '_' + string_digits(12)  # how we name the random folder
        )
        _setting["pr_cache_subfolder"] = subfolder_name
        mkdir(subfolder_name)
    else:
        subfolder_name = _setting["pr_cache_subfolder"]
        assert subfolder_name != '', f"something is wrong!"

    plt.savefig(subfolder_name + filename_personal, bbox_inches='tight', dpi=200)

    folder_current = (
        phcache_folder + '/' + _setting["pr_cache_folder_prefix"] + _setting["pr_cache_current_folder"]
    )

    if _setting["pr_cache_counter"] == 0:
        mkdir(folder_current)   # do nothing if the folder exists
        empty_dir(folder_current)  # remove old files if there is any.
    else:
        pass

    plt.savefig(folder_current + filename_personal, bbox_inches='tight', dpi=200)

    _setting["pr_cache_counter"] += 1
    plt.close(fig)


def _set_matplot_block(block):
    r""""""
    _setting['block'] = block


def _clear_pr_cache():
    r""""""
    _setting["pr_cache_counter"] = 0  # reset cache counting
    _setting["pr_cache_subfolder"] = ''  # clean cache_subfolder

    if RANK == MASTER_RANK:
        from tools.os_ import listdir, isdir, mkdir, rmdir, empty_dir

        phcache_folder = _setting[r'cache_folder']
        if isdir(phcache_folder):
            pass
        else:
            mkdir(phcache_folder)
        all_ph_cache_files = listdir(phcache_folder)  # including folder names.

        pr_prefix = _setting['pr_cache_folder_prefix']
        current_file = _setting["pr_cache_folder_prefix"] + _setting["pr_cache_current_folder"]
        len_prefix = len(pr_prefix)
        number_pr_files = 0  # excluding the current file
        pr_files = list()  # excluding the current file
        for cache_file in all_ph_cache_files:
            if cache_file[:len_prefix] == pr_prefix and cache_file != current_file:
                number_pr_files += 1
                pr_files.append(cache_file)
            else:
                pass
        pr_cache_maximum = _setting["pr_cache_maximum"]
        assert pr_cache_maximum > 1 and pr_cache_maximum % 1 == 0, \
            f"_setting['pr_cache_maximum'] = {pr_cache_maximum} is illegal, give me a positive integer (>1)."
        if number_pr_files >= 2 * pr_cache_maximum:
            files_2b_clean = pr_files[:pr_cache_maximum + 1]
            for file in files_2b_clean:
                empty_dir(phcache_folder + r"/" + file)
                rmdir(phcache_folder + r"/" + file)
        else:
            pass
    else:
        pass


def _clear_all():
    r"""clear all abstract objects.

    Make sure that, when we add new global cache, put it here.
    """
    from src.algebra.array import _global_root_arrays
    from src.algebra.nonlinear_operator import _global_nop_arrays
    from src.form.main import _global_forms
    from src.form.main import _global_root_forms_lin_dict
    _clear_a_dict(_global_root_arrays)
    _clear_a_dict(_global_nop_arrays)
    _clear_a_dict(_global_forms)
    _clear_a_dict(_global_root_forms_lin_dict)
    from src.form.parameters import _global_root_constant_scalars
    _clear_a_dict(_global_root_constant_scalars)
    from src.form.main import _global_form_variables
    _global_form_variables['update_cache'] = True

    from src.manifold import _global_manifolds
    _clear_a_dict(_global_manifolds)
    from src.mesh import _global_meshes
    _clear_a_dict(_global_meshes)

    from src.time_sequence import _global_abstract_time_sequence
    from src.time_sequence import _global_abstract_time_interval
    _clear_a_dict(_global_abstract_time_sequence)
    _clear_a_dict(_global_abstract_time_interval)

    from src.spaces.main import _config
    _config['current_mesh'] = ''
    from src.spaces.main import _degree_cache
    from src.spaces.main import _space_set
    from src.spaces.main import _mesh_set
    _clear_a_dict(_degree_cache)
    _clear_a_dict(_space_set)
    _clear_a_dict(_mesh_set)

    from src.wf.term.main import _global_wf_terms
    _clear_a_dict(_global_wf_terms)


def _clear_a_dict(the_dict):
    """"""
    keys = list(the_dict.keys())
    for key in keys:
        del the_dict[key]


def get_embedding_space_dim():
    """"""
    return _global_variables['embedding_space_dim']


# lib setting config ...............
_abstract_time_sequence_default_lin_repr = 'Ts'
_manifold_default_lin_repr = 'Manifold'
_mesh_default_lin_repr = 'Mesh'


_global_lin_repr_setting = {
    # objects
    'manifold': [r'\underline{', '}'],
    'mesh': [r'\textrm{', r'}'],
    'form': [r'\textsf{', r'}'],
    'scalar_parameter': [r'\textsc{', r'}'],
    'abstract_time_sequence': [r'\textit{', r'}'],
    'abstract_time_interval': [r'\texttt{', r'}'],   # do not use `textsc`.
    'abstract_time_instant': [r'\textsl{', r'}'],
    'array': [r'\textbf{', r'}'],
    'multidimensional_array': [r'\textlf{', r'}'],
    'TermNonLinearAlgebraicProxy': [r'\textmd{', r'}'],
}


def _parse_lin_repr(obj, pure_lin_repr):
    r""""""
    assert isinstance(pure_lin_repr, str) and len(pure_lin_repr) > 0, \
        f"linguistic_representation must be str of length > 0."
    assert all([_ not in r"{$\}" for _ in pure_lin_repr]), (
            f"pure_lin_repr={pure_lin_repr} illegal, cannot contain" + r"'{\}'.")
    start, end = _global_lin_repr_setting[obj]
    return start + pure_lin_repr + end, pure_lin_repr


def _parse_type_and_pure_lin_repr(lin_repr):
    r""""""
    for what in _global_lin_repr_setting:
        key = _global_lin_repr_setting[what][0]
        lk = len(key)
        if lin_repr[:lk] == key:
            return what, lin_repr[lk:-1]


_manifold_default_sym_repr = r'\mathcal{M}'
_mesh_default_sym_repr = r'\mathfrak{M}'
_abstract_time_sequence_default_sym_repr = r'\mathtt{T}^S'
_abstract_time_interval_default_sym_repr = r'\Delta t'


_mesh_partition_sym_repr = [r"\partial\mathfrak{M}\left(", r"\right)"]
_mesh_partition_lin_repr = r"mesh-over: "

_manifold_partition_lin_repr = "=sub"


def _check_sym_repr(sym_repr):   # not used for forms as they have their own checker.
    """"""
    assert isinstance(sym_repr, str), f"sym_repr = {sym_repr} illegal, must be a string."
    pure_sym_repr = sym_repr.replace(' ', '')
    assert len(pure_sym_repr) > 0, f"sym_repr={sym_repr} illegal, it cannot be empty."
    return sym_repr


_form_evaluate_at_repr_setting = {
    'sym': [r"\left.", r"\right|^{(", ")}"],
    'lin': "@",
}

_root_form_ap_vec_setting = {
    'sym': [r"\vec{", r"}"],
    'lin': "+vec"
}

_transpose_text = '-transpose'

_abstract_array_factor_sep = r'\{*\}'
_abstract_array_connector = r'\{@\}'


_global_operator_lin_repr_setting = {  # coded operators
    'plus': r" $+$ ",
    'minus': r" $-$ ",
    'wedge': r" $\wedge$ ",
    'Hodge': r'$\star$ ',
    'd': r'$\mathrm{d}$ ',
    'codifferential': r'$\mathrm{d}^{\ast}$ ',
    'time_derivative': r'$\partial_{t}$ ',
    'trace': r'\emph{tr} ',

    'L2-inner-product': [r"$($", r'\emph{,} ', r"$)$ \emph{over} "],
    'duality-pairing': [r"$<$", r'\emph{,} ', r"$>$ \emph{over} "],

    'division': r' \emph{divided by} ',
    'multiply': r' \emph{multiply} ',

    'cross_product': r"$\times$",
    'convect': r"$\cdot\nabla$",
    'tensor_product': r"$\otimes$",

    'projection': r'$\pi$ '
}


_non_root_lin_sep = [r'\{', r'\}']


_global_operator_sym_repr_setting = {  # coded operators
    'plus': r"+",
    'minus': r"-",
    'wedge': r"{\wedge}",
    'Hodge': r'{\star}',
    'd': r'\mathrm{d}',
    'codifferential': r'\mathrm{d}^{\ast}',
    'time_derivative': r'\partial_{t}',
    'trace': r'\mathrm{tr}',
    'division': [r'\frac{', r'}{', r"}"],

    'cross_product': r"{\times}",
    'tensor_product': r"{\otimes}",
    'convect': r"{\cdot\nabla}",

    'projection': r'{\pi}'
}


_wf_term_default_simple_patterns = {   # use only str to represent a simple pattern.
    # indicator : simple pattern
    '(pt,)': '(partial_t rf, f)',   # (partial_time_derivative of root-sf, sf)
    '(cd,)': '(codifferential f, f)',

    # below, we have simple patterns only for root-sf.
    '(rt,rt)': '(rf, rf)',
    '<|>': r"$\left<\left. \mathrm{rf} \right| \mathrm{rf} \right>$",              # <A|B>
    '(d,)': '(d rf, rf)',
    '<d,>': '<d rf, dual-rf>',
    '(,d)': '(rf, d rf)',
    '<,d>': '<dual-rf, d rf>',

    '(d,d)': '(d rf, d rf)',

    '(d(*A),B)': r"$\left(\mathrm{d}\left(\star A\right),B\right)$",

    '(<db>,d<b>)': '(root-diagonal-bf, d root-bf)',

    '<tr star | tr >': r'$\left\langle\right.$ tr star rf $|$ trace rf$\left.\right\rangle$',
    '<tr star | tr > - restrict': r'$\left\langle\right.$ tr star rf $||$ trace rf$\left.\right\rangle$',

    '(A, trB)': r"$(A, \mathrm{tr} B)$",
    '(trB, A)': r"$(\mathrm{tr} B, A)$",

    '<*x*|C>': r'$\left<\left.\mathrm{krf} \times \mathrm{krf} \right| \mathrm{rf}\right>$',
    '<Ax*|C>': r'$\left<\left.\mathrm{rf} \times \mathrm{krf} \right| \mathrm{rf}\right>$',
    '<*xB|C>': r'$\left<\left.\mathrm{krf} \times \mathrm{rf} \right| \mathrm{rf}\right>$',

    '<*x*|d(C)>': r'$\left<\left.\mathrm{krf} \times \mathrm{krf} \right| \mathrm{d}(\mathrm{rf})\right>$',

    '(* .V *, C)': r"$\left(\mathrm{krf} \cdot\nabla \mathrm{krf}, \mathrm{rf}\right)$",

    '<AxB|CxD>': r"$\left<\left.\mathrm{rf} \times \mathrm{rf} \right| \mathrm{rf} \times \mathrm{rf}\right>$",
    '<*x*|*xD>': r"$\left<\left.\mathrm{krf} \times \mathrm{krf} \right| \mathrm{krf} \times \mathrm{rf}\right>$",

    '(,d-pi)': '(rf, d(pi(rf)))',

    '(*x*,)': r'(krf $\times$ krf, rf)',   # vector
    '(*x,)': r'(krf $\times$ rf, rf)',
    '(x*,)': r'(rf $\times$ krf, rf)',

    '(*x*,*x)': r"(krf $\times$ krf, krf $\times$ rf)",  # vector , (*A x *B, *C x D)
    '(x*,*x)': r"(rf $\times$ krf, krf $\times$ rf)",    # matrix , (A x *B, *C x D)

    '(*x,d)': r"(krf $\times$ rf, d rf)",
    '(x*,d)': r"(rf $\times$ krf, d rf)",
    '(*x*,d)': r"(krf $\times$ krf, d rf)",   # vector

    '(x,)': r'(rf $\times$ rf, rf)',   # nonlinear term.

    '(d0*,0*tp)': r'(d krf-0, krf-0 $\otimes$ rf)',
    '(d0*,tp0*)': r'(d krf-0, rf $\otimes$ krf-0)',
    '(d,0*tp0*)': r'(d rf, krf-0 $\otimes$ krf-0)',
    '(d,tp):1K': r'(d rf, rf $\otimes$ rf):1K',
    '(d,tp):2K': r'(d rf, rf $\otimes$ rf):2K',
    '(d,tp)': r'(d rf, rf $\otimes$ rf)',

    '(,tp):1K': r'(rf, rf $\otimes$ rf):1K',
    '(,tp):2K': r'(rf, rf $\otimes$ rf):2K',
    '(,tp)': r'(rf, rf $\otimes$ rf)',
}

_pde_test_form_lin_repr = 'th-test-form'

_nonlinear_ap_test_form_repr = {
    'sym': r' \wr ',
    'lin': ' >=~=< ',
}