"""
Return cached data from minions
"""

import fnmatch
import logging
import os

import salt.cache
import salt.config
import salt.fileserver.gitfs
import salt.payload
import salt.pillar.git_pillar
import salt.runners.winrepo
import salt.utils.args
import salt.utils.gitfs
import salt.utils.master
from salt.exceptions import SaltInvocationError
from salt.fileserver import clear_lock as _clear_lock

log = logging.getLogger(__name__)

__func_alias__ = {
    "list_": "list",
}


def grains(tgt, tgt_type="glob", **kwargs):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Return cached grains of the targeted minions.

    tgt
        Target to match minion ids.

        .. versionchanged:: 2017.7.5,2018.3.0
            The ``tgt`` argument is now required to display cached grains. If
            not used, the function will not return grains. This optional
            argument will become mandatory in the Salt ``3001`` release.

    tgt_type
        The type of targeting to use for matching, such as ``glob``, ``list``,
        etc.

    CLI Example:

    .. code-block:: bash

        salt-run cache.grains '*'
    """
    pillar_util = salt.utils.master.MasterPillarUtil(
        tgt, tgt_type, use_cached_grains=True, grains_fallback=False, opts=__opts__
    )
    cached_grains = pillar_util.get_minion_grains()
    return cached_grains


def pillar(tgt=None, tgt_type="glob", **kwargs):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Return cached pillars of the targeted minions if tgt is set.
    If tgt is not set will return cached pillars for all minions.

    CLI Example:

    .. code-block:: bash

        salt-run cache.pillar
    """
    pillar_util = salt.utils.master.MasterPillarUtil(
        tgt,
        tgt_type,
        use_cached_grains=True,
        grains_fallback=False,
        use_cached_pillar=True,
        pillar_fallback=False,
        opts=__opts__,
    )
    cached_pillar = pillar_util.get_minion_pillar()
    return cached_pillar


def mine(tgt=None, tgt_type="glob", **kwargs):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Return cached mine data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.mine
    """
    pillar_util = salt.utils.master.MasterPillarUtil(
        tgt,
        tgt_type,
        use_cached_grains=False,
        grains_fallback=False,
        use_cached_pillar=False,
        pillar_fallback=False,
        opts=__opts__,
    )
    cached_mine = pillar_util.get_cached_mine_data()
    return cached_mine


def _clear_cache(
    tgt=None,
    tgt_type="glob",
    clear_pillar_flag=False,
    clear_grains_flag=False,
    clear_mine_flag=False,
    clear_mine_func_flag=None,
):
    """
    Clear the cached data/files for the targeted minions.
    """
    if tgt is None:
        return False

    pillar_util = salt.utils.master.MasterPillarUtil(
        tgt,
        tgt_type,
        use_cached_grains=True,
        grains_fallback=False,
        use_cached_pillar=True,
        pillar_fallback=False,
        opts=__opts__,
    )
    return pillar_util.clear_cached_minion_data(
        clear_pillar=clear_pillar_flag,
        clear_grains=clear_grains_flag,
        clear_mine=clear_mine_flag,
        clear_mine_func=clear_mine_func_flag,
    )


def clear_pillar(tgt=None, tgt_type="glob"):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Clear the cached pillar data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.clear_pillar
    """
    return _clear_cache(tgt, tgt_type, clear_pillar_flag=True)


def clear_grains(tgt=None, tgt_type="glob"):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Clear the cached grains data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.clear_grains
    """
    return _clear_cache(tgt, tgt_type, clear_grains_flag=True)


def clear_mine(tgt=None, tgt_type="glob"):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Clear the cached mine data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.clear_mine
    """
    return _clear_cache(tgt, tgt_type, clear_mine_flag=True)


def clear_mine_func(tgt=None, tgt_type="glob", clear_mine_func_flag=None):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Clear the cached mine function data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.clear_mine_func tgt='*' clear_mine_func_flag='network.interfaces'
    """
    return _clear_cache(tgt, tgt_type, clear_mine_func_flag=clear_mine_func_flag)


def clear_all(tgt=None, tgt_type="glob"):
    """
    .. versionchanged:: 2017.7.0
        The ``expr_form`` argument has been renamed to ``tgt_type``, earlier
        releases must use ``expr_form``.

    Clear the cached pillar, grains, and mine data of the targeted minions

    CLI Example:

    .. code-block:: bash

        salt-run cache.clear_all
    """
    return _clear_cache(
        tgt,
        tgt_type,
        clear_pillar_flag=True,
        clear_grains_flag=True,
        clear_mine_flag=True,
    )


def clear_git_lock(role, remote=None, **kwargs):
    """
    .. versionadded:: 2015.8.2

    Remove the update locks for Salt components (gitfs, git_pillar, winrepo)
    which use gitfs backend code from salt.utils.gitfs.

    .. note::
        Running :py:func:`cache.clear_all <salt.runners.cache.clear_all>` will
        not include this function as it does for pillar, grains, and mine.

        Additionally, executing this function with a ``role`` of ``gitfs`` is
        equivalent to running ``salt-run fileserver.clear_lock backend=git``.

    role
        Which type of lock to remove (``gitfs``, ``git_pillar``, or
        ``winrepo``)

    remote
        If specified, then any remotes which contain the passed string will
        have their lock cleared. For example, a ``remote`` value of **github**
        will remove the lock from all github.com remotes.

    type : update,checkout,mountpoint
        The types of lock to clear. Can be one or more of ``update``,
        ``checkout``, and ``mountpoint``, and can be passed either as a
        comma-separated or Python list.

        .. versionadded:: 2015.8.8
        .. versionchanged:: 2018.3.0
            ``mountpoint`` lock type added

    CLI Examples:

    .. code-block:: bash

        salt-run cache.clear_git_lock gitfs
        salt-run cache.clear_git_lock git_pillar
        salt-run cache.clear_git_lock git_pillar type=update
        salt-run cache.clear_git_lock git_pillar type=update,checkout
        salt-run cache.clear_git_lock git_pillar type='["update", "mountpoint"]'
    """
    kwargs = salt.utils.args.clean_kwargs(**kwargs)
    type_ = salt.utils.args.split_input(
        kwargs.pop("type", ["update", "checkout", "mountpoint"])
    )
    if kwargs:
        salt.utils.args.invalid_kwargs(kwargs)

    if role == "gitfs":
        git_objects = [
            salt.utils.gitfs.GitFS(
                __opts__,
                __opts__["gitfs_remotes"],
                per_remote_overrides=salt.fileserver.gitfs.PER_REMOTE_OVERRIDES,
                per_remote_only=salt.fileserver.gitfs.PER_REMOTE_ONLY,
            )
        ]
    elif role == "git_pillar":
        git_objects = []
        for ext_pillar in __opts__["ext_pillar"]:
            key = next(iter(ext_pillar))
            if key == "git":
                if not isinstance(ext_pillar["git"], list):
                    continue
                obj = salt.utils.gitfs.GitPillar(
                    __opts__,
                    ext_pillar["git"],
                    per_remote_overrides=salt.pillar.git_pillar.PER_REMOTE_OVERRIDES,
                    per_remote_only=salt.pillar.git_pillar.PER_REMOTE_ONLY,
                    global_only=salt.pillar.git_pillar.GLOBAL_ONLY,
                )
                git_objects.append(obj)
    elif role == "winrepo":
        winrepo_dir = __opts__["winrepo_dir"]
        winrepo_remotes = __opts__["winrepo_remotes"]

        git_objects = []
        for remotes, base_dir in (
            (winrepo_remotes, winrepo_dir),
            (__opts__["winrepo_remotes_ng"], __opts__["winrepo_dir_ng"]),
        ):
            obj = salt.utils.gitfs.WinRepo(
                __opts__,
                remotes,
                per_remote_overrides=salt.runners.winrepo.PER_REMOTE_OVERRIDES,
                per_remote_only=salt.runners.winrepo.PER_REMOTE_ONLY,
                global_only=salt.runners.winrepo.GLOBAL_ONLY,
                cache_root=base_dir,
            )
            git_objects.append(obj)
    else:
        raise SaltInvocationError(f"Invalid role '{role}'")

    ret = {}
    for obj in git_objects:
        for lock_type in type_:
            cleared, errors = _clear_lock(
                obj.clear_lock, role, remote=remote, lock_type=lock_type
            )
            if cleared:
                ret.setdefault("cleared", []).extend(cleared)
            if errors:
                ret.setdefault("errors", []).extend(errors)
    if not ret:
        return "No locks were removed"
    return ret


def cloud(tgt, provider=None):
    """
    Return cloud cache data for target.

    .. note:: Only works with glob matching

    tgt
      Glob Target to match minion ids

    provider
      Cloud Provider

    CLI Example:

    .. code-block:: bash

        salt-run cache.cloud 'salt*'
        salt-run cache.cloud glance.example.org provider=openstack
    """
    if not isinstance(tgt, str):
        return {}

    opts = salt.config.cloud_config(
        os.path.join(os.path.dirname(__opts__["conf_file"]), "cloud")
    )
    if not opts.get("update_cachedir"):
        return {}

    cloud_cache = __utils__["cloud.list_cache_nodes_full"](opts=opts, provider=provider)
    if cloud_cache is None:
        return {}

    ret = {}
    for driver, providers in cloud_cache.items():
        for provider, servers in providers.items():
            for name, data in servers.items():
                if fnmatch.fnmatch(name, tgt):
                    ret[name] = data
                    ret[name]["provider"] = provider
    return ret


def store(bank, key, data, cachedir=None):
    """
    Lists entries stored in the specified bank.

    CLI Example:

    .. code-block:: bash

        salt-run cache.store mycache mykey 'The time has come the walrus said'
    """
    if cachedir is None:
        cachedir = __opts__["cachedir"]

    try:
        cache = salt.cache.Cache(__opts__, cachedir=cachedir)
    except TypeError:
        cache = salt.cache.Cache(__opts__)
    return cache.store(bank, key, data)


def list_(bank, cachedir=None):
    """
    Lists entries stored in the specified bank.

    CLI Example:

    .. code-block:: bash

        salt-run cache.list cloud/active/ec2/myec2 cachedir=/var/cache/salt/
    """
    if cachedir is None:
        cachedir = __opts__["cachedir"]

    try:
        cache = salt.cache.Cache(__opts__, cachedir=cachedir)
    except TypeError:
        cache = salt.cache.Cache(__opts__)
    return cache.list(bank)


def fetch(bank, key, cachedir=None):
    """
    Fetch data from a salt.cache bank.

    CLI Example:

    .. code-block:: bash

        salt-run cache.fetch cloud/active/ec2/myec2 myminion cachedir=/var/cache/salt/
    """
    if cachedir is None:
        cachedir = __opts__["cachedir"]

    try:
        cache = salt.cache.Cache(__opts__, cachedir=cachedir)
    except TypeError:
        cache = salt.cache.Cache(__opts__)
    return cache.fetch(bank, key)


def flush(bank, key=None, cachedir=None):
    """
    Remove the key from the cache bank with all the key content. If no key is
    specified remove the entire bank with all keys and sub-banks inside.

    CLI Examples:

    .. code-block:: bash

        salt-run cache.flush cloud/active/ec2/myec2 cachedir=/var/cache/salt/
        salt-run cache.flush cloud/active/ec2/myec2 myminion cachedir=/var/cache/salt/
    """
    if cachedir is None:
        cachedir = __opts__["cachedir"]

    try:
        cache = salt.cache.Cache(__opts__, cachedir=cachedir)
    except TypeError:
        cache = salt.cache.Cache(__opts__)
    return cache.flush(bank, key)
