storage_utils.py

"""
Storage utilities: user file storage, encryption, pCloud download helpers.
"""

from __future__ import annotations

import logging
import os
import re
import tempfile
import time
from collections.abc import Iterator

from config import STORAGE_MOUNT_POINT
from crypto_utils import crypto

logger = logging.getLogger(__name__)

try:
    from pcloud_dl import PCloudDownloader  # noqa: F401

    HAS_PCLOUD_DL = True
except ImportError:
    HAS_PCLOUD_DL = False


def get_allowed_paths(username: str, is_admin: bool = False) -> list[str]:
    """
    Returns a list of authorized root directories for the file picker.
    """
    shared_path = "/mnt/storage/share"
    user_base_path = "/mnt/storage"

    # Always include the share directory
    allowed_dirs = [shared_path]

    if is_admin:
        # Admins see the root of all user folders
        allowed_dirs.append(user_base_path)
    else:
        # Standard users see only their specific subfolder
        personal_path = os.path.join(user_base_path, username)
        if os.path.exists(personal_path):
            allowed_dirs.append(personal_path)

    return [d for d in allowed_dirs if os.path.exists(d)]


def copy_storage_file_to_temp(file_path: str | None, user_state: dict | None = None) -> str | None:
    """
    Copies a file from Storage Box to local temp for processing.
    Handles encrypted files automatically.
    Returns path to local temp file.
    """
    if not file_path:
        return None

    username = user_state.get("username") if user_state else None
    if not username:
        raise ValueError("Nicht angemeldet")

    # Load file (with decryption if .enc)
    success, file_data, msg = load_from_user_storage(
        username=username,
        filepath=file_path,
        decrypt=file_path.endswith(".enc"),
        user_state=user_state,
    )

    if not success:
        raise ValueError(f"Konnte Datei nicht laden: {msg}")

    # Determine original filename (remove .enc if present)
    filename = os.path.basename(file_path)
    if filename.endswith(".enc"):
        filename = filename[:-4]  # Remove .enc extension

    # Write to temp
    temp_path = os.path.join(tempfile.gettempdir(), f"sb_{int(time.time())}_{filename}")
    with open(temp_path, "wb") as f:
        f.write(file_data)

    logger.info(f"✅ Decrypted to temp: {temp_path}")
    return temp_path


def get_user_storage_path(username: str | None) -> str | None:
    """
    Returns the user-specific storage path.
    Standardized to use the 'users' subdirectory for consistency across the app.
    """
    if not username:
        logger.error("❌ get_user_storage_path called without username")
        return None

    user_path = os.path.join(STORAGE_MOUNT_POINT, "users", username)

    # Defense-in-depth: resolve symlinks and verify the path stays inside
    # the storage mount. Blocks path traversal even if username validation
    # is bypassed or a symlink is planted.
    users_base = os.path.realpath(os.path.join(STORAGE_MOUNT_POINT, "users"))
    resolved = os.path.realpath(user_path)
    if not resolved.startswith(users_base + os.sep) and resolved != users_base:
        logger.error(
            "Path traversal blocked: resolved %r escapes base %r",
            resolved, users_base,
        )
        return None

    logger.info(f"Storage path requested for user '{username}': {user_path}")

    # Create directory with proper permissions
    try:
        if not os.path.exists(user_path):
            os.makedirs(user_path, mode=0o700, exist_ok=True)
            logger.info(f"Created storage directory: {user_path}")
        else:
            logger.debug(f"Storage directory exists: {user_path}")

        if not os.access(user_path, os.R_OK | os.W_OK):
            logger.error(f"Storage directory not accessible (Permissions/Mount): {user_path}")
            return None

        return user_path

    except Exception as e:
        logger.error(f"❌ Failed to create/access storage path for {username}: {e}")
        logger.exception(e)
        return None


def ensure_user_storage_dirs(username: str | None) -> bool:
    """
    Creates user-specific storage directory.
    Called at login time.
    """
    if not username:
        logger.warning("❌ ensure_user_storage_dirs called without username")
        return False

    user_path = get_user_storage_path(username)

    if user_path and os.path.exists(user_path):
        logger.info(f"✅ Storage directory verified for user '{username}': {user_path}")

        # List contents for debugging
        try:
            contents = os.listdir(user_path)
            logger.info(f"📁 Storage contents for '{username}': {len(contents)} items")
            if contents:
                logger.debug(f"   Files: {contents[:5]}{'...' if len(contents) > 5 else ''}")
        except Exception as e:
            logger.warning(f"⚠️ Could not list storage contents: {e}")

        return True

    logger.error(f"❌ Storage directory creation failed for user '{username}'")
    return False


# Allowed extensions for uploaded files. Anything not in this set is refused
# to prevent stored-XSS (HTML/SVG), code execution (.py, .sh, .exe),
# and unknown binary risk. Extend as needed.
UPLOAD_ALLOWED_EXTENSIONS = frozenset(
    {
        ".pdf",
        ".doc",
        ".docx",
        ".odt",
        ".xls",
        ".xlsx",
        ".ods",
        ".csv",
        ".tsv",
        ".ppt",
        ".pptx",
        ".odp",
        ".txt",
        ".md",
        ".rtf",
        ".log",
        ".json",
        ".xml",
        ".yaml",
        ".yml",
        ".png",
        ".jpg",
        ".jpeg",
        ".gif",
        ".webp",
        ".tiff",
        ".bmp",
        # ".svg",  # removed: SVG can contain embedded JavaScript (stored XSS)
        ".mp3",
        ".wav",
        ".ogg",
        ".flac",
        ".m4a",
        ".aac",
        ".wma",
        ".mp4",
        ".mkv",
        ".avi",
        ".mov",
        ".webm",
        ".zip",
        ".gz",
        ".tar",
        ".7z",
        ".rar",
        ".bib",
        ".ris",
        ".enw",
    }
)

# Maximum upload size: 200 MB. Change via $MAX_UPLOAD_BYTES if needed.
MAX_UPLOAD_BYTES = int(os.environ.get("MAX_UPLOAD_BYTES", 200 * 1024 * 1024))


def save_to_user_storage(
    username: str,
    filename: str,
    file_data: bytes | str,
    encrypt: bool = True,
    user_state: dict | None = None,
) -> tuple[bool, str | None, str]:
    """
    Save file to user's storage box with optional encryption.

    Args:
        username: User's username
        filename: Desired filename
        file_data: bytes or file path
        encrypt: Whether to encrypt the file
        user_state: User session state (for UMK)

    Returns:
        (success: bool, storage_path: str, message: str)
    """
    logger.info(f"💾 save_to_user_storage: user={username}, file={filename}, encrypt={encrypt}")

    try:
        # 0. Validate extension + size
        ext = os.path.splitext(filename)[1].lower()
        if ext and ext not in UPLOAD_ALLOWED_EXTENSIONS:
            return False, None, f"❌ Dateityp '{ext}' nicht erlaubt"

        # 1. Get user storage path
        user_path = get_user_storage_path(username)
        if not user_path:
            return False, None, "❌ Storage path nicht verfügbar"

        # 2. Generate safe filename
        safe_filename = re.sub(r'[<>:"/\\|?*\u0000-\u001F\u007F-\u009F/]', "_", filename)
        # Strip leading dots/dashes to prevent hidden files or option-like names
        safe_filename = safe_filename.lstrip(".-")
        if not safe_filename:
            safe_filename = "unnamed_upload"
        if encrypt:
            safe_filename += ".enc"

        storage_path = os.path.join(user_path, safe_filename)

        # Path traversal guard (mirrors load_from_user_storage)
        abs_storage = os.path.abspath(storage_path)
        abs_user = os.path.abspath(user_path)
        if not abs_storage.startswith(abs_user + os.sep) and abs_storage != abs_user:
            logger.error("🚫 Path traversal blocked in save_to_user_storage: %s", abs_storage)
            return False, None, "🚫 Ungültiger Dateiname"

        logger.info(f"📂 Target storage path: {storage_path}")

        # 3. Read file data if it's a path
        if isinstance(file_data, str) and os.path.exists(file_data):
            logger.debug(f"📥 Reading file from path: {file_data}")
            with open(file_data, "rb") as f:
                file_data = f.read()
        elif not isinstance(file_data, bytes):
            logger.error(f"❌ Invalid file_data type: {type(file_data)}")
            return False, None, "❌ Ungültige Datei-Daten"

        logger.info(f"📊 File size: {len(file_data)} bytes")

        if len(file_data) > MAX_UPLOAD_BYTES:
            return (
                False,
                None,
                f"❌ Datei zu gross ({len(file_data) / (1024 * 1024):.1f} MB, max {MAX_UPLOAD_BYTES / (1024 * 1024):.0f} MB)",
            )

        # 4. Encrypt if requested
        if encrypt:
            logger.info("🔐 Encrypting file...")
            umk = user_state.get("umk") if user_state else crypto.global_key

            if not umk:
                logger.error("❌ No encryption key available")
                return False, None, "❌ Kein Verschlüsselungsschlüssel"

            # Ensure key is properly formatted for Fernet
            import base64

            key_for_fernet = umk
            if isinstance(key_for_fernet, bytes) and len(key_for_fernet) == 32:
                key_for_fernet = base64.urlsafe_b64encode(key_for_fernet)

            from cryptography.fernet import Fernet

            f = Fernet(key_for_fernet)
            file_data = f.encrypt(file_data)
            logger.info(f"✅ File encrypted. New size: {len(file_data)} bytes")

        # 5. Write to storage
        logger.info(f"💾 Writing to storage: {storage_path}")
        with open(storage_path, "wb") as f:
            f.write(file_data)

        # 6. Set proper permissions (user-only)
        os.chmod(storage_path, 0o600)

        logger.info(f"✅ File saved successfully: {storage_path}")
        return True, storage_path, f"✅ Gespeichert: {safe_filename}"

    except Exception as e:
        logger.exception(f"❌ Error saving to storage: {e}")
        return False, None, f"❌ Fehler: {e!s}"


def load_from_user_storage(
    username: str, filepath: str, decrypt: bool = True, user_state: dict | None = None
) -> tuple[bool, bytes | None, str]:
    """
    Load and optionally decrypt a file from user's storage.

    Args:
        username: User's username
        filepath: Full path or filename in user's storage
        decrypt: Whether to decrypt the file
        user_state: User session state (for UMK)

    Returns:
        (success: bool, file_data: bytes, message: str)
    """
    logger.info(f"📂 load_from_user_storage: user={username}, file={filepath}, decrypt={decrypt}")

    try:
        # 1. Resolve path
        if not filepath.startswith(STORAGE_MOUNT_POINT):
            # It's a relative path, construct full path
            user_path = get_user_storage_path(username)
            if not user_path:
                return False, None, "❌ Storage nicht verfügbar"
            filepath = os.path.join(user_path, filepath)

        logger.info(f"📁 Full path: {filepath}")

        # 2. Security check: Ensure path is within user's directory
        user_path = get_user_storage_path(username)
        abs_filepath = os.path.abspath(filepath)
        abs_user_path = os.path.abspath(user_path)

        if not abs_filepath.startswith(abs_user_path):
            logger.error("🚫 Security violation: Path outside user directory")
            logger.error(f"   Requested: {abs_filepath}")
            logger.error(f"   User dir: {abs_user_path}")
            return False, None, "🚫 Zugriff verweigert"

        # 3. Check file exists
        if not os.path.exists(filepath):
            logger.error(f"❌ File not found: {filepath}")
            return False, None, "❌ Datei nicht gefunden"

        # 4. Read file
        logger.info(f"📥 Reading file: {filepath}")
        with open(filepath, "rb") as f:
            file_data = f.read()

        logger.info(f"📊 File size: {len(file_data)} bytes")

        # 5. Decrypt if needed
        if decrypt and filepath.endswith(".enc"):
            logger.info("🔓 Decrypting file...")
            umk = user_state.get("umk") if user_state else crypto.global_key

            if not umk:
                logger.error("❌ No decryption key available")
                return False, None, "❌ Kein Entschlüsselungsschlüssel"

            # Ensure key is properly formatted
            import base64

            key_for_fernet = umk
            if isinstance(key_for_fernet, bytes) and len(key_for_fernet) == 32:
                key_for_fernet = base64.urlsafe_b64encode(key_for_fernet)

            from cryptography.fernet import Fernet

            f = Fernet(key_for_fernet)
            file_data = f.decrypt(file_data)
            logger.info(f"✅ File decrypted. Size: {len(file_data)} bytes")

        logger.info("✅ File loaded successfully")
        return True, file_data, "✅ Geladen"

    except Exception as e:
        logger.exception(f"❌ Error loading from storage: {e}")
        return False, None, f"❌ Fehler: {e!s}"


def list_user_storage_files(username: str, pattern: str = "*") -> tuple[bool, list[str], str]:
    """
    List files in user's storage directory.

    Returns:
        (success: bool, files: list, message: str)
    """
    logger.info(f"📋 list_user_storage_files: user={username}, pattern={pattern}")

    try:
        user_path = get_user_storage_path(username)
        if not user_path:
            return False, [], "❌ Storage nicht verfügbar"

        import glob

        search_pattern = os.path.join(user_path, pattern)
        files = glob.glob(search_pattern)

        # Make paths relative for display
        relative_files = [os.path.relpath(f, user_path) for f in files]

        logger.info(f"📁 Found {len(relative_files)} files for user '{username}'")
        logger.debug(f"   Files: {relative_files[:10]}{'...' if len(relative_files) > 10 else ''}")

        return True, relative_files, f"✅ {len(relative_files)} Dateien"

    except Exception as e:
        logger.exception(f"❌ Error listing storage: {e}")
        return False, [], f"❌ Fehler: {e!s}"


# --- pCLOUD BULK DOWNLOADER INTEGRATION ---
def run_pcloud_bulk_import(url: str, user_state: dict | None) -> Iterator[str]:
    if not user_state or not user_state.get("id"):
        yield "❌ Bitte anmelden."
        return

    # Permission Check: Only Admins and Media Managers should handle bulk imports (70GB+)
    if not (user_state.get("is_admin") or user_state.get("is_media_manager")):
        yield "⛔ Zugriff verweigert: Nur Medienverwalter dürfen Massen-Imports durchführen."
        return

    from pcloud_dl import PCloudDownloader  # Import the class from our script

    username = user_state.get("username")
    output_dir = get_user_storage_path(username)

    downloader = PCloudDownloader(url, output_dir)
    code = downloader.code
    if not code:
        yield "❌ Ungültiger pCloud Link."
        return

    yield f"🔍 Analysiere Link: {code}..."
    files = downloader.get_metadata()

    if not files:
        yield "❌ Keine Dateien gefunden oder Link gesperrt."
        return

    total_gb = sum(f["size"] for f in files) / 1e9
    logs = f"📂 Gefunden: {len(files)} Dateien ({total_gb:.2f} GB)\n"
    logs += f"📍 Ziel: Storage Box / {username}\n"
    yield logs

    for i, f_info in enumerate(files):
        fname = f_info["name"]
        fsize = f_info["size"]
        step = i + 1

        logs += f"\n⏳ [{step}/{len(files)}] Lade: {fname} ({fsize / 1e6:.1f} MB)..."
        yield logs

        try:
            # We recreate the download_file logic here to yield progress
            dl_api = f"https://{downloader.api_host}/getpublinkdownload?code={downloader.code}&fileid={f_info['fileid']}"
            res = downloader.session.get(dl_api).json()

            if res.get("result") == 0:
                direct_url = f"https://{res['hosts'][0]}{res['path']}"
                target_path = os.path.join(output_dir, os.path.basename(fname))

                with downloader.session.get(direct_url, stream=True) as r:
                    r.raise_for_status()
                    with open(target_path, "wb") as f:
                        for chunk in r.iter_content(chunk_size=1024 * 1024):
                            f.write(chunk)
                logs += " ✅"
                yield logs
            else:
                logs += f" ❌ Fehler: {res.get('error')}"
                yield logs
        except Exception as e:
            logs += f" ❌ Kritischer Fehler: {e!s}"
            yield logs

    yield logs + "\n\n🎉 Bulk-Import abgeschlossen!"


def pcloud_download_handler(
    url: str, selected_files: list[str], custom_subpath: str | None, user_state: dict | None
) -> Iterator[str]:
    from pcloud_dl import PCloudDownloader

    if not user_state or not user_state.get("id"):
        yield "❌ Nicht angemeldet."
        return
    if not selected_files:
        yield "⚠️ Bitte mindestens eine Datei auswählen."
        return

    try:
        username = user_state.get("username")
        base_storage = get_user_storage_path(username)

        # Path logic: Use custom or default
        final_subpath = custom_subpath.strip("/") if custom_subpath else "pcloud/shared/default"
        full_target_dir = os.path.join(base_storage, final_subpath)
        os.makedirs(full_target_dir, exist_ok=True)

        downloader = PCloudDownloader(url)
        _, all_files = downloader.scan_link()

        # Filter out folders, only keep files with size
        valid_files = [f for f in all_files if not f.get("isfolder", False) and "size" in f]

        # Filter only files selected in UI
        files_to_dl = [
            f for f in valid_files if f"{f['name']} ({f['size'] / 1e6:.1f} MB)" in selected_files
        ]

        if not files_to_dl:
            yield "❌ Keine gültigen Dateien zum Download gefunden."
            return

        logs = f"🚀 Starte Import nach: {final_subpath}\n"
        logs += f"📦 {len(files_to_dl)} Dateien werden heruntergeladen\n"
        yield logs

        for i, f_info in enumerate(files_to_dl):
            fname = f_info["name"]
            fsize = f_info.get("size", 0)
            logs += f"\n⏳ [{i + 1}/{len(files_to_dl)}] {fname} ({fsize / 1e6:.1f} MB)..."
            yield logs

            try:
                dl_url = downloader.get_download_url(f_info["fileid"])
                if dl_url:
                    target_path = os.path.join(full_target_dir, os.path.basename(fname))
                    with downloader.session.get(dl_url, stream=True, timeout=300) as r:
                        r.raise_for_status()
                        with open(target_path, "wb") as f:
                            for chunk in r.iter_content(chunk_size=1024 * 1024):
                                if chunk:
                                    f.write(chunk)
                    logs += " ✅"
                else:
                    logs += " ❌ Link-Fehler"
            except Exception as e:
                logs += f" ❌ Fehler: {e!s}"
                logger.error(f"Download error for {fname}: {e}")

            yield logs

        yield logs + "\n\n🎉 Fertig!"

    except Exception as e:
        logger.error(f"pCloud download error: {e}")
        yield f"❌ Kritischer Fehler: {e!s}"


# ==========================================
# 🎙️ TRANSCRIPTION UTILITIES
# ==========================================