import base64
import copy
import glob
import ipaddress
import json
import logging
import os
import re
import socket
import time
import traceback
import uuid
from datetime import UTC, datetime, timedelta
from functools import lru_cache, wraps
from http.cookiejar import MozillaCookieJar
from pathlib import Path
from typing import Any

from Crypto.Cipher import AES

from app.library.log import get_logger

LOG = get_logger()

ALLOWED_SUBS_EXTENSIONS: set[str] = {".srt", ".vtt", ".ass"}
"Allowed subtitle file extensions."

FILES_TYPE: list = [
    {"rx": re.compile(r"\.(avi|ts|mkv|mp4|mp3|mpv|ogm|m4v|webm|m4b)$", re.IGNORECASE), "type": "video"},
    {"rx": re.compile(r"\.(mp3|flac|aac|opus|wav|m4a)$", re.IGNORECASE), "type": "audio"},
    {"rx": re.compile(r"\.(srt|ass|ssa|smi|sub|idx)$", re.IGNORECASE), "type": "subtitle"},
    {"rx": re.compile(r"\.(jpg|jpeg|png|gif|bmp|webp)$", re.IGNORECASE), "type": "image"},
    {"rx": re.compile(r"\.(txt|nfo|md|json|yml|yaml|plexmatch)$", re.IGNORECASE), "type": "text"},
    {"rx": re.compile(r"\.(nfo|json|jpg|torrent|\.info\.json)$", re.IGNORECASE), "type": "metadata"},
]
"File type patterns for sidecar files."

TAG_REGEX: re.Pattern[str] = re.compile(r"%{([^:}]+)(?::([^}]*))?}c")
"Regex to find tags in templates."


class FileLogFormatter(logging.Formatter):
    def formatTime(self, record, datefmt=None):  # noqa: N802
        _ = datefmt
        return datetime.fromtimestamp(record.created).astimezone().isoformat(timespec="milliseconds")


LOG_RECORD_ATTRS: set[str] = set(logging.makeLogRecord({}).__dict__) | {"asctime", "message"}
SKIP_LOG_FIELD = object()


class JsonLogFormatter(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        source = {
            "path": record.pathname,
            "file": record.filename,
            "module": record.module,
            "function": record.funcName,
            "line": record.lineno,
        }
        data: dict[str, Any] = {
            "id": str(uuid.uuid4()),
            "datetime": self.formatTime(record),
            "level": record.levelname.lower(),
            "levelno": record.levelno,
            "logger": record.name,
            "message": record.getMessage(),
            "source": source,
            "process": {"id": record.process, "name": record.processName},
            "thread": {"id": record.thread, "name": record.threadName},
            "fields": self._extra(record),
        }

        if record.exc_info:
            exception = self._exception(record.exc_info)
            if exception is not None:
                data["exception"] = exception
                data["source"].update(self._exception_source(exception))

        return json.dumps(data, ensure_ascii=False, default=str)

    def formatTime(self, record, datefmt=None):  # noqa: N802
        _ = datefmt
        return datetime.fromtimestamp(record.created).astimezone().isoformat(timespec="milliseconds")

    @staticmethod
    def _extra(record: logging.LogRecord) -> dict[str, Any]:
        extra: dict[str, Any] = {}
        for key, value in record.__dict__.items():
            if key in LOG_RECORD_ATTRS or key.startswith("_"):
                continue

            value = JsonLogFormatter._field(value)
            if value is not SKIP_LOG_FIELD:
                extra[key] = value

        return extra

    @staticmethod
    def _field(value: Any) -> Any:
        if isinstance(value, str | int | float | bool) or value is None:
            return value

        if isinstance(value, Path):
            return str(value)

        if isinstance(value, dict):
            data: dict[str, Any] = {}
            for key, item in value.items():
                if not isinstance(key, str) or key.startswith("_"):
                    continue

                item = JsonLogFormatter._field(item)
                if item is not SKIP_LOG_FIELD:
                    data[key] = item

            return data

        if isinstance(value, list):
            data: list[Any] = []
            for item in value:
                item = JsonLogFormatter._field(item)
                if item is not SKIP_LOG_FIELD:
                    data.append(item)

            return data

        return SKIP_LOG_FIELD

    @staticmethod
    def _exception(
        exc_info: tuple[type[BaseException], BaseException, Any] | tuple[None, None, None],
    ) -> dict[str, Any] | None:
        exc = exc_info[1]
        if exc is None:
            return None

        stack = JsonLogFormatter._exception_stack(exc_info)
        data: dict[str, Any] = {"type": JsonLogFormatter._exception_type(exc)}

        message = str(exc).strip()
        if message:
            data["message"] = message

        if stack:
            origin = stack[-1]
            data["file"] = origin["path"]
            data["line"] = origin["line"]
            data["stack"] = stack

        return data

    @staticmethod
    def _exception_type(exc: BaseException) -> str:
        module = exc.__class__.__module__
        name = exc.__class__.__qualname__
        return name if module == "builtins" else f"{module}.{name}"

    @staticmethod
    def _exception_stack(
        exc_info: tuple[type[BaseException], BaseException, Any] | tuple[None, None, None],
    ) -> list[dict[str, Any]]:
        exc = exc_info[1]
        tb = exc_info[2] if len(exc_info) > 2 else None
        if tb is None and exc is not None:
            tb = exc.__traceback__

        if tb is None:
            return []

        return [JsonLogFormatter._frame(frame) for frame in traceback.extract_tb(tb)]

    @staticmethod
    def _frame(frame: traceback.FrameSummary) -> dict[str, Any]:
        path = frame.filename
        file_path = Path(path)
        return {
            "path": path,
            "file": file_path.name,
            "module": file_path.stem,
            "function": frame.name,
            "line": frame.lineno,
        }

    @staticmethod
    def _exception_source(exception: dict[str, Any]) -> dict[str, Any]:
        source: dict[str, Any] = {}

        path = exception.get("file")
        if isinstance(path, str) and path:
            file_path = Path(path)
            source["path"] = path
            source["file"] = file_path.name
            source["module"] = file_path.stem

        line = exception.get("line")
        if isinstance(line, int):
            source["line"] = line

        stack = exception.get("stack")
        if isinstance(stack, list) and stack:
            frame = stack[-1]
            if isinstance(frame, dict):
                function = frame.get("function")
                if isinstance(function, str) and function:
                    source["function"] = function

                module = frame.get("module")
                if isinstance(module, str) and module:
                    source["module"] = module

        return source


def timed_lru_cache(ttl_seconds: float, max_size: int = 128):
    """
    Decorator that applies an LRU cache with a time-to-live (TTL) to a function.
    Supports both synchronous and asynchronous functions.

    Args:
        ttl_seconds (int): Time-to-live in seconds.
        max_size (int): Maximum size of the cache.

    Returns:
        Decorated function with caching capabilities.

    """
    import inspect

    def decorator(func):
        is_async = inspect.iscoroutinefunction(func)

        if is_async:
            # For async functions, we need to cache the actual result, not the coroutine
            cache = {}
            cache_expiry = {}

            @wraps(func)
            async def async_wrapper(*args, **kwargs):
                key = str(args) + str(sorted(kwargs.items()))
                current_time = time.monotonic()

                # Check if we have a cached result that hasn't expired
                if key in cache and key in cache_expiry and current_time < cache_expiry[key]:
                    cached_result = cache[key]
                    try:
                        return copy.deepcopy(cached_result)
                    except Exception:
                        return cached_result

                # Call the function and cache the result
                result = await func(*args, **kwargs)
                try:
                    cached_value = copy.deepcopy(result)
                except Exception:
                    cached_value = result

                cache[key] = cached_value
                cache_expiry[key] = current_time + ttl_seconds

                # Limit cache size
                if len(cache) > max_size:
                    # Remove oldest entries
                    oldest_keys = sorted(cache_expiry.keys(), key=lambda k: cache_expiry[k])[: len(cache) - max_size]
                    for old_key in oldest_keys:
                        cache.pop(old_key, None)
                        cache_expiry.pop(old_key, None)

                try:
                    return copy.deepcopy(cached_value)
                except Exception:
                    return cached_value

            # Expose cache management methods
            def cache_clear():
                cache.clear()
                cache_expiry.clear()

            def cache_info():
                # Use functools._CacheInfo for compatibility with standard lru_cache
                from functools import _CacheInfo

                return _CacheInfo(hits=0, misses=len(cache), maxsize=max_size, currsize=len(cache))

            async_wrapper_cache: Any = async_wrapper
            async_wrapper_cache.cache_clear = cache_clear
            async_wrapper_cache.cache_info = cache_info
            return async_wrapper

        # For sync functions, use the original implementation

        @lru_cache(maxsize=max_size)
        def cached(*args, **kwargs):
            result = func(*args, **kwargs)
            try:
                return copy.deepcopy(result)
            except Exception:
                return result

        cached_expiry = time.monotonic() + ttl_seconds

        @wraps(func)
        def sync_wrapper(*args, **kwargs):
            nonlocal cached_expiry
            if time.monotonic() >= cached_expiry:
                cached.cache_clear()
                cached_expiry = time.monotonic() + ttl_seconds
            result = cached(*args, **kwargs)
            try:
                return copy.deepcopy(result)
            except Exception:
                return result

        # expose cache_clear, cache_info
        sync_wrapper_cache: Any = sync_wrapper
        sync_wrapper_cache.cache_clear = cached.cache_clear
        sync_wrapper_cache.cache_info = cached.cache_info
        return sync_wrapper

    return decorator


def calc_download_path(base_path: str | Path, folder: str | None = None, create_path: bool = True) -> str:
    """
    Calculates download path.

    Args:
        base_path (str): Base download path.
        folder (str): Folder to add to the base path.
        create_path (bool): Create the path if it does not exist.

    Returns:
        Download path with base folder factored in.

    """
    if not isinstance(base_path, Path):
        base_path = Path(base_path)

    if not folder:
        return str(base_path)

    folder = folder.removeprefix("/")

    realBasePath: Path = base_path.resolve()
    download_path: Path = Path(realBasePath).joinpath(folder).resolve(strict=False)

    if not str(download_path).startswith(str(realBasePath)):
        msg: str = f'Folder "{folder}" must resolve inside the base download folder "{realBasePath}".'
        raise Exception(msg)

    try:
        download_path.relative_to(realBasePath)
    except ValueError as e:
        msg = f'Folder "{folder}" must resolve inside the base download folder "{realBasePath}".'
        raise Exception(msg) from e

    if not download_path.is_dir() and create_path:
        download_path.mkdir(parents=True, exist_ok=True)

    return str(download_path)


def _is_safe_key(key: Any) -> bool:
    """
    Check if a dictionary key is safe for merging.

    Blocks:
    - All dunder attributes (__*__)
    - Non-string keys (for consistency)
    - Keys that could be dangerous variations
    """
    # Only allow string keys
    if not isinstance(key, str):
        return False

    # Block empty keys and whitespace-only keys
    if not key or not key.strip():
        return False

    # Block only truly dangerous dunder patterns
    key_stripped: str = key.strip()

    # Block dunder attributes (starts AND ends with __)
    return not (key_stripped.startswith("__") and key_stripped.endswith("__"))


def merge_dict(
    source: dict,
    destination: dict,
    max_depth: int = 50,
    max_list_size: int = 10000,
    _depth: int = 0,
    _seen: set | None = None,
) -> dict:
    """
    Merge data from source into destination.

    Args:
        source (dict): Source data
        destination (dict): Destination data
        max_depth (int): Maximum recursion depth allowed (default: 50)
        max_list_size (int): Maximum list size allowed (default: 10000)
        _depth (int): Internal recursion depth counter
        _seen (set): Internal circular reference tracker

    Returns:
        dict: The merged dictionary

    Raises:
        TypeError: If source or destination are not dictionaries
        RecursionError: If recursion depth exceeds safety limit
        ValueError: If circular reference is detected

    """
    if not isinstance(source, dict) or not isinstance(destination, dict):
        msg = "Both source and destination must be dictionaries."
        raise TypeError(msg)

    # Prevent deep recursion DoS
    if _depth > max_depth:
        msg: str = f"Recursion depth limit exceeded ({max_depth})"
        raise RecursionError(msg)

    # Initialize circular reference tracking
    if _seen is None:
        _seen = set()

    # Check for circular references
    source_id = id(source)
    dest_id = id(destination)
    if source_id in _seen or dest_id in _seen:
        msg = "Circular reference detected"
        raise ValueError(msg)

    # Track current objects
    current_seen: set[Any | int] = _seen | {source_id, dest_id}

    # Create a clean copy of destination with only safe keys
    destination_copy: dict = {}
    for k, v in destination.items():
        if _is_safe_key(k):
            # Prevent memory DoS from large lists
            if isinstance(v, list) and len(v) > max_list_size:
                destination_copy[k] = v[:max_list_size]  # Truncate large lists
            else:
                destination_copy[k] = copy.deepcopy(v)

    for key, value in source.items():
        # Skip unsafe keys
        if not _is_safe_key(key):
            continue

        destination_value: Any | None = destination_copy.get(key)

        # Recursively merge dictionaries with safety checks
        if isinstance(value, dict) and isinstance(destination_value, dict):
            destination_copy[key] = merge_dict(
                value, destination_value, max_depth, max_list_size, _depth + 1, current_seen
            )

        # Safely extend lists with size limits
        elif isinstance(value, list) and isinstance(destination_value, list):
            # Prevent memory DoS
            combined_size = len(value) + len(destination_value)
            if combined_size > max_list_size:
                # Truncate to stay within limits
                available_space: int = max_list_size - len(destination_value)
                truncated_value: list = value[: max(0, available_space)]
                destination_copy[key] = copy.deepcopy(destination_value) + copy.deepcopy(truncated_value)
            else:
                destination_copy[key] = copy.deepcopy(destination_value) + copy.deepcopy(value)
        # For non-dict values or when destination doesn't have the key
        elif isinstance(value, dict):
            destination_copy[key] = merge_dict(value, {}, max_depth, max_list_size, _depth + 1, current_seen)
        elif isinstance(value, list) and len(value) > max_list_size:
            # Truncate large lists
            destination_copy[key] = copy.deepcopy(value[:max_list_size])
        else:
            destination_copy[key] = copy.deepcopy(value)

    return destination_copy


def check_id(file: Path) -> bool | Path:
    """
    Check if we are able to get an id from the file name.
    if so check if any video file with the same id exists.

    Args:
        file (Path): File to check.

    Returns:
        bool|str: False if no file found, else the file path.

    """
    match: re.Match[str] | None = re.search(
        r"(?<=\[)(?:youtube-)?(?P<id>[a-zA-Z0-9\-_]{11})(?=\])", file.stem, re.IGNORECASE
    )
    if not match:
        return False

    id: str | None = match.groupdict().get("id")
    if id is None:
        return False

    try:
        if not file.parent.exists():
            return False

        for f in file.parent.iterdir():
            if id not in f.stem:
                continue

            if f.suffix != file.suffix:
                continue

            return f.absolute()
    except OSError as e:
        LOG.exception(
            "Failed to check for a matching file for '%s'.",
            file,
            extra={"file_path": str(file), "operation": "check_id", "exception_type": type(e).__name__},
        )
        return False

    return False


@timed_lru_cache(ttl_seconds=300, max_size=256)
def is_private_address(hostname: str) -> bool:
    ip: str = socket.gethostbyname(hostname)
    ip_obj: ipaddress.IPv4Address | ipaddress.IPv6Address = ipaddress.ip_address(ip)
    return ip_obj.is_private or ip_obj.is_loopback or ip_obj.is_reserved or ip_obj.is_link_local


def validate_url(url: str, allow_internal: bool = False) -> bool:
    """
    Validate if the url is valid and allowed.

    Args:
        url (str): URL to validate.
        allow_internal (bool): If True, allow internal URLs or private networks.

    Returns:
        bool: True if the URL is valid and allowed.

    Raises:
        ValueError: If the URL is invalid or not allowed.

    """
    if not url:
        msg = "URL is required."
        raise ValueError(msg)

    try:
        from yarl import URL

        parsed_url = URL(url)
    except ValueError as exc:
        msg = "Invalid URL."
        raise ValueError(msg) from exc

    # Check allowed schemes
    if parsed_url.scheme not in ["http", "https"]:
        msg = "Invalid scheme usage. Only HTTP or HTTPS allowed."
        raise ValueError(msg)

    hostname: str | None = parsed_url.host
    if not hostname:
        msg = "Invalid hostname."
        raise ValueError(msg)

    if allow_internal is False:
        try:
            if is_private_address(hostname):
                msg = "Access to internal urls or private networks is not allowed."
                raise ValueError(msg)
        except socket.gaierror as e:
            LOG.exception(
                "Failed to resolve hostname '%s'.",
                hostname,
                extra={"hostname": hostname, "exception_type": type(e).__name__},
            )
            msg = "Invalid hostname."
            raise ValueError(msg) from e

    return True


def validate_uuid(uuid_str: str, version: int = 4) -> bool:
    """
    Validate if the UUID is valid.

    Args:
        uuid_str (str): UUID to validate.
        version  (int): The UUID version

    Returns:
        bool: True if the UUID is valid.

    """
    try:
        uuid.UUID(uuid_str, version=version)
        return True
    except ValueError:
        return False


@timed_lru_cache(ttl_seconds=60, max_size=256)
def get_file_sidecar(file: Path | None = None) -> dict[str, list[dict[str, Any]]]:
    """
    Get sidecar files for the given file.

    Args:
        file (Path|None): The video file.

    Returns:
        dict: A dictionary with sidecar files categorized by type.

    """
    files: dict = {}

    if not file:
        return files

    for i, f in enumerate(file.parent.glob(f"{glob.escape(file.stem)}.*")):
        if f == file or f.is_file() is False or f.stem.startswith("."):
            continue

        if f.stat().st_size < 1:
            continue

        content_type = "Unknown"
        for pattern in FILES_TYPE:
            if pattern["rx"].search(f.name):
                content_type: str = pattern["type"]
                break

        if content_type == "subtitle":
            if f.suffix not in ALLOWED_SUBS_EXTENSIONS:
                continue
            lg: re.Match[str] | None = re.search(r"\.(?P<lang>\w{2,3})\.\w{3}$", f.name)
            lang: str | None = lg.groupdict().get("lang") if lg else "und"
            content: dict[str, Any] = {"file": f, "lang": lang, "name": f"{f.suffix[1:].upper()} ({i}) - {lang}"}
        else:
            content = {"file": f}

        if content_type not in files:
            files[content_type] = []

        files[content_type].append(content)

    images: list[dict] = get_possible_images(str(file.parent))
    if len(images) > 0:
        if "image" not in files:
            files["image"] = []

        files["image"].extend(images)

    return files


def rename_file(old_path: Path, new_name: str) -> tuple[Path, list[tuple[Path, Path]]]:
    """
    Rename a file along with all its sidecar files.

    Args:
        old_path (Path): The original file path.
        new_name (str): The new name for the file (not full path, just the name).

    Returns:
        tuple[Path, list[tuple[Path, Path]]]: Tuple of (new_path, list of (old_sidecar_path, new_sidecar_path) tuples).

    Raises:
        OSError: If renaming fails.
        ValueError: If new_name would cause a collision with existing files.

    """
    new_path: Path = old_path.parent / new_name

    if new_path.exists():
        msg: str = f"Destination '{new_name}' already exists"
        raise ValueError(msg)

    sidecar_data: dict[str, dict] = get_file_sidecar(old_path)
    sidecar_files: list[Path] = []

    for category in sidecar_data.values():
        sidecar_files.extend([item["file"] for item in category if "file" in item and isinstance(item["file"], Path)])

    renamed_sidecars: list[tuple[Path, Path]] = []
    new_stem: str = new_path.stem
    rename_operations: list[tuple[Path, Path]] = []

    for sidecar in sidecar_files:
        sidecar_suffix: str = sidecar.name[len(old_path.stem) :]  # Everything after the original stem
        new_sidecar_path: Path = old_path.parent / f"{new_stem}{sidecar_suffix}"
        if new_sidecar_path.exists():
            msg = f"Sidecar destination '{new_sidecar_path.name}' already exists"
            raise ValueError(msg)

        rename_operations.append((sidecar, new_sidecar_path))

    try:
        renamed_main: Path = old_path.rename(new_path)
        for old_sidecar, new_sidecar in rename_operations:
            try:
                renamed_sidecar: Path = old_sidecar.rename(new_sidecar)
                renamed_sidecars.append((old_sidecar, renamed_sidecar))
            except OSError as e:
                LOG.exception(
                    "Failed to rename sidecar '%s' to '%s'.",
                    old_sidecar,
                    new_sidecar,
                    extra={
                        "old_path": str(old_sidecar),
                        "new_path": str(new_sidecar),
                        "operation": "rename_sidecar",
                        "exception_type": type(e).__name__,
                    },
                )
                try:
                    renamed_main.rename(old_path)
                except OSError as rollback_error:
                    LOG.exception(
                        "Failed to roll back main file rename from '%s' to '%s'.",
                        renamed_main,
                        old_path,
                        extra={
                            "old_path": str(renamed_main),
                            "new_path": str(old_path),
                            "operation": "rename_rollback",
                            "exception_type": type(rollback_error).__name__,
                        },
                    )
                raise

        return renamed_main, renamed_sidecars
    except OSError as e:
        LOG.exception(
            "Failed to rename '%s' to '%s'.",
            old_path,
            new_path,
            extra={
                "old_path": str(old_path),
                "new_path": str(new_path),
                "operation": "rename",
                "exception_type": type(e).__name__,
            },
        )
        raise


def move_file(old_path: Path, target_dir: Path) -> tuple[Path, list[tuple[Path, Path]]]:
    """
    Move a file along with all its sidecar files to a target directory.

    Args:
        old_path (Path): The original file path.
        target_dir (Path): The target directory to move the file to.

    Returns:
        tuple[Path, list[tuple[Path, Path]]]: Tuple of (new_path, list of (old_sidecar_path, new_sidecar_path) tuples).

    Raises:
        OSError: If moving fails.
        ValueError: If target directory doesn't exist or if destination would cause collision.

    """
    if not target_dir.exists():
        msg: str = f"Target directory '{target_dir}' does not exist"
        raise ValueError(msg)

    if not target_dir.is_dir():
        msg = f"Target '{target_dir}' is not a directory"
        raise ValueError(msg)

    new_path: Path = target_dir / old_path.name

    if new_path.exists():
        msg = f"Destination '{new_path}' already exists"
        raise ValueError(msg)

    sidecar_data: dict[str, dict] = get_file_sidecar(old_path)
    sidecar_files: list[Path] = []

    for category in sidecar_data.values():
        sidecar_files.extend([item["file"] for item in category if "file" in item and isinstance(item["file"], Path)])

    renamed_sidecars: list[tuple[Path, Path]] = []
    move_operations: list[tuple[Path, Path]] = []

    for sidecar in sidecar_files:
        new_sidecar_path: Path = target_dir / sidecar.name
        if new_sidecar_path.exists():
            msg = f"Sidecar destination '{new_sidecar_path}' already exists"
            raise ValueError(msg)

        move_operations.append((sidecar, new_sidecar_path))

    try:
        moved_main: Path = old_path.rename(new_path)
        for old_sidecar, new_sidecar in move_operations:
            try:
                moved_sidecar: Path = old_sidecar.rename(new_sidecar)
                renamed_sidecars.append((old_sidecar, moved_sidecar))
            except OSError as e:
                LOG.exception(
                    "Failed to move sidecar '%s' to '%s'.",
                    old_sidecar,
                    new_sidecar,
                    extra={
                        "old_path": str(old_sidecar),
                        "new_path": str(new_sidecar),
                        "operation": "move_sidecar",
                        "exception_type": type(e).__name__,
                    },
                )
                try:
                    moved_main.rename(old_path)
                    # Rollback any sidecars that were already moved
                    for rolled_back_old, rolled_back_new in renamed_sidecars:
                        try:
                            rolled_back_new.rename(rolled_back_old)
                        except OSError as rollback_error:
                            LOG.exception(
                                "Failed to roll back sidecar move from '%s' to '%s'.",
                                rolled_back_new,
                                rolled_back_old,
                                extra={
                                    "old_path": str(rolled_back_new),
                                    "new_path": str(rolled_back_old),
                                    "operation": "move_sidecar_rollback",
                                    "exception_type": type(rollback_error).__name__,
                                },
                            )
                except OSError as rollback_error:
                    LOG.exception(
                        "Failed to roll back main file move from '%s' to '%s'.",
                        moved_main,
                        old_path,
                        extra={
                            "old_path": str(moved_main),
                            "new_path": str(old_path),
                            "operation": "move_rollback",
                            "exception_type": type(rollback_error).__name__,
                        },
                    )
                raise

        return moved_main, renamed_sidecars
    except OSError as e:
        LOG.exception(
            "Failed to move '%s' to '%s'.",
            old_path,
            new_path,
            extra={
                "old_path": str(old_path),
                "new_path": str(new_path),
                "operation": "move",
                "exception_type": type(e).__name__,
            },
        )
        raise


def get_possible_images(dir: str) -> list[dict]:
    images: list = []

    path_loc = Path(dir, "test.jpg")

    for filename in ["poster", "thumbnail", "artwork", "cover", "fanart"]:
        for ext in [".jpg", ".jpeg", ".png", ".webp"]:
            f = path_loc.with_stem(filename).with_suffix(ext)
            if f.exists():
                images.append({"file": f})

    return images


def get_mime_type(metadata: dict, file_path: Path) -> str:
    """
    Determine the correct MIME type for a video file based on ffprobe metadata.

    Args:
        metadata (dict): Parsed JSON output from ffprobe.
        file_path (str): The path to the video file for fallback detection.

    Returns:
        str: MIME type compatible with HTML5 <video> tag.

    """
    format_name = metadata.get("format_name", "")

    format_to_mime: dict[str, str] = {
        "matroska": "video/x-matroska",  # Default for MKV
        "webm": "video/webm",  # MKV can also be WebM
        "mp4": "video/mp4",
        "mpegts": "video/mp2t",
    }

    if format_name:
        selected = None
        for fmt in format_name.split(","):
            fmt = fmt.strip().lower()
            if fmt in format_to_mime:
                selected: str = format_to_mime[fmt]

        if selected:
            return selected

    import mimetypes

    mime_type, _ = mimetypes.guess_type(str(file_path))
    if mime_type:
        return mime_type

    # Final fallback: Return generic binary type
    return "application/octet-stream"


def get_file(download_path: str | Path, file: str | Path) -> tuple[Path, int]:
    """
    Get the real file path.

    Args:
        download_path (str|Path): Base download path.
        file (str|Path): File path.

    Returns:
        Path: Real file path.
        int: http status code.

    """
    if not isinstance(download_path, Path):
        download_path = Path(download_path)

    try:
        realFile: Path = Path(calc_download_path(base_path=download_path, folder=str(file), create_path=False))
        if realFile.exists():
            return (realFile, 200)
    except Exception as e:
        LOG.exception(
            "Failed to resolve download file path for '%s'.",
            file,
            extra={"file_path": str(file), "download_path": str(download_path), "exception_type": type(e).__name__},
        )
        return (Path(file), 404)

    possibleFile: bool | Path = check_id(file=realFile)
    if not isinstance(possibleFile, Path):
        return (realFile, 404)

    return (possibleFile, 302)


def encrypt_data(data: str, key: bytes) -> str:
    """
    Encrypts data using AES-GCM

    Args:
        data (str): The data to encrypt
        key (bytes): The encryption key

    Returns:
        str: The encrypted data as a base64 encoded string

    """
    iv = os.urandom(12)  # AES-GCM requires a 12-byte IV
    cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
    ciphertext, tag = cipher.encrypt_and_digest(data.encode())

    return base64.urlsafe_b64encode(iv + ciphertext + tag).decode()


def decrypt_data(data: str, key: bytes) -> str | None:
    """
    Decrypts AES-GCM encrypted data

    Args:
        data (str): The encrypted data as a base64 encoded string
        key (bytes): The encryption key

    Returns:
        str: The decrypted data

    """
    try:
        raw: bytes = base64.urlsafe_b64decode(data)
        iv, ciphertext, tag = raw[:12], raw[12:-16], raw[-16:]
        cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
        plaintext = cipher.decrypt_and_verify(ciphertext, tag)
        return plaintext.decode()
    except Exception:
        return None


def get(
    data: dict | list,
    path: str | list | None = None,
    default: Any = None,
    separator=".",
):
    """
    Access data in a nested dictionary or list using a path string or list of keys.

    Args:
        data (dict | list): The data to traverse.
        path (str | list, optional): The path to the desired data. Defaults to None.
        default (any, optional): The default value to return if the path is not found. Defaults to None.
        separator (str, optional): The separator used to split the path string. Defaults to ".".

    Returns:
        any: The value at the specified path, or the default value if not found.

    """
    # If path is empty, return the entire data.
    if not path:
        return data

    # If data is not a dict or list, attempt to convert it.
    if not isinstance(data, dict | list):
        try:
            data = vars(data)
        except Exception:
            pass

    # If path is a list, try each key in order.
    if isinstance(path, list):
        for key in path:
            val = get(data, key, "__not_set", separator)
            if val != "__not_set":
                return val

        return default() if callable(default) else default

    # For non-list path, attempt a direct lookup.
    if isinstance(data, dict):
        if path in data and data[path] is not None:
            return data[path]
    elif isinstance(data, list):
        # If path is an integer index.
        if isinstance(path, int):
            if 0 <= path < len(data) and data[path] is not None:
                return data[path]
        # If path is a numeric string, convert it.
        elif isinstance(path, str) and path.isdigit():
            idx = int(path)
            if 0 <= idx < len(data) and data[idx] is not None:
                return data[idx]

    # If path doesn't contain the separator, return the default.
    if not (isinstance(path, str) and separator in path):
        return default() if callable(default) else default

    # Split the path by the separator and traverse the data structure.
    segments: list[str] = path.split(separator)
    for segment in segments:
        if isinstance(data, dict):
            if segment in data:
                data = data[segment]
            else:
                return default() if callable(default) else default
        elif isinstance(data, list):
            try:
                idx = int(segment)
            except ValueError:
                return default() if callable(default) else default
            if 0 <= idx < len(data):
                data = data[idx]
            else:
                return default() if callable(default) else default
        else:
            return default() if callable(default) else default
    return data


def get_files(
    base_path: Path | str,
    dir: str | None = None,
    page: int = 1,
    per_page: int = 0,
    sort_by: str = "name",
    sort_order: str = "asc",
    search: str | None = None,
) -> tuple[list, int]:
    """
    Get directory contents with optional pagination, sorting, and search.

    Args:
        base_path (Path|str): Base download path.
        dir (str): Directory to check.
        page (int): Page number (1-indexed). Ignored if per_page is 0.
        per_page (int): Items per page. If 0, returns all items.
        sort_by (str): Sort field: name, size, date, type.
        sort_order (str): Sort direction: asc, desc.
        search (str|None): Filter by filename (case-insensitive).

    Returns:
        tuple[list, int]: List of file/directory dicts and total count (before pagination).

    Raises:
        OSError: If the directory is invalid or not a directory.

    """
    if not isinstance(base_path, Path):
        base_path = Path(base_path)

    base_path = base_path.resolve()

    dir_path = base_path
    if dir and dir != "/":
        dir_path: Path = base_path.joinpath(dir)

    try:
        dir_path = dir_path.resolve()
    except OSError as e:
        LOG.warning(
            "Failed to resolve '%s': %s",
            dir,
            e,
            extra={"requested_dir": dir, "base_path": str(base_path), "exception_type": type(e).__name__},
            exc_info=True,
        )
        return [], 0

    try:
        dir_path.relative_to(base_path)
    except ValueError:
        LOG.warning(
            "Invalid path '%s': must be inside '%s'.",
            dir_path,
            base_path,
            extra={"path": str(dir_path), "base_path": str(base_path)},
        )
        return [], 0

    if not str(dir_path).startswith(str(base_path)):
        LOG.warning(
            "Invalid path '%s': must be inside '%s'.",
            dir_path,
            base_path,
            extra={"path": str(dir_path), "base_path": str(base_path)},
        )
        return [], 0

    if not dir_path.is_dir():
        LOG.warning(
            "Invalid path '%s': must be a directory.",
            dir_path,
            extra={"path": str(dir_path), "base_path": str(base_path)},
        )
        return [], 0

    contents: list = []
    for file in dir_path.iterdir():
        if file.name.startswith(".") or file.name.startswith("_"):
            continue

        is_symlink: bool = file.is_symlink()
        if is_symlink:
            try:
                test: Path = file.resolve()
                test.relative_to(base_path)
                if not str(test).startswith(str(base_path)):
                    LOG.warning(
                        "Invalid symlink '%s': must resolve inside '%s'.",
                        file,
                        base_path,
                        extra={"path": str(file), "resolved_path": str(test), "base_path": str(base_path)},
                    )
                    continue
            except ValueError:
                LOG.warning(
                    "Invalid symlink '%s': must resolve inside '%s'.",
                    file,
                    base_path,
                    extra={"path": str(file), "base_path": str(base_path)},
                )
                continue
            except OSError as e:
                LOG.warning(
                    "Skipping broken symlink '%s'.",
                    file,
                    extra={"path": str(file), "base_path": str(base_path), "exception_type": type(e).__name__},
                    exc_info=True,
                )
                continue

        content_type = None

        for pattern in FILES_TYPE:
            if pattern["rx"].search(file.name):
                content_type = pattern["type"]
                break

        if not content_type and file.is_dir():
            content_type = "dir"

        if not content_type:
            content_type = "download"

        stat: os.stat_result = file.stat()

        contents.append(
            {
                "type": "file" if file.is_file() else "link" if is_symlink else "dir",
                "content_type": content_type,
                "name": file.name,
                "path": str(file.relative_to(base_path)).strip("/"),
                "size": stat.st_size,
                "mime": get_mime_type({}, file) if file.is_file() else "directory",
                "mtime": datetime.fromtimestamp(stat.st_mtime, tz=UTC).isoformat(),
                "ctime": datetime.fromtimestamp(stat.st_ctime, tz=UTC).isoformat(),
                "is_dir": file.is_dir(),
                "is_file": file.is_file(),
                "is_symlink": is_symlink,
            }
        )

    total: int = len(contents)

    if search:
        search_lower: str = search.lower()
        contents = [c for c in contents if search_lower in c["name"].lower()]

    if sort_by == "name":
        contents.sort(key=lambda x: x["name"].lower(), reverse=(sort_order.lower() == "desc"))
    elif sort_by == "size":
        contents.sort(key=lambda x: x["size"], reverse=(sort_order.lower() == "desc"))
    elif sort_by == "date":
        contents.sort(key=lambda x: x["mtime"], reverse=(sort_order.lower() == "desc"))
    elif sort_by == "type":
        contents.sort(key=lambda x: x["content_type"], reverse=(sort_order.lower() == "desc"))

    if per_page > 0:
        offset: int = (page - 1) * per_page
        contents = contents[offset : offset + per_page]

    return contents, total


def clean_item(item: dict, keys: list | tuple) -> tuple[dict, bool]:
    """
    Remove given keys from a dictionary.

    Args:
        item (dict): The item to clean.
        keys (list|tuple): The keys to remove.

    Returns:
        tuple[dict, bool]: The cleaned item and a the status of cleaning operation.

    Raises:
        TypeError: If item is not a dictionary or keys is not a list or tuple.

    """
    status = False
    item = copy.deepcopy(item)

    if not isinstance(item, dict):
        msg = "Item must be a dictionary."
        raise TypeError(msg)

    if not isinstance(keys, list | tuple):
        msg = "Keys must be a list or tuple."
        raise TypeError(msg)

    for key in keys:
        if key not in item:
            continue

        status = True
        item.pop(key)

    return item, status


def strip_newline(string: str) -> str:
    """
    Remove newlines from a string.

    Args:
        string (str): The string to process.

    Returns:
        str: The string without newlines.

    """
    if not string:
        return ""

    res: str = re.sub(r"(\r\n|\r|\n)", " ", string)

    return res.strip() if res else ""


def load_cookies(file: str | Path) -> tuple[bool, MozillaCookieJar]:
    """
    Validate and load a cookie file.

    Args:
        file (str): The cookie file path.

    Returns:
        bool: True if the cookie file is valid.

    """
    try:
        from http.cookiejar import MozillaCookieJar

        cookies = MozillaCookieJar(str(file), delayload=False, policy=None)
        cookies.load()

        return (True, cookies)
    except Exception as e:
        msg = f"Invalid cookie file '{file}'. '{e!s}'"
        raise ValueError(msg) from e


def dt_delta(delta: timedelta) -> str:
    """
    Convert a timedelta object to a human-readable string.

    Args:
        delta (timedelta): The timedelta object.

    Returns:
        str: A human-readable string representing the timedelta.

    """
    total_secs = int(delta.total_seconds())
    days, rem = divmod(total_secs, 86400)
    hours, rem = divmod(rem, 3600)
    minutes, secs = divmod(rem, 60)

    parts: list[str] = []
    if days:
        parts.append(f"{days}d")
    if hours:
        parts.append(f"{hours}h")
    if minutes:
        parts.append(f"{minutes}m")
    if secs:
        parts.append(f"{secs}s")

    # if it's under one second
    if not parts:
        parts.append("<1s")

    return " ".join(parts)


def delete_dir(dir: Path) -> bool:
    """
    Delete a directory and all its contents.

    Args:
        dir (Path): The directory to delete.

    Returns:
        bool: True if the directory was deleted successfully, False otherwise.

    """
    if not dir or not dir.exists() or not dir.is_dir():
        return False

    try:
        for item in dir.iterdir():
            if item.is_dir():
                delete_dir(item)
            else:
                item.unlink()
        dir.rmdir()
        return True
    except Exception as e:
        LOG.exception(
            "Failed to delete directory '%s'.",
            dir,
            extra={"dir": str(dir), "exception_type": type(e).__name__},
        )
        return False


def init_class[T](cls: type[T], data: dict, _fields=None) -> T:
    """
    Initialize a class instance with data from a dictionary, filtering out keys not present in the class fields.

    Args:
        cls (type): The class to initialize.
        data (dict): The data to use for initialization.
        _fields (set, optional): A set of field names to consider. If None, all fields from the class will be used.

    Returns:
        T: An instance of the class initialized with the provided data.

    """
    from dataclasses import fields

    _classMembers = _fields if _fields is not None else {f.name for f in fields(cls)}
    return cls(**{k: v for k, v in data.items() if k in _classMembers})


def load_modules(root_path: Path, directory: Path):
    """
    Load all modules from a given directory relative to the root path.

    Args:
        root_path (Path): The root path of the application.
        directory (Path): The directory from which to load modules.

    """
    import importlib
    import pkgutil

    package_name: str = str(directory.relative_to(root_path).as_posix()).replace("/", ".")
    # Ensure package name starts with 'app.' for proper module resolution
    if not package_name.startswith("app."):
        package_name = f"app.{package_name}"

    for _, name, _ in pkgutil.iter_modules([directory]):
        full_name: str = f"{package_name}.{name}"
        if name.startswith("_"):
            continue

        try:
            importlib.import_module(full_name)
        except ImportError as e:
            LOG.exception(
                "Failed to import module '%s'.",
                full_name,
                extra={"module_name": full_name, "exception_type": type(e).__name__},
            )


def parse_tags(text: str) -> tuple[str, dict[str, str | bool]]:
    """
    Parse tags from a string formatted with %{tag_name[:value]}c.

    Args:
        text (str): The input string containing tags.

    Returns:
        tuple[str, dict[str, str | bool]]: A tuple containing the string with tags removed and a dictionary of tags.

    """
    tags: dict[str, str | bool] = {}

    def replacer(match: re.Match) -> str:
        name = match.group(1)
        value = match.group(2)
        tags[name] = value if value is not None else True
        return ""

    return TAG_REGEX.sub(replacer, text).strip(), tags


def str_to_dt(time_str: str, now=None) -> datetime:
    """
    Convert a string representation of time into a datetime object.

    Args:
        time_str (str): The string representation of time.
        now (datetime, optional): The base datetime to use for relative times. Defaults to None, which uses the current UTC time.

    Returns:
        datetime: A datetime object representing the parsed time.

    Raises:
        ValueError: If the time string cannot be parsed.

    """
    from dateparser import parse as _parse

    dt: datetime | None = _parse(
        time_str,
        settings={
            "RELATIVE_BASE": now or datetime.now(tz=UTC),
            "RETURN_AS_TIMEZONE_AWARE": True,
            "TO_TIMEZONE": "UTC",
        },
    )

    if dt is None:
        msg: str = f"Couldn't parse date: {time_str!r}"
        raise ValueError(msg)

    return dt


def get_channel_images(thumbnails: list[dict]) -> dict:
    """
    Extract channel images from a list of thumbnail dictionaries.

    Args:
        thumbnails (list[dict]): List of thumbnail dictionaries with keys 'url', 'width', 'height', and 'id'.

    Returns:
        dict: A dictionary with keys 'icon', 'landscape', 'poster', 'thumb', 'fanart', and 'banner' mapped to their respective URLs.

    """
    artwork = {}

    for t in thumbnails:
        url = t.get("url")
        if not url:
            continue

        width = t.get("width")
        height = t.get("height")
        tid = t.get("id", "")

        if not width or not height:
            if "avatar_uncropped" in tid:
                artwork["icon"] = url

            elif "banner_uncropped" in tid:
                artwork["landscape"] = url

            continue

        ratio = width / height

        if 0.55 <= ratio <= 0.75:  # portrait → poster
            artwork["poster"] = url
        elif 0.9 <= ratio <= 1.1:  # square → thumb
            artwork.setdefault("thumb", url)
        elif ratio >= 5:  # very wide
            if width >= 1920:
                artwork["fanart"] = url
            else:
                artwork["banner"] = url
        elif 1.6 <= ratio <= 1.8:  # landscape
            artwork["landscape"] = url

    if "fanart" not in artwork and "banner" in artwork:
        artwork["fanart"] = artwork["banner"]

    if "banner" not in artwork and "fanart" in artwork:
        artwork["banner"] = artwork["fanart"]

    if "poster" not in artwork and "thumb" in artwork:
        artwork["poster"] = artwork["thumb"]  # optional fallback

    return artwork


def create_cookies_file(cookies: str, file: Path | None = None) -> Path:
    """
    Create a cookies file from a string of cookies.

    Args:
        cookies (str): The cookie string.
        file (Path|None): The path to the cookie file. If None, a temporary file is created.

    Returns:
        Path: The path to the created cookie file.

    """
    if file is None:
        from .config import Config

        file = Path(Config.get_instance().temp_path, f"c_{uuid.uuid4().hex}.txt")

    file.parent.mkdir(parents=True, exist_ok=True)
    file.write_text(cookies)

    load_cookies(file)

    return file