import importlib
from datetime import datetime
from typing import Dict, List, Tuple

import config
from server.core import sqs
from server.core.cache.utils import is_image_caching_collection

try:
    cache_backend = importlib.import_module(config.CACHE_BACKEND)
except ImportError:
    raise RuntimeError(f"The cache backend does not exist: {config.CACHE_BACKEND}")


async def get_items(
    collection_name: str, keys: List[str], timeout: int or None, by_record_id: bool
) -> Tuple[Dict[str, dict], datetime or None, datetime or None]:
    """
    Retrieves data with the cache backend

        Args:
        collection_name: Collection name.
        keys: Collection items ID list.
        timeout: Cached data considered as actual if it was saved to less than this interval (in seconds) ago,
            0 or None - do not use cache, -1 - ignore timeout.
        by_record_id: Return results mapping by record ID or by object ID.

    Returns:
         ID to data mapping and datetime stats.
    """

    return await cache_backend.get_documents(collection_name, keys, timeout, by_record_id)


async def save_item(collection_name: str, key: str, value: dict, created_at: datetime):
    """
    Save data with the cache backend and send a message to SQS for image caching if needed.

    Args:
        collection_name: Collection name.
        key: Caching key.
        value: Record data.
        created_at: Records created_at datetime.

    """
    await cache_backend.save_document(collection_name, key, value, created_at)

    if config.IMAGE_CACHING_ENABLED and is_image_caching_collection(collection_name):
        await sqs.send_messages([create_message(collection_name, key, created_at)])


async def save_items(
    collection_name: str, records: Dict[str, Tuple[str, dict] or Tuple[int, dict]], created_at: datetime
):
    """Save data with the cache backend and send messages to SQS for image caching if needed.

    Args:
        collection_name: Collection name.
        records: Mapping caching key to tuple of record ID and data.
        created_at: Records created_at datetime.

    """
    await cache_backend.save_documents(collection_name, records, created_at)

    if config.IMAGE_CACHING_ENABLED and is_image_caching_collection(collection_name):
        messages = [create_message(collection_name, record_id, created_at) for record_id in records.keys()]
        await sqs.send_messages(messages)


def create_message(collection_name: str, record_id: str, created_at: datetime) -> dict:
    """Generate SQS message body.

    Args:
        collection_name: Collection name.
        record_id: Caching key.
        created_at: Created at timestamp.

    Returns:
        Message body.

    """
    return {"collection": collection_name, "id": record_id, "created_at": created_at}