# Copyright (C) 2015-2024 RhodeCode GmbH
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License, version 3
# (only), as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# This program is dual-licensed. If you wish to learn more about the
# RhodeCode Enterprise Edition, including its added features, Support services,
# and proprietary license terms, please see https://rhodecode.com/licenses/

import logging
import threading

from dogpile.cache import register_backend

from . import region_meta
from .utils import (
    ActiveRegionCache,
    InvalidationContext,
    backend_key_generator,
    clear_cache_namespace,
    get_default_cache_settings,
    get_or_create_region,
    make_region,
    str2bool,
)

module_name = "rhodecode"

register_backend("dogpile.cache.rc.memory_lru", f"{module_name}.lib.rc_cache.backends", "LRUMemoryBackend")

register_backend("dogpile.cache.rc.file_namespace", f"{module_name}.lib.rc_cache.backends", "FileNamespaceBackend")

register_backend("dogpile.cache.rc.redis", f"{module_name}.lib.rc_cache.backends", "RedisPickleBackend")

register_backend("dogpile.cache.rc.redis_msgpack", f"{module_name}.lib.rc_cache.backends", "RedisMsgPackBackend")


log = logging.getLogger(__name__)


FILE_TREE_CACHE_VER = "v6"
LICENSE_CACHE_VER = "v3"
PERMISSIONS_CACHE_VER = "v2"

CLEAR_DELETE = "delete"
CLEAR_INVALIDATE = "invalidate"


def async_creation_runner(cache, cache_key, creator, mutex):
    def runner():
        try:
            value = creator()
            cache.set(cache_key, value)
        finally:
            mutex.release()

    thread = threading.Thread(target=runner)
    thread.start()


def configure_dogpile_cache(settings):
    cache_dir = settings.get("cache_dir")
    if cache_dir:
        region_meta.dogpile_config_defaults["cache_dir"] = cache_dir

    rc_cache_data = get_default_cache_settings(settings, prefixes=["rc_cache."])

    # inspect available namespaces
    avail_regions = set()
    for key in rc_cache_data.keys():
        namespace_name = key.split(".", 1)[0]
        if namespace_name in avail_regions:
            continue

        avail_regions.add(namespace_name)
        log.debug("dogpile: found following cache regions: %s", namespace_name)

        new_region = make_region(name=namespace_name, function_key_generator=None, async_creation_runner=None)

        new_region.configure_from_config(settings, f"rc_cache.{namespace_name}.")
        new_region.function_key_generator = backend_key_generator(new_region.actual_backend)

        async_creator = str2bool(settings.pop(f"rc_cache.{namespace_name}.async_creator", "false"))
        if async_creator:
            log.debug("configuring region %s with async creator", new_region)
            new_region.async_creation_runner = async_creation_runner

        if log.isEnabledFor(logging.DEBUG):
            region_args = dict(
                backend=new_region.actual_backend, region_invalidator=new_region.region_invalidator.__class__
            )
            log.debug("dogpile: registering a new region key=`%s` args=%s", namespace_name, region_args)

        region_meta.dogpile_cache_regions[namespace_name] = new_region


def includeme(config):
    configure_dogpile_cache(config.registry.settings)
