main_app.py

from flask import render_template, request, jsonify, send_from_directory, url_for, send_file, after_this_request, make_response
import os
import json
import subprocess
import base64
import binascii
import logging
import threading
import uuid
import copy
import re
import tempfile
import glob
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Set, Tuple
import shutil
import tarfile
import zipfile
import stat
from werkzeug.utils import secure_filename
from pydub import AudioSegment
import wave
import math
from collections import OrderedDict
from app_factory import create_flask_app, register_app_routes
from services.script_catalog import (
    get_script_definition as get_script_definition_service,
    get_scripts_catalog as get_scripts_catalog_service,
    infer_autofill_kind as infer_autofill_kind_service,
    prepare_script_entry as prepare_script_entry_service,
    rebuild_scripts_config_file as rebuild_scripts_config_file_service,
)
from services.script_meta import validate_script_meta
from services.project_files import (
    build_audio_metadata as build_audio_metadata_service,
    build_failed_generation_json_metadata as build_failed_generation_json_metadata_service,
    collect_directory_entries as collect_directory_entries_service,
    compute_failed_generation_highlights as compute_failed_generation_highlights_service,
    get_audio_metadata_directories as get_audio_metadata_directories_service,
    get_failed_generation_directories as get_failed_generation_directories_service,
    get_tts_root_directory as get_tts_root_directory_service,
    sanitize_storage_relative_path as sanitize_storage_relative_path_service,
    should_enable_failed_move as should_enable_failed_move_service,
)
from services.workflow_jobs import (
    build_log_links as build_log_links_service,
    cleanup_workflow_resources as cleanup_workflow_resources_service,
    get_project_jobs as get_project_jobs_service,
    get_workflow_event as get_workflow_event_service,
    get_workflow_job as get_workflow_job_service,
    get_workflow_thread as get_workflow_thread_service,
    read_log_tail as read_log_tail_service,
    register_workflow_job as register_workflow_job_service,
    request_workflow_cancel as request_workflow_cancel_service,
    run_workflow_job as run_workflow_job_service,
    set_workflow_thread as set_workflow_thread_service,
    update_workflow_job as update_workflow_job_service,
)
from services.workflow_state import (
    ensure_workflows_dir as ensure_workflows_dir_service,
    get_project_root_path as get_project_root_path_service,
    get_project_workflow_state_path as get_project_workflow_state_path_service,
    list_workflow_templates as list_workflow_templates_service,
    load_project_workflow_state as load_project_workflow_state_service,
    load_workflow_template as load_workflow_template_service,
    save_project_workflow_state as save_project_workflow_state_service,
    save_workflow_template_file as save_workflow_template_file_service,
    sanitize_workflow_id as sanitize_workflow_id_service,
    load_workflow_file as load_workflow_file_service,
)
from services.workflow_execution import (
    build_command_for_step as build_command_for_step_service,
    build_masked_command_and_params as build_masked_command_and_params_service,
    coerce_bool as coerce_bool_service,
    mask_workflow_secret_params as mask_workflow_secret_params_service,
    mask_applied_params_for_ui as mask_applied_params_for_ui_service,
    mask_command_for_ui as mask_command_for_ui_service,
    normalize_workflow_steps as normalize_workflow_steps_service,
    run_script_command as run_script_command_service,
    unmask_secret_param_value as unmask_secret_param_value_service,
)
app = create_flask_app(__name__)

logging.basicConfig(level=logging.INFO)

config_lock = threading.Lock()
workflow_lock = threading.Lock()
theme_config_lock = threading.Lock()
workflow_jobs = {}
workflow_threads = {}
workflow_events = {}
review_audio_encoding_jobs: Dict[str, Dict[str, Any]] = {}
review_audio_encoding_lock = threading.Lock()

CONFIG_FILE_PATH = Path(app.root_path) / 'config.json'
CONFIG_MTIME: Optional[float] = None
KEYHOLDER_PATH = os.path.join(app.root_path, 'keyholder.json')
CONDA_PYTHON_CACHE = {}

AUDIO_EXTENSIONS = {'.wav', '.mp3', '.ogg', '.flac', '.m4a', '.aac'}
VIDEO_EXTENSIONS = {
    '.mp4', '.mkv', '.avi', '.mov', '.webm', '.wmv', '.flv', '.mts', '.m2ts', '.mpg', '.mpeg'
}

DEFAULT_UI_LANGUAGE = 'hun'
UI_LANGUAGE_COOKIE = 'ui_language'
language_cache_lock = threading.Lock()
language_cache: Dict[Tuple[str, str], Dict[str, Any]] = {}


def derive_project_prefix(name: str) -> str:
    tokens = [part for part in re.split(r'[._-]+', name) if part]
    if not tokens:
        return name or 'Egyéb'
    prefix = tokens[0]
    if len(tokens) >= 2 and len(prefix) <= 3:
        prefix = f"{prefix}_{tokens[1]}"
    return prefix


def build_project_entries(projects: List[str], group_threshold: int = 3) -> List[Dict[str, Any]]:
    grouped: "OrderedDict[str, List[str]]" = OrderedDict()
    for project in projects:
        key = derive_project_prefix(project)
        if key not in grouped:
            grouped[key] = []
        grouped[key].append(project)

    entries: List[Dict[str, Any]] = []
    for key, names in grouped.items():
        if len(names) >= group_threshold:
            entries.append({
                'type': 'group',
                'key': key,
                'projects': names,
                'count': len(names)
            })
        else:
            for name in names:
                entries.append({
                    'type': 'project',
                    'name': name
                })
    return entries


def sanitize_segment_strings(segments: Any) -> Any:
    """
    Remove stray escape sequences that break JSON loading on the front-end.
    """
    if not isinstance(segments, list):
        return segments

    for segment in segments:
        if not isinstance(segment, dict):
            continue
        for key in ('text', 'translated_text'):
            value = segment.get(key)
            if isinstance(value, str):
                segment[key] = value.replace('\\"', '"')
    return segments


def format_time_for_filename(time_in_seconds: Any) -> str:
    """
    Convert a time value (seconds) into the HH-MM-SS-mmm pattern used for split filenames.
    """
    try:
        time_float = float(time_in_seconds)
    except (TypeError, ValueError):
        return "00-00-00-000"

    total_milliseconds = int(round(time_float * 1000))
    if total_milliseconds < 0:
        total_milliseconds = 0

    hours = total_milliseconds // 3_600_000
    minutes = (total_milliseconds % 3_600_000) // 60_000
    seconds = (total_milliseconds % 60_000) // 1_000
    milliseconds = total_milliseconds % 1_000

    return f"{hours:02d}-{minutes:02d}-{seconds:02d}-{milliseconds:03d}"


def annotate_segments_with_translated_splits(project_dir: str, segments: List[Dict[str, Any]]) -> None:
    """
    Mark each segment with a flag indicating whether a translated split WAV exists.
    """
    try:
        project_subdirs = config.get('PROJECT_SUBDIRS') if isinstance(config, dict) else {}
    except NameError:
        project_subdirs = {}

    translated_splits_subdir = (project_subdirs or {}).get('translated_splits')
    base_dir = Path(project_dir) / translated_splits_subdir if translated_splits_subdir else None
    base_dir_exists = base_dir.exists() if base_dir else False

    for segment in segments:
        has_split = False
        if isinstance(segment, dict):
            start = segment.get('start')
            end = segment.get('end')
            if (
                base_dir_exists
                and isinstance(start, (int, float))
                and isinstance(end, (int, float))
            ):
                filename = f"{format_time_for_filename(start)}_{format_time_for_filename(end)}.wav"
                has_split = (base_dir / filename).is_file()
        segment['has_translated_split'] = has_split


def prepare_segments_for_response(project_dir: str, segments: Any) -> List[Dict[str, Any]]:
    """
    Return a sanitized, annotated copy of the segment list for front-end consumption.
    """
    if not isinstance(segments, list):
        return []
    prepared_segments: List[Dict[str, Any]] = copy.deepcopy(segments)
    sanitize_segment_strings(prepared_segments)
    annotate_segments_with_translated_splits(project_dir, prepared_segments)
    return prepared_segments


def collect_translated_split_progress(project_name: str, config_snapshot: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
    current_config = config_snapshot or get_config_copy()
    directories = current_config.get('DIRECTORIES') or {}
    project_subdirs = current_config.get('PROJECT_SUBDIRS') or {}

    workdir_rel = directories.get('workdir')
    translated_rel = project_subdirs.get('translated')
    translated_splits_rel = project_subdirs.get('translated_splits')
    if not workdir_rel or not translated_rel or not translated_splits_rel:
        raise WorkflowValidationError(
            "Hiányzó config kulcs: DIRECTORIES.workdir, PROJECT_SUBDIRS.translated vagy PROJECT_SUBDIRS.translated_splits."
        )

    safe_project = secure_filename(project_name)
    project_dir = Path(workdir_rel) / safe_project
    if not project_dir.is_dir():
        raise FileNotFoundError(f"A projekt könyvtár nem található: {project_dir}")

    translated_dir = project_dir / translated_rel
    if not translated_dir.is_dir():
        raise FileNotFoundError(f"A translated könyvtár nem található: {translated_dir}")

    translated_json_files = sorted(
        path for path in translated_dir.iterdir()
        if path.is_file() and path.suffix.lower() == '.json'
    )
    if not translated_json_files:
        raise FileNotFoundError(f"Nem található JSON fájl a translated könyvtárban: {translated_dir}")

    selected_json_path = translated_json_files[0]
    try:
        with selected_json_path.open('r', encoding='utf-8') as file:
            payload = json.load(file)
    except OSError as exc:
        raise FileNotFoundError(f"Nem sikerült beolvasni a translated JSON fájlt: {selected_json_path}") from exc
    except json.JSONDecodeError as exc:
        raise WorkflowValidationError(f"Hibás JSON formátum: {selected_json_path.name}") from exc

    segments = payload.get('segments')
    if not isinstance(segments, list):
        raise WorkflowValidationError(
            f'A kiválasztott translated JSON fájl nem tartalmaz érvényes "segments" listát: {selected_json_path.name}'
        )

    expected_segment_stems: List[str] = []
    translated_ready_segments = 0
    for segment in segments:
        if not isinstance(segment, dict):
            continue
        start = segment.get('start')
        end = segment.get('end')
        original_text = str(segment.get('text') or '').strip()
        translated_text = str(segment.get('translated_text') or '').strip()
        if not isinstance(start, (int, float)) or not isinstance(end, (int, float)):
            continue
        if not original_text:
            continue
        expected_segment_stems.append(f"{format_time_for_filename(start)}_{format_time_for_filename(end)}")
        if translated_text:
            translated_ready_segments += 1

    translated_splits_dir = project_dir / translated_splits_rel
    actual_audio_stems: Set[str] = set()
    if translated_splits_dir.is_dir():
        for path in translated_splits_dir.iterdir():
            if path.is_file() and path.suffix.lower() in AUDIO_EXTENSIONS:
                actual_audio_stems.add(path.stem)

    completed_segments = sum(1 for stem in expected_segment_stems if stem in actual_audio_stems)
    expected_segments = len(expected_segment_stems)

    return {
        'project_name': safe_project,
        'json_file_name': selected_json_path.name,
        'translated_dir': translated_rel,
        'translated_splits_dir': translated_splits_rel,
        'total_segments': len(segments),
        'expected_segments': expected_segments,
        'translated_ready_segments': translated_ready_segments,
        'completed_segments': completed_segments,
        'missing_segments': max(expected_segments - completed_segments, 0),
        'actual_audio_files': len(actual_audio_stems),
        'translated_splits_exists': translated_splits_dir.is_dir()
    }


def resolve_project_paths(project_name: str) -> Path:
    safe_project = secure_filename(project_name)
    return Path('workdir') / safe_project


def resolve_source_audio_path(project_name: str, audio_file_name: str) -> Optional[Path]:
    if not project_name or not audio_file_name:
        return None
    project_root = resolve_project_paths(project_name)
    speech_subdir = (config.get('PROJECT_SUBDIRS') or {}).get('separated_audio_speech')
    if not speech_subdir:
        return None
    candidate = project_root / speech_subdir / os.path.basename(audio_file_name)
    if candidate.is_file():
        return candidate
    return None


def get_review_encoded_audio_path(project_name: str, audio_file_name: str) -> Optional[Path]:
    temp_subdir = (config.get('PROJECT_SUBDIRS') or {}).get('temp')
    if not temp_subdir or not audio_file_name:
        return None
    project_root = resolve_project_paths(project_name)
    temp_dir = project_root / temp_subdir
    try:
        temp_dir.mkdir(parents=True, exist_ok=True)
    except OSError as exc:
        logging.error("Failed to create temp dir %s: %s", temp_dir, exc)
        return None
    source_stem = Path(audio_file_name).stem or Path(audio_file_name).name
    encoded_name = f"{source_stem}_review_preview.mp3"
    return temp_dir / encoded_name


def probe_audio_duration(audio_path: Path) -> Optional[float]:
    try:
        result = subprocess.run(
            [
                'ffprobe',
                '-v',
                'error',
                '-show_entries',
                'format=duration',
                '-of',
                'default=noprint_wrappers=1:nokey=1',
                str(audio_path)
            ],
            capture_output=True,
            text=True,
            check=True
        )
        return float(result.stdout.strip())
    except Exception as exc:
        logging.warning("Failed to probe duration for %s: %s", audio_path, exc)
        return None


def _run_review_audio_encoding_job(project_name: str, source_path: Path, target_path: Path, job: Dict[str, Any]) -> None:
    job['status'] = 'encoding'
    job['progress'] = 0.0
    duration_seconds = probe_audio_duration(source_path)
    command = [
        'ffmpeg',
        '-y',
        '-i',
        str(source_path),
        '-ac',
        '1',
        '-ar',
        '44100',
        '-b:a',
        '128k',
        '-progress',
        'pipe:1',
        '-nostats',
        str(target_path)
    ]
    proc = None
    try:
        proc = subprocess.Popen(
            command,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            bufsize=1
        )
        if proc.stdout:
            for line in proc.stdout:
                line = line.strip()
                if duration_seconds and line.startswith('out_time_ms='):
                    try:
                        current_ms = float(line.split('=')[1])
                        progress = (current_ms / (duration_seconds * 1000.0)) * 100.0
                        job['progress'] = max(0.0, min(99.0, progress))
                    except (ValueError, ZeroDivisionError):
                        continue
        proc.wait()
        if proc.returncode == 0 and target_path.exists():
            job['progress'] = 100.0
            job['status'] = 'completed'
        else:
            job['status'] = 'failed'
            job['error'] = f"ffmpeg exited with code {proc.returncode}"
            if target_path.exists():
                try:
                    target_path.unlink()
                except OSError:
                    pass
    except Exception as exc:
        job['status'] = 'failed'
        job['error'] = str(exc)
        if target_path.exists():
            try:
                target_path.unlink()
            except OSError:
                pass
    finally:
        if proc and proc.stdout:
            proc.stdout.close()
        with review_audio_encoding_lock:
            review_audio_encoding_jobs.pop(project_name, None)


def find_matching_audio_file(base_name: str, directory: str) -> Optional[str]:
    """
    Find the first audio file in directory whose stem matches base_name.
    Preference order follows PREFERRED_AUDIO_EXTENSIONS.
    """
    for extension in PREFERRED_AUDIO_EXTENSIONS:
        candidate = base_name + extension
        candidate_path = Path(directory) / candidate
        if candidate_path.is_file():
            return candidate
    return None


def delete_translated_split_file(project_dir: str, start: Any, end: Any) -> bool:
    """
    Delete the translated split WAV file for the provided time window, if it exists.
    """
    try:
        project_subdirs = config.get('PROJECT_SUBDIRS') if isinstance(config, dict) else {}
    except NameError:
        project_subdirs = {}

    translated_splits_subdir = (project_subdirs or {}).get('translated_splits')
    if not translated_splits_subdir:
        return False

    try:
        start_float = float(start)
        end_float = float(end)
    except (TypeError, ValueError):
        return False

    base_dir = Path(project_dir) / translated_splits_subdir
    if not base_dir.exists():
        return False

    filename = f"{format_time_for_filename(start_float)}_{format_time_for_filename(end_float)}.wav"
    file_path = (base_dir / filename).resolve()
    project_root = Path(project_dir).resolve()

    if not is_subpath(str(file_path), str(project_root)):
        logging.warning("Skipping translated split deletion outside project scope: %s", file_path)
        return False

    try:
        if file_path.exists() and file_path.is_file():
            file_path.unlink()
            logging.info("Deleted translated split file: %s", file_path)
            return True
    except OSError as exc:
        logging.warning("Failed to delete translated split file %s: %s", file_path, exc)
    return False

AUDIO_MIME_MAP = {
    '.wav': 'audio/wav',
    '.mp3': 'audio/mpeg',
    '.ogg': 'audio/ogg',
    '.flac': 'audio/flac',
    '.m4a': 'audio/mp4',
    '.aac': 'audio/aac'
}
VIDEO_MIME_MAP = {
    '.mp4': 'video/mp4',
    '.mkv': 'video/x-matroska',
    '.avi': 'video/x-msvideo',
    '.mov': 'video/quicktime',
    '.webm': 'video/webm',
    '.wmv': 'video/x-ms-wmv',
    '.flv': 'video/x-flv',
    '.mts': 'video/mp2t',
    '.m2ts': 'video/mp2t',
    '.mpg': 'video/mpeg',
    '.mpeg': 'video/mpeg'
}
PREFERRED_AUDIO_EXTENSIONS = ['.wav', '.mp3', '.ogg', '.flac']

SCRIPTS_DIR = Path(app.root_path) / 'scripts'
SCRIPTS_CONFIG_PATH = SCRIPTS_DIR / 'scripts.json'
SCRIPTS_CACHE: Dict[str, Any] = {'mtime': None, 'data': []}
SCRIPTS_CACHE_LOCK = threading.Lock()
CONDA_INFO_CACHE: Optional[dict] = None
CONDA_INFO_LOCK = threading.Lock()
WORKFLOWS_DIR = Path(app.root_path) / 'workflows'
WORKFLOW_STATE_FILENAME = 'workflow_state.json'
THEME_CONFIG_PATH = Path(app.root_path) / 'config' / 'theme_colors.json'
THEME_COLOR_KEYS = [
    'primary-color',
    'secondary-color',
    'success-color',
    'background-color',
    'text-color',
    'card-bg',
    'border-color',
    'waveform-bg',
    'timeline-segment-bg',
]
DEFAULT_THEME_COLORS = {
    'light': {
        'primary-color': '#0d6efd',
        'secondary-color': '#6c757d',
        'success-color': '#198754',
        'background-color': '#ffffff',
        'text-color': '#212529',
        'card-bg': '#f8f9fa',
        'border-color': '#dee2e6',
        'waveform-bg': '#f0f0f0',
        'timeline-segment-bg': 'rgba(230, 230, 250, 0.8)',
    },
    'dark': {
        'primary-color': '#0dcaf0',
        'secondary-color': '#6c757d',
        'success-color': '#198754',
        'background-color': '#212529',
        'text-color': '#f8f9fa',
        'card-bg': '#2d3339',
        'border-color': '#495057',
        'waveform-bg': '#343a40',
        'timeline-segment-bg': 'rgba(100, 100, 150, 0.8)',
    },
}

SCRIPT_KEY_REQUIREMENTS = {
    'translate_chatgpt_srt_easy_codex.py': {'chatgpt'},
    'translate.py': {'deepl'},
    'split_segments_by_speaker_codex.py': {'huggingface'},
    'whisx.py': {'huggingface'},
}

SCRIPT_PARAM_KEYHOLDER = {
    'translate_chatgpt_srt_easy_codex.py': {'auth_key': ('chatgpt_api_key', 'api_key')},
    'translate.py': {'auth_key': ('deepL_api_key', 'deepl_api_key')},
    'split_segments_by_speaker_codex.py': {'hf_token': ('hf_token',)},
    'whisx.py': {'hf_token': ('hf_token',)},
}

PROJECT_AUTOFILL_OVERRIDES = {
    'project_name': 'project_name',
    'project': 'project_name',
    'project_dir_name': 'project_name',
    'project_dir': 'project_path',
    'project_path': 'project_path',
}
SECRET_PARAM_NAMES = {'auth_key', 'api_key', 'hf_token'}
NEGATIVE_FLAG_NAME_PREFIXES: Tuple[str, ...] = ('no_', 'disable_', 'skip_', 'without_')
ENCODED_SECRET_PREFIX = 'base64:'
SECRET_VALUE_PLACEHOLDER = '***'
ALLOWED_WORKFLOW_WIDGETS = {'reviewContinue', 'cycleWidget', 'translatedSplitLoopWidget'}


class WorkflowValidationError(Exception):
    """Egy workflow lépés konfigurációja érvénytelen."""


def _normalize_theme_colors(data: Optional[Dict[str, Dict[str, Any]]]) -> Dict[str, Dict[str, str]]:
    normalized: Dict[str, Dict[str, str]] = {}
    for mode, defaults in DEFAULT_THEME_COLORS.items():
        normalized[mode] = {}
        mode_values = data.get(mode) if isinstance(data, dict) else {}
        mode_values = mode_values if isinstance(mode_values, dict) else {}
        for key, default_value in defaults.items():
            value = mode_values.get(key)
            if isinstance(value, str):
                value = value.strip() or default_value
            else:
                value = default_value
            normalized[mode][key] = value
    return normalized


def load_theme_colors() -> Dict[str, Dict[str, str]]:
    with theme_config_lock:
        if THEME_CONFIG_PATH.exists():
            try:
                with open(THEME_CONFIG_PATH, 'r', encoding='utf-8') as file:
                    raw_data = json.load(file)
            except (OSError, json.JSONDecodeError) as exc:
                logging.warning("Nem sikerült beolvasni a témaszíneket: %s", exc)
                raw_data = None
        else:
            raw_data = None
        return _normalize_theme_colors(raw_data)


def save_theme_colors(data: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, str]]:
    normalized = _normalize_theme_colors(data)
    with theme_config_lock:
        try:
            THEME_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
            with open(THEME_CONFIG_PATH, 'w', encoding='utf-8') as file:
                json.dump(normalized, file, ensure_ascii=False, indent=2)
        except OSError as exc:
            logging.error("Nem sikerült elmenteni a témaszíneket: %s", exc)
            raise
    return normalized


@app.context_processor
def inject_theme_colors():
    try:
        colors = load_theme_colors()
    except Exception as exc:
        logging.error("Nem sikerült betölteni a témaszíneket: %s", exc)
        colors = DEFAULT_THEME_COLORS
    return {
        'theme_colors': colors,
        'default_theme_colors': DEFAULT_THEME_COLORS,
    }


def is_secret_param(name: str) -> bool:
    return name in SECRET_PARAM_NAMES


def mask_workflow_secret_params(steps: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
    return mask_workflow_secret_params_service(
        steps,
        secret_param_names=SECRET_PARAM_NAMES,
        encoded_secret_prefix=ENCODED_SECRET_PREFIX,
        encode_keyholder_value=encode_keyholder_value,
    )


def unmask_secret_param_value(value: Any) -> Any:
    return unmask_secret_param_value_service(
        value,
        encoded_secret_prefix=ENCODED_SECRET_PREFIX,
        decode_keyholder_value=decode_keyholder_value,
    )


def mask_applied_params_for_ui(applied_params: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
    return mask_applied_params_for_ui_service(
        applied_params,
        secret_param_names=SECRET_PARAM_NAMES,
        secret_value_placeholder=SECRET_VALUE_PLACEHOLDER,
    )


def mask_command_for_ui(command: Optional[List[str]], applied_params: Optional[List[Dict[str, Any]]], script_meta: Dict[str, Any]) -> List[str]:
    return mask_command_for_ui_service(
        command,
        applied_params,
        script_meta,
        secret_param_names=SECRET_PARAM_NAMES,
        secret_value_placeholder=SECRET_VALUE_PLACEHOLDER,
    )


def build_masked_command_and_params(
    command: Optional[List[str]],
    applied_params: Optional[List[Dict[str, Any]]],
    script_meta: Dict[str, Any]
) -> Tuple[List[str], List[Dict[str, Any]]]:
    return build_masked_command_and_params_service(
        command,
        applied_params,
        script_meta,
        secret_param_names=SECRET_PARAM_NAMES,
        secret_value_placeholder=SECRET_VALUE_PLACEHOLDER,
    )


def resolve_workspace_path(path_value):
    if path_value is None:
        return None
    if os.path.isabs(path_value):
        return os.path.abspath(path_value)
    return os.path.abspath(os.path.join(app.root_path, path_value))


def is_subpath(child_path, parent_path):
    try:
        return os.path.commonpath([child_path, parent_path]) == os.path.commonpath([parent_path])
    except ValueError:
        return False


def sanitize_storage_relative_path(path_value: str, *, allow_empty: bool = False) -> str:
    return sanitize_storage_relative_path_service(path_value, secure_filename, allow_empty=allow_empty)


def get_tts_root_directory(config_snapshot: Dict[str, Any]) -> Optional[str]:
    return get_tts_root_directory_service(config_snapshot, resolve_workspace_path)


def safe_extract_tar(archive: tarfile.TarFile, destination: str) -> None:
    for member in archive.getmembers():
        member_name = member.name or ''
        if not member_name:
            continue
        member_path = os.path.abspath(os.path.join(destination, member_name))
        if not is_subpath(member_path, destination):
            raise ValueError('Az archívum érvénytelen elérési utakat tartalmaz.')
        if member.issym() or member.islnk():
            raise ValueError('Az archívum szimbolikus linkeket tartalmaz, ami nem támogatott.')
    archive.extractall(path=destination)


def safe_extract_zip(archive: zipfile.ZipFile, destination: str) -> None:
    for info in archive.infolist():
        member_name = info.filename or ''
        if not member_name:
            continue
        if info.create_system == 3:
            permissions = info.external_attr >> 16
            if stat.S_ISLNK(permissions):
                raise ValueError('Az archívum szimbolikus linkeket tartalmaz, ami nem támogatott.')
        member_path = os.path.abspath(os.path.join(destination, member_name))
        if not is_subpath(member_path, destination):
            raise ValueError('Az archívum érvénytelen elérési utakat tartalmaz.')
        if info.is_dir():
            os.makedirs(member_path, exist_ok=True)
            continue
        parent_dir = os.path.dirname(member_path)
        if parent_dir:
            os.makedirs(parent_dir, exist_ok=True)
        with archive.open(info, 'r') as source, open(member_path, 'wb') as target:
            shutil.copyfileobj(source, target)


def collect_directory_entries(
    root_path: str,
    target_path: str,
    metadata_directories: Optional[Set[str]] = None,
    highlight_map: Optional[Dict[str, str]] = None,
    failed_generation_directories: Optional[Set[str]] = None
) -> List[Dict[str, Any]]:
    return collect_directory_entries_service(
        root_path,
        target_path,
        metadata_directories=metadata_directories,
        highlight_map=highlight_map,
        failed_generation_directories=failed_generation_directories,
    )


def compute_failed_generation_highlights(
    project_dir: str,
    config_snapshot: Dict[str, Any]
) -> Dict[str, str]:
    return compute_failed_generation_highlights_service(project_dir, config_snapshot)


def should_enable_failed_move(rel_path: str, highlight_map: Dict[str, str]) -> bool:
    return should_enable_failed_move_service(rel_path, highlight_map)


FILENAME_RANGE_PATTERN = re.compile(
    r'^(\d{2}-\d{2}-\d{2}-\d{3})_(\d{2}-\d{2}-\d{2}-\d{3})'
)


def get_audio_metadata_directories(config_snapshot: Dict[str, Any]) -> Set[str]:
    return get_audio_metadata_directories_service(config_snapshot)


def should_collect_audio_metadata(rel_path: str, metadata_directories: Set[str]) -> bool:
    if not rel_path or not metadata_directories:
        return False
    normalized = rel_path.replace('\\', '/')
    segments = [segment for segment in normalized.split('/') if segment]
    if len(segments) <= 1:
        return False
    parent_segments = segments[:-1]
    return any(segment in metadata_directories for segment in parent_segments)


def parse_timestamp_to_seconds(value: str) -> Optional[float]:
    if not value:
        return None
    parts = value.split('-')
    if len(parts) != 4:
        return None
    try:
        hours, minutes, seconds, milliseconds = (int(part) for part in parts)
    except ValueError:
        return None
    total_seconds = (hours * 3600) + (minutes * 60) + seconds + (milliseconds / 1000.0)
    return max(total_seconds, 0.0)


def compute_duration_from_filename(filename: str) -> Optional[float]:
    if not filename:
        return None
    stem, _ = os.path.splitext(filename)
    match = FILENAME_RANGE_PATTERN.match(stem or '')
    if not match:
        return None
    start_seconds = parse_timestamp_to_seconds(match.group(1))
    end_seconds = parse_timestamp_to_seconds(match.group(2))
    if start_seconds is None or end_seconds is None:
        return None
    computed = end_seconds - start_seconds
    if computed < 0:
        return None
    return computed


def read_wav_duration_seconds(file_path: str) -> Optional[float]:
    try:
        with wave.open(file_path, 'rb') as wav_file:
            frame_rate = wav_file.getframerate()
            frame_count = wav_file.getnframes()
            if not frame_rate:
                return None
            duration = frame_count / float(frame_rate)
            if math.isfinite(duration) and duration >= 0:
                return duration
    except (wave.Error, OSError) as exc:
        logging.debug("Nem sikerült kiolvasni a wav időtartamot (%s): %s", file_path, exc)
    return None


def format_seconds_hundredths(value: Optional[float]) -> Optional[str]:
    if value is None:
        return None
    if not math.isfinite(value):
        return None
    rounded = round(max(value, 0) + 1e-9, 2)
    return f"{rounded:.2f}"


def build_audio_metadata(
    full_path: str,
    rel_path: str,
    metadata_directories: Set[str]
) -> Dict[str, Any]:
    return build_audio_metadata_service(full_path, rel_path, metadata_directories)


def get_failed_generation_directories(config_snapshot: Dict[str, Any]) -> Set[str]:
    return get_failed_generation_directories_service(config_snapshot)


def should_collect_failed_generation_text(rel_path: str, failed_directories: Set[str]) -> bool:
    if not rel_path or not failed_directories:
        return False
    normalized = rel_path.replace('\\', '/')
    segments = [segment for segment in normalized.split('/') if segment]
    if len(segments) <= 1:
        return False
    parent_segments = segments[:-1]
    return any(segment in failed_directories for segment in parent_segments)


def build_failed_generation_json_metadata(
    full_path: str,
    rel_path: str,
    failed_directories: Set[str]
) -> Dict[str, Any]:
    return build_failed_generation_json_metadata_service(full_path, rel_path, failed_directories)


def infer_autofill_kind(param_name: str) -> Optional[str]:
    return infer_autofill_kind_service(param_name, PROJECT_AUTOFILL_OVERRIDES)


def load_scripts_file() -> List[Dict[str, Any]]:
    entries = rebuild_scripts_config_file()
    return entries


def rebuild_scripts_config_file() -> List[Dict[str, Any]]:
    return rebuild_scripts_config_file_service(
        SCRIPTS_DIR,
        SCRIPTS_CONFIG_PATH,
        validate_script_meta,
    )


def prepare_script_entry(raw_entry: Dict[str, Any]) -> Optional[Dict[str, Any]]:
    return prepare_script_entry_service(
        raw_entry,
        scripts_dir=SCRIPTS_DIR,
        negative_flag_name_prefixes=NEGATIVE_FLAG_NAME_PREFIXES,
        secret_param_names=SECRET_PARAM_NAMES,
        script_key_requirements=SCRIPT_KEY_REQUIREMENTS,
        project_autofill_overrides=PROJECT_AUTOFILL_OVERRIDES,
    )


def get_scripts_catalog(force_reload: bool = False) -> List[Dict[str, Any]]:
    return get_scripts_catalog_service(
        force_reload=force_reload,
        scripts_config_path=SCRIPTS_CONFIG_PATH,
        scripts_cache=SCRIPTS_CACHE,
        scripts_cache_lock=SCRIPTS_CACHE_LOCK,
        load_scripts_file=load_scripts_file,
        prepare_script_entry_fn=prepare_script_entry,
    )


def initialize_scripts_catalog() -> None:
    try:
        rebuild_scripts_config_file()
    except Exception as exc:
        logging.error("Nem sikerült inicializálni a script katalógust: %s", exc)


def get_script_definition(script_id: str) -> Optional[Dict[str, Any]]:
    return get_script_definition_service(script_id, get_scripts_catalog)


def ensure_workflows_dir() -> Path:
    return ensure_workflows_dir_service(WORKFLOWS_DIR)


def sanitize_workflow_id(name: str) -> str:
    return sanitize_workflow_id_service(name, secure_filename)


def _load_workflow_file(path: Path) -> Optional[Dict[str, Any]]:
    return load_workflow_file_service(path, mask_workflow_secret_params)


def list_workflow_templates() -> List[Dict[str, Any]]:
    return list_workflow_templates_service(WORKFLOWS_DIR, mask_workflow_secret_params)


def load_workflow_template(template_id: str) -> Optional[Dict[str, Any]]:
    return load_workflow_template_service(WORKFLOWS_DIR, template_id, mask_workflow_secret_params)


def save_workflow_template_file(
    name: str,
    steps: List[Dict[str, Any]],
    template_id: Optional[str] = None,
    overwrite: bool = False,
    description: Optional[str] = None
) -> Dict[str, Any]:
    return save_workflow_template_file_service(
        WORKFLOWS_DIR,
        name,
        steps,
        mask_workflow_secret_params,
        secure_filename,
        WorkflowValidationError,
        template_id=template_id,
        overwrite=overwrite,
        description=description,
    )


def get_project_root_path(project_name: str, config_snapshot: Optional[Dict[str, Any]] = None) -> Optional[Path]:
    return get_project_root_path_service(project_name, get_config_copy, secure_filename, config_snapshot=config_snapshot)


def get_project_workflow_state_path(project_name: str, config_snapshot: Optional[Dict[str, Any]] = None) -> Optional[Path]:
    return get_project_workflow_state_path_service(
        project_name,
        WORKFLOW_STATE_FILENAME,
        get_config_copy,
        secure_filename,
        config_snapshot=config_snapshot,
    )


def load_project_workflow_state(project_name: str, config_snapshot: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
    return load_project_workflow_state_service(
        project_name,
        WORKFLOW_STATE_FILENAME,
        get_config_copy,
        secure_filename,
        mask_workflow_secret_params,
        config_snapshot=config_snapshot,
    )


def save_project_workflow_state(
    project_name: str,
    steps: List[Dict[str, Any]],
    template_id: Optional[str] = None,
    *,
    config_snapshot: Optional[Dict[str, Any]] = None,
    saved_at: Optional[str] = None
) -> Dict[str, Any]:
    return save_project_workflow_state_service(
        project_name,
        steps,
        mask_workflow_secret_params,
        WORKFLOW_STATE_FILENAME,
        get_config_copy,
        secure_filename,
        WorkflowValidationError,
        template_id=template_id,
        config_snapshot=config_snapshot,
        saved_at=saved_at,
    )


def coerce_bool(value: Any) -> bool:
    return coerce_bool_service(value)


def normalize_cycle_widget_params(raw_params: Dict[str, Any]) -> Dict[str, int]:
    if raw_params is None:
        params = {}
    elif isinstance(raw_params, dict):
        params = raw_params
    else:
        raise WorkflowValidationError("A ciklus widget paraméterei hibás formátumúak.")

    def parse_positive_int(value: Any, field_label: str) -> int:
        if value is None:
            candidate = ''
        else:
            candidate = str(value).strip()
        if candidate == '':
            candidate = '1'
        try:
            numeric = int(candidate)
        except (TypeError, ValueError):
            raise WorkflowValidationError(
                f"A ciklus widget {field_label} paramétere csak pozitív egész szám lehet."
            ) from None
        if numeric < 1:
            raise WorkflowValidationError(
                f"A ciklus widget {field_label} paramétere csak pozitív egész szám lehet."
            )
        return numeric

    repeat_count = parse_positive_int(params.get('repeat_count'), 'repeat_count')
    step_back = parse_positive_int(params.get('step_back'), 'step_back')

    return {
        'repeat_count': repeat_count,
        'step_back': step_back
    }


def normalize_translated_split_loop_widget_params(raw_params: Dict[str, Any]) -> Dict[str, int]:
    if raw_params is None:
        params = {}
    elif isinstance(raw_params, dict):
        params = raw_params
    else:
        raise WorkflowValidationError("A translated split loop widget paraméterei hibás formátumúak.")

    value = params.get('allowed_missing_segments')
    candidate = '' if value is None else str(value).strip()
    if candidate == '':
        candidate = '0'
    try:
        numeric = int(candidate)
    except (TypeError, ValueError):
        raise WorkflowValidationError(
            "A translated split loop widget allowed_missing_segments paramétere csak nemnegatív egész szám lehet."
        ) from None
    if numeric < 0:
        raise WorkflowValidationError(
            "A translated split loop widget allowed_missing_segments paramétere csak nemnegatív egész szám lehet."
        )

    return {
        'allowed_missing_segments': numeric
    }


def load_conda_info(force_refresh: bool = False) -> Optional[dict]:
    global CONDA_INFO_CACHE
    with CONDA_INFO_LOCK:
        if CONDA_INFO_CACHE is not None and not force_refresh:
            return CONDA_INFO_CACHE
        try:
            result = subprocess.run(
                ['conda', 'info', '--json'],
                capture_output=True,
                text=True,
                encoding='utf-8',
                check=True
            )
            info = json.loads(result.stdout)
            CONDA_INFO_CACHE = info
            return info
        except (subprocess.CalledProcessError, FileNotFoundError, json.JSONDecodeError) as exc:
            logging.error("Nem sikerült lekérdezni a Conda információkat: %s", exc)
            return None


def map_env_name_to_path(info: dict) -> Dict[str, str]:
    mapping: Dict[str, str] = {}
    if not info:
        return mapping
    envs = info.get('envs') or []
    root_prefix = info.get('root_prefix')
    if root_prefix:
        mapping['base'] = root_prefix
        mapping[os.path.basename(root_prefix)] = root_prefix
    for env_path in envs:
        if not env_path:
            continue
        env_name = os.path.basename(str(env_path).rstrip(os.sep))
        mapping[env_name] = env_path
    return mapping


def load_keyholder_data():
    if not os.path.exists(KEYHOLDER_PATH):
        return {}
    try:
        with open(KEYHOLDER_PATH, 'r', encoding='utf-8') as f:
            return json.load(f)
    except json.JSONDecodeError:
        logging.warning("Nem sikerült beolvasni a keyholder.json fájlt, feltételezzük, hogy üres.")
    except OSError as exc:
        logging.error(f"Nem olvasható a keyholder.json fájl: {exc}")
    return {}


def save_keyholder_data(data):
    try:
        with open(KEYHOLDER_PATH, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        return True
    except OSError as exc:
        logging.error(f"Nem sikerült menteni a keyholder.json fájlt: {exc}")
        return False


def decode_keyholder_value(value):
    if not value:
        return None
    value = value.strip()
    if not value:
        return None
    try:
        decoded = base64.b64decode(value.encode('utf-8')).decode('utf-8')
        return decoded.strip() or None
    except (binascii.Error, UnicodeDecodeError, AttributeError):
        return value


def encode_keyholder_value(value):
    if value is None:
        return None
    cleaned = value.strip()
    if not cleaned:
        return None
    return base64.b64encode(cleaned.encode('utf-8')).decode('utf-8')


def get_keyholder_value(data: Dict[str, Any], field_names: Tuple[str, ...]) -> Optional[str]:
    for field in field_names:
        if not field:
            continue
        value = decode_keyholder_value(data.get(field))
        if value:
            return value
    return None


def get_conda_python(env_name: str):
    cached = CONDA_PYTHON_CACHE.get(env_name)
    if cached:
        return cached
    if not env_name:
        return None
    info = load_conda_info()
    if not info:
        return None
    env_map = map_env_name_to_path(info)
    env_path = env_map.get(env_name)
    if not env_path:
        for envs_dir in info.get('envs_dirs', []):
            candidate = os.path.join(envs_dir, env_name)
            if os.path.isdir(candidate):
                env_path = candidate
                break
    if not env_path:
        logging.error("A(z) '%s' nevű Conda környezet nem található.", env_name)
        return None
    python_exec = os.path.join(env_path, 'python.exe') if os.name == 'nt' else os.path.join(env_path, 'bin', 'python')
    if os.path.exists(python_exec):
        CONDA_PYTHON_CACHE[env_name] = python_exec
        return python_exec
    logging.error("Nem található Python végrehajtható itt: %s", python_exec)
    return None


def ensure_project_structure(project_path: str, subdirs_config: Dict[str, str]) -> None:
    logging.info("Projekt könyvtár ellenőrzése: %s", project_path)
    os.makedirs(project_path, exist_ok=True)
    for subdir in subdirs_config.values():
        os.makedirs(os.path.join(project_path, subdir), exist_ok=True)


def setup_project_logging(project_path: str, logs_subdir: str, project_name: str) -> Tuple[logging.Handler, str]:
    log_dir = os.path.join(project_path, logs_subdir)
    os.makedirs(log_dir, exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    log_file = os.path.join(log_dir, f'{project_name}_run_{timestamp}.log')

    handler = logging.FileHandler(log_file, encoding='utf-8')
    handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
    logging.getLogger().addHandler(handler)
    logging.info("Log fájl létrehozva: %s", log_file)
    return handler, log_file


def remove_logging_handler(handler: logging.Handler) -> None:
    logger = logging.getLogger()
    try:
        logger.removeHandler(handler)
    except Exception:
        pass
    try:
        handler.close()
    except Exception:
        pass


def determine_parameter_value(
    param_meta: Dict[str, Any],
    user_params: Dict[str, Any],
    script_meta: Dict[str, Any],
    context: Dict[str, Any]
) -> Any:
    from services.workflow_execution import determine_parameter_value as determine_parameter_value_service
    return determine_parameter_value_service(
        param_meta,
        user_params,
        script_meta,
        context,
        script_param_keyholder=SCRIPT_PARAM_KEYHOLDER,
        get_keyholder_value=get_keyholder_value,
    )


def build_argument_fragment(param_meta: Dict[str, Any], value: Any) -> List[str]:
    param_type = param_meta['type']
    name = param_meta['name']
    flags = param_meta.get('flags') or []

    if param_type == 'flag':
        if not flags:
            return []

        flag_mode = param_meta.get('flag_mode', 'standard')
        positive_flag = next((flag for flag in flags if not flag.startswith('--no-')), None)
        negative_flag = next((flag for flag in flags if flag.startswith('--no-')), None)

        if flag_mode == 'negative_only_negative':
            if value is True and negative_flag:
                return [negative_flag]
            return []

        if flag_mode == 'negative_only_positive':
            if value is False and negative_flag:
                return [negative_flag]
            return []

        if value is True:
            return [positive_flag] if positive_flag else []
        if value is False:
            if negative_flag:
                return [negative_flag]
            return []
        return []

    if value is None:
        return []

    if param_type == 'positional':
        return [str(value)]

    if param_type == 'option':
        if flags:
            return [flags[0], str(value)]
        return [str(value)]

    if param_type == 'config_option':
        return [f"{name}={value}"]

    logging.warning("Ismeretlen paraméter típus: %s", param_type)
    return []


def build_command_for_step(
    step_config: Dict[str, Any],
    script_meta: Dict[str, Any],
    context: Dict[str, Any]
) -> Tuple[List[str], List[Dict[str, Any]]]:
    return build_command_for_step_service(
        step_config,
        script_meta,
        context,
        get_conda_python=get_conda_python,
        app_root_path=app.root_path,
        workflow_validation_error=WorkflowValidationError,
        script_param_keyholder=SCRIPT_PARAM_KEYHOLDER,
        get_keyholder_value=get_keyholder_value,
    )


def normalize_workflow_steps(payload: Any) -> Tuple[List[Dict[str, Any]], Set[str], int]:
    return normalize_workflow_steps_service(
        payload,
        workflow_validation_error=WorkflowValidationError,
        allowed_workflow_widgets=ALLOWED_WORKFLOW_WIDGETS,
        get_script_definition=get_script_definition,
        normalize_cycle_widget_params=normalize_cycle_widget_params,
        normalize_translated_split_loop_widget_params=normalize_translated_split_loop_widget_params,
        secret_param_names=SECRET_PARAM_NAMES,
        unmask_secret_param_value_fn=unmask_secret_param_value,
    )


def run_script_command(
    command_list: List[str],
    log_prefix: str = "",
    env: Optional[Dict[str, str]] = None,
    should_stop: Optional[Callable[[], bool]] = None
) -> Any:
    return run_script_command_service(
        command_list,
        log_prefix=log_prefix,
        env=env,
        should_stop=should_stop,
    )


def determine_workflow_key_status(required_keys: Optional[Set[str]] = None) -> Dict[str, Any]:
    keyholder_data = load_keyholder_data()
    required_keys = set(required_keys or [])

    key_definitions = {
        'chatgpt': {
            'label': 'OpenAI / ChatGPT API kulcs',
            'fields': ('chatgpt_api_key', 'api_key'),
        },
        'deepl': {
            'label': 'DeepL API kulcs',
            'fields': ('deepL_api_key', 'deepl_api_key'),
        },
        'huggingface': {
            'label': 'Hugging Face token',
            'fields': ('hf_token',),
        }
    }

    keys_status = {}
    for key_name, definition in key_definitions.items():
        present = bool(get_keyholder_value(keyholder_data, definition['fields']))
        keys_status[key_name] = {
            'label': definition['label'],
            'present': present,
            'required': key_name in required_keys
        }

    return {
        'keys': keys_status,
        'uses_chatgpt_translation': 'chatgpt' in required_keys
    }

# Statikus fájlok kiszolgálása a workdir mappából
@app.route('/workdir/<path:filename>')
def serve_workdir(filename):
    return send_from_directory('workdir', filename)

# Konfiguráció betöltése
with CONFIG_FILE_PATH.open('r', encoding='utf-8') as config_file:
    config = json.load(config_file)
CONFIG_MTIME = CONFIG_FILE_PATH.stat().st_mtime

def get_config_copy():
    global config, CONFIG_MTIME
    with config_lock:
        current_mtime = CONFIG_FILE_PATH.stat().st_mtime
        if CONFIG_MTIME is None or current_mtime != CONFIG_MTIME:
            with CONFIG_FILE_PATH.open('r', encoding='utf-8') as config_file:
                config = json.load(config_file)
            CONFIG_MTIME = current_mtime
        return copy.deepcopy(config)


def persist_config(updated_config):
    global config, CONFIG_MTIME
    with config_lock:
        config = updated_config
        with CONFIG_FILE_PATH.open('w', encoding='utf-8') as config_file:
            json.dump(config, config_file, indent=2, ensure_ascii=False)
        CONFIG_MTIME = CONFIG_FILE_PATH.stat().st_mtime


def _normalize_language_code(code: Optional[str]) -> Optional[str]:
    if not code:
        return None
    normalized = str(code).strip().lower()
    return normalized or None


def get_languages_root_directory() -> Path:
    directories = {}
    try:
        directories = config.get('DIRECTORIES') if isinstance(config, dict) else {}
    except NameError:
        directories = {}
    languages_rel_path = (directories or {}).get('languages', 'languages')
    return Path(app.root_path) / languages_rel_path


def list_language_directories() -> List[str]:
    languages_root = get_languages_root_directory()
    if not languages_root.is_dir():
        return []
    return sorted(
        entry.name
        for entry in languages_root.iterdir()
        if entry.is_dir()
    )


def load_language_payload(lang_code: Optional[str], file_name: str = 'index') -> Optional[Dict[str, Any]]:
    normalized_code = _normalize_language_code(lang_code)
    if not normalized_code:
        return None

    languages_root = get_languages_root_directory()
    lang_file = languages_root / normalized_code / f'{file_name}.json'
    if not lang_file.is_file():
        return None

    file_mtime = lang_file.stat().st_mtime
    cache_key = (normalized_code, file_name)
    with language_cache_lock:
        cached = language_cache.get(cache_key)
        if cached and cached.get('mtime') == file_mtime:
            return cached.get('data')

    try:
        with lang_file.open('r', encoding='utf-8') as handle:
            payload = json.load(handle)
    except (OSError, json.JSONDecodeError) as exc:
        logging.warning("Nem sikerült beolvasni a(z) %s nyelvi fájlt: %s", lang_file, exc)
        return None

    with language_cache_lock:
        language_cache[cache_key] = {
            'mtime': file_mtime,
            'data': payload
        }

    return payload


def get_language_strings(lang_code: Optional[str], file_name: str = 'index') -> Tuple[Dict[str, Any], Dict[str, Any]]:
    payload = load_language_payload(lang_code, file_name=file_name)
    if not isinstance(payload, dict):
        return {}, {}

    strings = payload.get('strings')
    if not isinstance(strings, dict):
        strings = {key: value for key, value in payload.items() if key != 'meta'}

    meta = payload.get('meta')
    if not isinstance(meta, dict):
        meta = {}

    return strings, meta


def list_language_options() -> List[Dict[str, str]]:
    options: List[Dict[str, str]] = []
    for code in list_language_directories():
        payload = load_language_payload(code, file_name='index')
        meta = payload.get('meta') if isinstance(payload, dict) else {}
        label = None
        if isinstance(meta, dict):
            label = meta.get('label') or meta.get('name') or meta.get('native_label')
        options.append({
            'code': code,
            'label': label or code.upper()
        })
    return options


def build_translation_helper(strings: Optional[Dict[str, Any]]):
    safe_strings = strings or {}

    def translate(key: str, default: Optional[str] = None, **kwargs):
        value: Any = safe_strings
        for part in key.split('.'):
            if isinstance(value, dict):
                value = value.get(part)
            else:
                value = None
                break

        if value is None:
            value = default if default is not None else key

        if isinstance(value, str) and kwargs:
            try:
                value = value.format(**kwargs)
            except KeyError:
                pass
        return value

    return translate


def resolve_language_context(preferred_code: Optional[str], file_name: str = 'index') -> Dict[str, Any]:
    available_codes = list_language_directories()
    normalized_preference = _normalize_language_code(preferred_code)
    requested_code = normalized_preference if normalized_preference in available_codes else None

    strings: Dict[str, Any] = {}
    meta: Dict[str, Any] = {}
    resolved_code: Optional[str] = None

    if requested_code:
        candidate_strings, candidate_meta = get_language_strings(requested_code, file_name=file_name)
        if candidate_strings:
            strings = candidate_strings
            meta = candidate_meta
            resolved_code = requested_code

    if not resolved_code:
        fallback_priority: List[str] = []
        if DEFAULT_UI_LANGUAGE in available_codes:
            fallback_priority.append(DEFAULT_UI_LANGUAGE)
        fallback_priority.extend(code for code in available_codes if code not in fallback_priority)
        if requested_code and requested_code not in fallback_priority:
            fallback_priority.append(requested_code)

        for candidate in fallback_priority:
            candidate_strings, candidate_meta = get_language_strings(candidate, file_name=file_name)
            if candidate_strings:
                strings = candidate_strings
                meta = candidate_meta
                resolved_code = candidate
                break

    if not strings:
        strings = {}
    if not meta:
        meta = {}
    if not resolved_code:
        resolved_code = requested_code or DEFAULT_UI_LANGUAGE

    return {
        'requested': requested_code,
        'resolved': resolved_code,
        'strings': strings,
        'meta': meta
    }


def render_with_language(template_name: str, *, file_name: str = 'index', **context):
    preferred_language = request.args.get('lang') or request.cookies.get(UI_LANGUAGE_COOKIE)
    language_context = resolve_language_context(preferred_language, file_name=file_name)
    translation_helper = build_translation_helper(language_context.get('strings'))
    language_options = list_language_options()

    active_language_code = (
        language_context.get('requested')
        or language_context.get('resolved')
        or DEFAULT_UI_LANGUAGE
    )
    resolved_language_code = language_context.get('resolved') or DEFAULT_UI_LANGUAGE
    language_meta = language_context.get('meta') or {}
    html_lang = language_meta.get('html_lang') or language_meta.get('code') or resolved_language_code

    context.update({
        'translations': language_context.get('strings') or {},
        'translate': translation_helper,
        'language_options': language_options,
        'active_language': active_language_code,
        'resolved_language': resolved_language_code,
        'language_meta': language_meta,
        'html_lang': html_lang
    })

    response = make_response(render_template(template_name, **context))
    cookie_value = request.cookies.get(UI_LANGUAGE_COOKIE)
    should_update_cookie = (
        active_language_code
        and active_language_code != cookie_value
        and (request.args.get('lang') or not cookie_value)
    )
    if should_update_cookie:
        response.set_cookie(
            UI_LANGUAGE_COOKIE,
            active_language_code,
            max_age=60 * 60 * 24 * 365,
            samesite='Lax'
        )
    return response

def update_workflow_job(job_id, **kwargs):
    update_workflow_job_service(
        job_id,
        workflow_lock,
        workflow_jobs,
        mask_workflow_secret_params,
        **kwargs,
    )


def get_workflow_job(job_id):
    return get_workflow_job_service(job_id, workflow_lock, workflow_jobs)


def get_project_jobs(project_name):
    return get_project_jobs_service(project_name, workflow_lock, workflow_jobs, secure_filename)


def register_workflow_job(job_id, job_data):
    register_workflow_job_service(
        job_id,
        job_data,
        workflow_lock,
        workflow_jobs,
        workflow_events,
        mask_workflow_secret_params,
    )


def set_workflow_thread(job_id, thread):
    set_workflow_thread_service(job_id, thread, workflow_lock, workflow_threads)


def get_workflow_thread(job_id):
    return get_workflow_thread_service(job_id, workflow_lock, workflow_threads)


def get_workflow_event(job_id):
    return get_workflow_event_service(job_id, workflow_lock, workflow_events)


def cleanup_workflow_resources(job_id):
    cleanup_workflow_resources_service(job_id, workflow_lock, workflow_threads, workflow_events)


def request_workflow_cancel(job_id):
    return request_workflow_cancel_service(job_id, workflow_lock, workflow_events)


def is_cancel_requested(job_id):
    event = get_workflow_event(job_id)
    return event.is_set() if event else False


def build_log_links(project_name, logs_subdir, log_filename):
    return build_log_links_service(project_name, logs_subdir, log_filename, secure_filename)


def read_log_tail(log_path, max_bytes=12000):
    return read_log_tail_service(log_path, max_bytes=max_bytes)


def run_workflow_job(job_id, project_name, workflow_payload):
    return run_workflow_job_service(
        job_id,
        project_name,
        workflow_payload,
        secure_filename=secure_filename,
        get_workflow_event_fn=get_workflow_event,
        update_workflow_job_fn=update_workflow_job,
        get_config_copy=get_config_copy,
        ensure_project_structure=ensure_project_structure,
        setup_project_logging=setup_project_logging,
        build_log_links_fn=build_log_links,
        mask_workflow_secret_params=mask_workflow_secret_params,
        load_keyholder_data=load_keyholder_data,
        get_script_definition=get_script_definition,
        build_command_for_step=build_command_for_step,
        build_masked_command_and_params=build_masked_command_and_params,
        run_script_command=run_script_command,
        workflow_validation_error=WorkflowValidationError,
        remove_logging_handler=remove_logging_handler,
        cleanup_workflow_resources_fn=cleanup_workflow_resources,
    )


register_app_routes(
    app,
    {
        'pages': {
            'workdir_path': 'workdir',
            'build_project_entries': build_project_entries,
            'render_with_language': render_with_language,
            'config': config,
            'secure_filename': secure_filename,
            'compute_failed_generation_highlights': compute_failed_generation_highlights,
            'get_audio_metadata_directories': get_audio_metadata_directories,
            'get_failed_generation_directories': get_failed_generation_directories,
            'should_enable_failed_move': should_enable_failed_move,
            'build_audio_metadata': build_audio_metadata,
            'build_failed_generation_json_metadata': build_failed_generation_json_metadata,
            'get_tts_root_directory': get_tts_root_directory,
            'audio_extensions': AUDIO_EXTENSIONS,
            'video_extensions': VIDEO_EXTENSIONS,
            'audio_mime_map': AUDIO_MIME_MAP,
            'video_mime_map': VIDEO_MIME_MAP,
            'secret_param_names': sorted(SECRET_PARAM_NAMES),
            'prepare_segments_for_response': prepare_segments_for_response,
            'get_review_encoded_audio_path': get_review_encoded_audio_path,
        },
        'review': {
            'config': config,
            'secure_filename': secure_filename,
            'resolve_source_audio_path': resolve_source_audio_path,
            'get_review_encoded_audio_path': get_review_encoded_audio_path,
            'review_audio_encoding_lock': review_audio_encoding_lock,
            'review_audio_encoding_jobs': review_audio_encoding_jobs,
            '_run_review_audio_encoding_job': _run_review_audio_encoding_job,
            'prepare_segments_for_response': prepare_segments_for_response,
            'delete_translated_split_file': delete_translated_split_file,
            'get_config_copy': get_config_copy,
            'sanitize_segment_strings': sanitize_segment_strings,
            'find_matching_audio_file': find_matching_audio_file,
            'get_project_workflow_state_path': get_project_workflow_state_path,
            'normalize_workflow_steps': normalize_workflow_steps,
            'WorkflowValidationError': WorkflowValidationError,
            'workflow_lock': workflow_lock,
            'workflow_jobs': workflow_jobs,
            'determine_workflow_key_status': determine_workflow_key_status,
            'mask_workflow_secret_params': mask_workflow_secret_params,
            'register_workflow_job': register_workflow_job,
            'run_workflow_job': run_workflow_job,
            'set_workflow_thread': set_workflow_thread,
        },
        'workflow': {
            'secure_filename': secure_filename,
            'get_config_copy': get_config_copy,
            'normalize_workflow_steps': normalize_workflow_steps,
            'WorkflowValidationError': WorkflowValidationError,
            'determine_workflow_key_status': determine_workflow_key_status,
            'list_workflow_templates': list_workflow_templates,
            'load_workflow_template': load_workflow_template,
            'coerce_bool': coerce_bool,
            'save_workflow_template_file': save_workflow_template_file,
            'get_scripts_catalog': get_scripts_catalog,
            'load_project_workflow_state': load_project_workflow_state,
            'get_project_workflow_state_path': get_project_workflow_state_path,
            'save_project_workflow_state': save_project_workflow_state,
            'mask_workflow_secret_params': mask_workflow_secret_params,
            'get_project_jobs': get_project_jobs,
            'get_project_root_path': get_project_root_path,
            'workflow_lock': workflow_lock,
            'workflow_jobs': workflow_jobs,
            'register_workflow_job': register_workflow_job,
            'run_workflow_job': run_workflow_job,
            'set_workflow_thread': set_workflow_thread,
            'get_workflow_job': get_workflow_job,
            'request_workflow_cancel': request_workflow_cancel,
            'update_workflow_job': update_workflow_job,
            'resolve_workspace_path': resolve_workspace_path,
            'read_log_tail': read_log_tail,
            'load_keyholder_data': load_keyholder_data,
            'encode_keyholder_value': encode_keyholder_value,
            'save_keyholder_data': save_keyholder_data,
        },
        'files': {
            'secure_filename': secure_filename,
            'get_config_copy': get_config_copy,
            'is_subpath': is_subpath,
            'get_project_jobs': get_project_jobs,
            'compute_failed_generation_highlights': compute_failed_generation_highlights,
            'get_audio_metadata_directories': get_audio_metadata_directories,
            'get_failed_generation_directories': get_failed_generation_directories,
            'collect_directory_entries': collect_directory_entries,
            'get_tts_root_directory': get_tts_root_directory,
            'sanitize_storage_relative_path': sanitize_storage_relative_path,
            'safe_extract_tar': safe_extract_tar,
            'safe_extract_zip': safe_extract_zip,
            'audio_extensions': AUDIO_EXTENSIONS,
        },
        'load_theme_colors': load_theme_colors,
        'save_theme_colors': save_theme_colors,
        'theme_color_keys': THEME_COLOR_KEYS,
        'secure_filename': secure_filename,
        'collect_translated_split_progress': collect_translated_split_progress,
        'get_config_copy': get_config_copy,
        'workflow_validation_error': WorkflowValidationError,
        'initialize_scripts_catalog': initialize_scripts_catalog,
        'logger': logging.getLogger(__name__),
    },
)


if __name__ == '__main__':
    import logging
    import os

    debug_flag = os.environ.get('FLASK_DEBUG', '')
    debug_enabled = debug_flag.lower() in {'1', 'true', 'yes', 'on'}

    if not debug_enabled:
        logging.getLogger('werkzeug').setLevel(logging.WARNING)

    app.run(debug=debug_enabled, host='0.0.0.0')