utils.py

"""
====================================================
Universal File Converter
Utility Functions
====================================================
"""

from __future__ import annotations

import os
import re
import shutil
import tempfile
import zipfile
from pathlib import Path
from typing import Iterable

from config import OUTPUT_DIR


def sanitize_filename(filename: str) -> str:
    """
    Remove invalid characters from a filename.
    """
    filename = Path(filename).name
    filename = re.sub(r'[<>:"/\\|?*]', "_", filename)
    filename = re.sub(r"\s+", "_", filename)
    return filename


def ensure_directory(directory: str | Path) -> Path:
    """
    Create a directory if it does not exist.
    """
    directory = Path(directory)
    directory.mkdir(parents=True, exist_ok=True)
    return directory


def get_unique_filename(output_path: str | Path) -> Path:
    """
    Prevent accidental overwrite by generating a unique filename.
    """
    output_path = Path(output_path)

    if not output_path.exists():
        return output_path

    stem = output_path.stem
    suffix = output_path.suffix
    parent = output_path.parent

    counter = 1

    while True:
        candidate = parent / f"{stem}_{counter}{suffix}"

        if not candidate.exists():
            return candidate

        counter += 1


def create_temp_directory() -> Path:
    """
    Create a temporary working directory.
    """
    return Path(tempfile.mkdtemp())


def cleanup_temp_directory(directory: str | Path) -> None:
    """
    Delete a temporary directory safely.
    """
    directory = Path(directory)

    if directory.exists():
        shutil.rmtree(directory, ignore_errors=True)


def create_zip(files: Iterable[str | Path], zip_name: str) -> Path:
    """
    Create a ZIP archive from multiple files.
    """
    ensure_directory(OUTPUT_DIR)

    zip_path = OUTPUT_DIR / zip_name

    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as archive:

        for file in files:

            file = Path(file)

            if file.exists():
                archive.write(file, arcname=file.name)

    return zip_path


def file_size_mb(file_path: str | Path) -> float:
    """
    Return file size in MB.
    """
    size = Path(file_path).stat().st_size
    return round(size / (1024 * 1024), 2)


def delete_file(file_path: str | Path) -> None:
    """
    Delete a file if it exists.
    """
    file_path = Path(file_path)

    if file_path.exists():
        file_path.unlink()


def clear_output_directory() -> None:
    """
    Remove all files from the output directory.
    """
    ensure_directory(OUTPUT_DIR)

    for item in OUTPUT_DIR.iterdir():

        if item.is_file():
            item.unlink()

        elif item.is_dir():
            shutil.rmtree(item)


def list_output_files() -> list[Path]:
    """
    Return all converted files.
    """
    ensure_directory(OUTPUT_DIR)

    return sorted([file for file in OUTPUT_DIR.iterdir() if file.is_file()])


def open_output_directory() -> None:
    """
    Open output directory in the system file explorer.
    """
    path = str(OUTPUT_DIR.resolve())

    if os.name == "nt":
        os.startfile(path)

    elif os.name == "posix":
        os.system(f'xdg-open "{path}"')


def reset_application() -> None:
    """
    Reset application generated files.
    """
    clear_output_directory()


def cleanup_old_files(
    directory: str | Path,
    max_age_hours: int = 24,
) -> None:
    """
    Delete files older than max_age_hours.
    """

    import time

    directory = Path(directory)

    if not directory.exists():
        return

    current_time = time.time()

    for file in directory.iterdir():

        if not file.is_file():
            continue

        age = (current_time - file.stat().st_mtime) / 3600

        if age >= max_age_hours:

            try:
                file.unlink()

            except Exception:
                pass