Update app.py

app.py

@@ -1,783 +1,948 @@
+"""Gradio UI wired to hexagonal architecture services."""
 from __future__ import annotations
+
+import datetime as _dt
 import os
+import tempfile
+from typing import Optional, List, Tuple
 import json
-import datetime as _dt
-from typing import List, Tuple, Optional
-import time
 
-import requests
-import pandas as pd
-import numpy as np
 import gradio as gr
+import pandas as pd
 
+# --- Пачатак блока, які можа патрабаваць ўстаноўкі залежнасцяў ---
 try:
-    # New Google Gemini client library
-    from google import genai  # type: ignore
-    _HAS_GENAI = True
-except Exception:
-    genai = None
-    _HAS_GENAI = False
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Config
-# ─────────────────────────────────────────────────────────────────────────────
-BASE_URL  = os.environ.get("VOCHI_BASE_URL", "https://crm.vochi.by/api")
-CLIENT_ID = os.environ.get("VOCHI_CLIENT_ID") 
-
-# If your API needs auth, fill it here (or via VOCHI_BEARER in Secrets)
-_AUTH_TOKEN = os.environ.get("VOCHI_BEARER", "").strip()
-AUTH_HEADERS = {
-    "Accept": "audio/*,application/json;q=0.9,*/*;q=0.8",
-    **({"Authorization": f"Bearer {_AUTH_TOKEN}"} if _AUTH_TOKEN else {}),
-}
-
-# 🔒 UI password from Space Secrets (set VOCHI_UI_PASSWORD there)
-_UI_PASSWORD = os.environ.get("VOCHI_UI_PASSWORD", "")
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Vochi API helpers
-# ─────────────────────────────────────────────────────────────────────────────
-def fetch_calllogs(date_str: str):
-    """Get list of calls for a given date (YYYY-MM-DD)."""
-    r = requests.get(
-        f"{BASE_URL}/calllogs",
-        params={"start": date_str, "end": date_str, "clientId": CLIENT_ID},
-        headers=AUTH_HEADERS,
-        timeout=60,
+    from calls_analyser.adapters.ai.gemini import GeminiAIAdapter
+    from calls_analyser.adapters.secrets.env import EnvSecretsAdapter
+    from calls_analyser.adapters.storage.local import LocalStorageAdapter
+    from calls_analyser.adapters.telephony.vochi import VochiTelephonyAdapter
+    from calls_analyser.domain.exceptions import CallsAnalyserError
+    from calls_analyser.domain.models import Language
+    from calls_analyser.ports.ai import AIModelPort
+    from calls_analyser.services.analysis import AnalysisOptions, AnalysisService
+    from calls_analyser.services.call_log import CallLogService
+    from calls_analyser.services.prompt import PromptService
+    from calls_analyser.services.registry import ProviderRegistry
+    from calls_analyser.services.tenant import TenantService
+    from calls_analyser.config import (
+        PROMPTS as CFG_PROMPTS,
+        MODEL_CANDIDATES as CFG_MODEL_CANDIDATES,
+        BATCH_MODEL_KEY as CFG_BATCH_MODEL_KEY,
+        BATCH_PROMPT_KEY as CFG_BATCH_PROMPT_KEY,
+        BATCH_PROMPT_TEXT as CFG_BATCH_PROMPT_TEXT,
+        BATCH_LANGUAGE_CODE as CFG_BATCH_LANGUAGE_CODE,
     )
-    r.raise_for_status()
-    data = r.json()
-    if isinstance(data, dict):
-        return data.get("data", data)
-    return data
-
-
-def fetch_mp3_by_unique_id(unique_id: str) -> Tuple[str, str]:
-    """Fetch call recording by UniqueId and save to /tmp. Returns (filepath, url)."""
-    url = f"{BASE_URL}/calllogs/{CLIENT_ID}/{unique_id}"
-    r = requests.get(url, headers=AUTH_HEADERS, timeout=120)
-    r.raise_for_status()
-    path = f"/tmp/call_{unique_id}.mp3"
-    with open(path, "wb") as f:
-        f.write(r.content)
-    return path, url
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Prompt templates & model options
-# ─────────────────────────────────────────────────────────────────────────────
-PROMPT_TEMPLATES = {
-    "simple": (
-        """
-You are a call-center conversation analyst for a medical clinic. From the call recording, provide a brief summary:
-- Purpose of the call (appointment / results / complaint / billing / other).
-- Patient intent and expectations.
-- Outcome (booked / call-back / routed / unresolved).
-- Next steps (owner and when).
-- Patient emotion (1–5) and agent tone (1–5).
-- Alerts: urgency/risks/privacy.
-
-Keep it short (6–8 lines). End with a line: ‘Service quality rating: X/5’ and one sentence explaining the rating.
-"""
-    ),
-    "medium": (
-        """
-Act as a senior service analyst. Analyze the call using this structure:
-1) Quick overview: reason for the call, intent, key facts, urgency (low/medium/high).
-2) Call flow (2–4 bullets): what was asked/answered, where friction occurred.
-3) Outcomes & tasks: concrete next actions for clinic/patient with timeframes.
-4) Emotions & empathy: patient mood; agent empathy (0–5).
-5) Procedural compliance: identity verification, disclosure of recording (if stated), no off-protocol medical advice, data accuracy.
-6) Quality rating (0–100) using rubric: greeting, verification, accuracy, empathy, issue resolution (each 0–20).
-"""
-    ),
-    "detailed": (
-        """
-You are a quality & operations analyst. Provide an in-depth analysis:
-A) Segmentation: split the call into stages with approximate timestamps (if available) and roles (Patient/Agent).
-B) Structured data for booking: full name (if stated), date of birth, phone, symptoms/complaints (list), onset/duration, possible pain level 0–10 (if mentioned), required specialist/service, preferred time windows, constraints.
-C) Triage & risks: class (routine/urgent/emergency), red flags, whether immediate escalation is needed.
-D) Compliance audit: identity/privacy checks, recording disclosure, consent to data processing, booking policies.
-E) Conversation metrics: talk ratio (agent/patient), interruptions, long pauses, notable keywords.
-F) Coaching for the agent: 3–5 concrete improvements with sample phrasing.
-
-Deliver: (1) A short patient-chart summary (2–3 sentences). (2) A task table with columns: priority, owner, due.
-"""
-    ),
-}
-
-TPL_OPTIONS = [
-    ("Simple", "simple"),
-    ("Medium", "medium"),
-    ("Detailed", "detailed"),
-    ("Custom", "custom"),
-]
+    PROJECT_IMPORTS_AVAILABLE = True
+except ImportError:
+    PROJECT_IMPORTS_AVAILABLE = False
 
-LANG_OPTIONS = [
-    ("Russian", "ru"),
-    ("Auto", "default"),
-    ("Belarusian", "be"),
-    ("English", "en"),
-]
+    class CallsAnalyserError(Exception):
+        pass
 
-MODEL_OPTIONS = [
-    ("flash", "models/gemini-2.5-flash"),
-    ("pro", "models/gemini-2.5-pro"),
-    ("flash-lite", "models/gemini-2.5-flash-lite"),
-]
+    class Language:
+        RUSSIAN = "ru"
+        BELARUSIAN = "be"
+        ENGLISH = "en"
+        AUTO = "auto"
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Utilities
-# ─────────────────────────────────────────────────────────────────────────────
+    CFG_PROMPTS = {}
+    CFG_MODEL_CANDIDATES = []
+    CFG_BATCH_MODEL_KEY = ""
+    CFG_BATCH_PROMPT_KEY = ""
+    CFG_BATCH_PROMPT_TEXT = ""
+    CFG_BATCH_LANGUAGE_CODE = "auto"
+# --- Канец блока ---
 
-def label_row(row: dict) -> str:
-    start = row.get("Start", "")
-    src   = row.get("CallerId", "")
-    dst   = row.get("Destination", "")
-    dur   = row.get("Duration", "")
-    return f"{start} | {src} → {dst} ({dur}s)"
 
+PROMPTS = CFG_PROMPTS if PROJECT_IMPORTS_AVAILABLE else {}
 
-def _resolve_model(client: "genai.Client", preferred: str) -> str:
-    name = preferred if preferred.startswith("models/") else f"models/{preferred}"
-    try:
-        models = list(client.models.list())
-        desired_short = name.split("/", 1)[1]
-        for m in models:
-            mname = getattr(m, "name", "")
-            short = mname.split("/", 1)[1] if mname.startswith("models/") else mname
-            methods = set(getattr(m, "supported_generation_methods", []) or [])
-            if short == desired_short and ("generateContent" in methods or not methods):
-                return f"models/{short}"
-        # Fallback to first available
-        for title, candidate in MODEL_OPTIONS:
+TPL_OPTIONS = [(tpl.title, tpl.key) for tpl in PROMPTS.values()] + [("Custom", "custom")]
+LANG_OPTIONS = [
+    ("Russian", Language.RUSSIAN),
+    ("Auto", Language.AUTO),
+    ("Belarusian", Language.BELARUSIAN),
+    ("English", Language.ENGLISH),
+]
+CALL_TYPE_OPTIONS = [
+    ("All types", ""),
+    ("Inbound", "0"),
+    ("Outbound", "1"),
+    ("Internal", "2"),
+]
+MODEL_CANDIDATES = CFG_MODEL_CANDIDATES if PROJECT_IMPORTS_AVAILABLE else []
+
+
+# ----------------------------------------------------------------------------
+# Dependency wiring
+# ----------------------------------------------------------------------------
+DEFAULT_TENANT_ID = os.environ.get("DEFAULT_TENANT_ID", "default")
+DEFAULT_BASE_URL = os.environ.get("VOCHI_BASE_URL", "https://crm.vochi.by/api")
+
+if not PROJECT_IMPORTS_AVAILABLE:
+    # заглушкі
+    class MockAdapter:
+        def get_optional_secret(self, _):
+            return os.environ.get("GOOGLE_API_KEY")
+
+    secrets_adapter = MockAdapter()
+    storage_adapter = None
+    prompt_service = None
+    ai_registry = {}
+    tenant_service = None
+    call_log_service = None
+    analysis_service = None
+else:
+    secrets_adapter = EnvSecretsAdapter()
+    storage_adapter = LocalStorageAdapter()
+    prompt_service = PromptService(PROMPTS)
+    ai_registry: ProviderRegistry[AIModelPort] = ProviderRegistry()
+
+    def _register_gemini_models() -> None:
+        api_key = secrets_adapter.get_optional_secret("GOOGLE_API_KEY")
+        if not api_key:
+            return
+        for _title, model in MODEL_CANDIDATES:
             try:
-                short = candidate.split("/", 1)[1]
-                for m in models:
-                    mname = getattr(m, "name", "")
-                    sm = mname.split("/", 1)[1] if mname.startswith("models/") else mname
-                    methods = set(getattr(m, "supported_generation_methods", []) or [])
-                    if sm == short and ("generateContent" in methods or not methods):
-                        return candidate
-            except Exception:
-                pass
-    except Exception:
-        pass
-    return name
+                ai_registry.register(model, GeminiAIAdapter(api_key=api_key, model=model))
+            except CallsAnalyserError:
+                continue
 
+    _register_gemini_models()
 
-def _system_instruction(lang_code: str) -> str:
-    if lang_code == "be":
-        return "Reply in Belarusian."
-    if lang_code == "ru":
-        return "Reply in Russian."
-    if lang_code == "en":
-        return "Reply in English."
-    return "Reply in the caller's language; if unclear, use concise professional English."
+    def _build_tenant_service() -> TenantService:
+        return TenantService(
+            secrets_adapter,
+            default_tenant=DEFAULT_TENANT_ID,
+            default_base_url=DEFAULT_BASE_URL,
+        )
 
+    def _build_call_log_service(tenant_service: TenantService) -> CallLogService:
+        config = tenant_service.resolve()
+        telephony_adapter = VochiTelephonyAdapter(
+            base_url=config.vochi_base_url,
+            client_id=config.vochi_client_id,
+            bearer_token=config.bearer_token,
+        )
+        return CallLogService(telephony_adapter, storage_adapter)
 
-def _prepare_prompt(template_key: str, custom_prompt: str) -> str:
-    if template_key == "custom":
-        return (custom_prompt or "").strip() or PROMPT_TEMPLATES["simple"]
-    return PROMPT_TEMPLATES.get(template_key, PROMPT_TEMPLATES["simple"])
+    tenant_service = _build_tenant_service()
+    call_log_service = _build_call_log_service(tenant_service)
+    analysis_service = AnalysisService(call_log_service, ai_registry, prompt_service)
 
 
-def _today_str():
-    return _dt.date.today().strftime("%Y-%m-%d")
+def _build_model_options() -> list[tuple[str, str]]:
+    """Збіраем опцыі мадэлі для выпадаючага спісу."""
+    if not PROJECT_IMPORTS_AVAILABLE:
+        return []
+    options: list[tuple[str, str]] = []
+    for title, model_key in MODEL_CANDIDATES:
+        if model_key not in ai_registry:
+            continue
+        provider = ai_registry.get(model_key)
+        provider_label = getattr(provider, "provider_name", model_key)
+        options.append((f"{provider_label} • {title}", model_key))
+    return options
+
+
+MODEL_OPTIONS = _build_model_options()
+MODEL_PLACEHOLDER_CHOICE = ("Configure GOOGLE_API_KEY to enable Gemini models", "")
+MODEL_CHOICES = MODEL_OPTIONS or [MODEL_PLACEHOLDER_CHOICE]
+MODEL_DEFAULT = MODEL_OPTIONS[0][1] if MODEL_OPTIONS else MODEL_PLACEHOLDER_CHOICE[1]
+MODEL_INFO = (
+    "Select an AI model for call analysis"
+    if MODEL_OPTIONS
+    else "Add GOOGLE_API_KEY to secrets and reload to enable models"
+)
+
+BATCH_PROMPT_KEY = CFG_BATCH_PROMPT_KEY
+BATCH_PROMPT_TEXT = (CFG_BATCH_PROMPT_TEXT or "").strip()
+BATCH_MODEL_KEY = CFG_BATCH_MODEL_KEY or MODEL_DEFAULT or ""
+BATCH_LANGUAGE_CODE = CFG_BATCH_LANGUAGE_CODE
+try:
+    BATCH_LANGUAGE = Language(BATCH_LANGUAGE_CODE)
+except ValueError:
+    BATCH_LANGUAGE = Language.AUTO
+
 
-# Time helpers (HH:MM → seconds since midnight)
-_DEF_T_FROM = "00:00"
-_DEF_T_TO   = "23:59"
+# ----------------------------------------------------------------------------
+# UI utilities
+# ----------------------------------------------------------------------------
+def _label_row(row: dict) -> str:
+    start = row.get("Start", "")
+    src = row.get("CallerId", "")
+    dst = row.get("Destination", "")
+    dur = row.get("Duration", "")
+    return f"{start} | {src} → {dst} ({dur}s)"
 
 
-def _parse_hhmm(s: Optional[str]) -> Optional[int]:
-    s = (s or "").strip()
-    if not s:
+def _parse_day(day_value) -> _dt.date:
+    if isinstance(day_value, _dt.datetime):
+        return day_value.date()
+    if isinstance(day_value, _dt.date):
+        return day_value
+    if not day_value:
+        raise ValueError("Date not specified.")
+    try:
+        timestamp = float(str(day_value).strip())
+        if timestamp > 1e9:
+            return _dt.datetime.fromtimestamp(timestamp, tz=_dt.timezone.utc).date()
+    except (ValueError, TypeError):
+        pass
+    try:
+        return _dt.date.fromisoformat(str(day_value).strip())
+    except ValueError as exc:
+        raise ValueError(f"Invalid date format: {day_value}") from exc
+
+
+def _parse_time_value(time_value) -> Optional[_dt.time]:
+    if time_value in (None, ""):
         return None
+    if isinstance(time_value, _dt.datetime):
+        return time_value.time().replace(microsecond=0)
+    if isinstance(time_value, _dt.time):
+        return time_value.replace(microsecond=0)
     try:
-        hh, mm = s.split(":", 1)
-        hh = int(hh)
-        mm = int(mm)
-        if not (0 <= hh <= 23 and 0 <= mm <= 59):
-            return None
-        return hh * 3600 + mm * 60
-    except Exception:
+        timestamp = float(str(time_value).strip())
+        if timestamp > 1e9:
+            return (
+                _dt.datetime.fromtimestamp(timestamp, tz=_dt.timezone.utc)
+                .time()
+                .replace(microsecond=0)
+            )
+    except (ValueError, TypeError):
+        pass
+    value = str(time_value).strip()
+    if not value:
         return None
+    try:
+        if value.count(":") == 1 and len(value.split(":")[0]) == 1:
+            value = f"0{value}"
+        parsed = _dt.time.fromisoformat(value)
+    except ValueError as exc:
+        if len(value) == 5 and value.count(":") == 1:
+            parsed = _dt.time.fromisoformat(f"{value}:00")
+        else:
+            raise ValueError(f"Invalid time format: {value}") from exc
+    return parsed.replace(microsecond=0)
 
 
-def _infer_calltype_col(df: pd.DataFrame) -> Optional[str]:
-    for c in df.columns:
-        low = str(c).lower()
-        if low in {"calltype", "call_type", "type"}:
-            return c
-    return None
+def _validate_time_range(time_from: Optional[_dt.time], time_to: Optional[_dt.time]) -> None:
+    if time_from and time_to and time_from > time_to:
+        raise ValueError("Time 'from' must be less than or equal to time 'to'.")
 
 
-def _normalize_start_to_time(df: pd.DataFrame) -> pd.DataFrame:
-    if "Start" not in df.columns:
-        return df
-    out = df.copy()
+def _resolve_call_type(value: object) -> Optional[int]:
+    s = str(value).strip()
+    if s == "":
+        return None
     try:
-        out["_Start_dt"] = pd.to_datetime(out["Start"], errors="coerce")
-        out["_Start_time_sec"] = out["_Start_dt"].dt.hour.fillna(0).astype(int) * 3600 + \
-                                   out["_Start_dt"].dt.minute.fillna(0).astype(int) * 60 + \
-                                   out["_Start_dt"].dt.second.fillna(0).astype(int)
-    except Exception:
-        out["_Start_time_sec"] = np.nan
-    return out
+        return int(s)
+    except ValueError:
+        pass
+    label_to_value = {label: v for (label, v) in CALL_TYPE_OPTIONS}
+    mapped = label_to_value.get(s, "")
+    try:
+        return int(mapped) if mapped != "" else None
+    except ValueError:
+        return None
 
 
-def _filter_calls(df: pd.DataFrame, t_from: Optional[str], t_to: Optional[str], calltype: Optional[str]) -> pd.DataFrame:
-    if df is None or df.empty:
-        return df
+def _build_dropdown(df: pd.DataFrame):
+    opts = [(_label_row(row), idx) for idx, row in df.iterrows()]
+    value = opts[0][1] if opts else None
+    return gr.update(choices=[(label, idx) for label, idx in opts], value=value)
 
-    tf = _parse_hhmm(t_from) or _parse_hhmm(_DEF_T_FROM) or 0
-    tt = _parse_hhmm(t_to) or _parse_hhmm(_DEF_T_TO) or (24*3600-1)
-    if tt < tf:
-        # Swap if user inverted
-        tf, tt = tt, tf
 
-    work = _normalize_start_to_time(df)
-    mask_time = (work["_Start_time_sec"].fillna(-1).astype(int) >= tf) & (work["_Start_time_sec"].fillna(-1).astype(int) <= tt)
+def _build_batch_dropdown(df: pd.DataFrame):
+    if df is None or df.empty:
+        return gr.update(choices=[], value=None)
+    opts: List[Tuple[str, str]] = []
+    for _idx, row in df.iterrows():
+        label = (
+            f"{row.get('Start','')} | {row.get('Caller','')} -> "
+            f"{row.get('Destination','')} ({row.get('Duration (s)','')}s)"
+        )
+        uid = str(row.get("UniqueId", ""))
+        if uid:
+            opts.append((label, uid))
+    value = opts[0][1] if opts else None
+    return gr.update(choices=opts, value=value)
 
-    mask = mask_time
 
-    ct = (calltype or "").strip()
-    if ct:
-        col = _infer_calltype_col(work)
-        if col:
-            # exact match (case-insensitive)
-            mask = mask & (work[col].astype(str).str.lower() == ct.lower())
+# ----------------------------------------------------------------------------
+# Gradio handlers
+# ----------------------------------------------------------------------------
+def ui_filter_calls(
+    date_value,
+    time_from_value,
+    time_to_value,
+    call_type_value,
+    authed,
+    tenant_id,
+):
+    """Фільтруе званкі і вяртае табліцу."""
+    if not authed:
+        return (
+            gr.update(value=pd.DataFrame(), visible=False),
+            gr.update(visible=False),
+            gr.update(choices=[], value=None),
+            "🔐 Enter the password to apply the filter.",
+            gr.update(visible=True),
+        )
+
+    if not PROJECT_IMPORTS_AVAILABLE:
+        return (
+            pd.DataFrame(),
+            gr.update(visible=False),
+            [],
+            "Project dependencies are not loaded.",
+            gr.update(visible=False),
+        )
 
-    return work.loc[mask].drop(columns=[c for c in ["_Start_dt", "_Start_time_sec"] if c in work.columns])
+    try:
+        day = _parse_day(date_value)
+        time_from = _parse_time_value(time_from_value)
+        time_to = _parse_time_value(time_to_value)
+        _validate_time_range(time_from, time_to)
+        call_type = _resolve_call_type(call_type_value)
+
+        tenant = tenant_service.resolve(tenant_id or None)
+        entries = call_log_service.list_calls(
+            day,
+            tenant,
+            time_from=time_from,
+            time_to=time_to,
+            call_type=call_type,
+        )
+        df = pd.DataFrame([entry.raw for entry in entries])
+        dd = _build_dropdown(df)
+        msg = f"Calls found: {len(df)}"
 
+        return (
+            gr.update(value=df, visible=True),
+            gr.update(visible=False),
+            dd,
+            msg,
+            gr.update(visible=False),
+        )
+    except Exception as exc:
+        return (
+            gr.update(value=pd.DataFrame(), visible=True),
+            gr.update(visible=False),
+            gr.update(choices=[], value=None),
+            f"Load error: {exc}",
+            gr.update(visible=False),
+        )
 
-def _validate_times(t_from: str, t_to: str) -> Tuple[bool, str, bool, bool]:
-    """Return (ok, message_html, from_valid, to_valid)."""
-    tf = _parse_hhmm(t_from)
-    tt = _parse_hhmm(t_to)
-    if tf is None and tt is None:
-        return False, "<span style='color:#c00'>❌ Памылка: няправільны фармат часу ў абодвух палях (выкарыстайце HH:MM).</span>", False, False
-    if tf is None:
-        return False, "<span style='color:#c00'>❌ Памылка: поле <b>Time from</b> павінна быць у фармаце HH:MM.</span>", False, True
-    if tt is None:
-        return False, "<span style='color:#c00'>❌ Памылка: поле <b>Time to</b> павінна быць у фармаце HH:MM.</span>", True, False
-    return True, "", True, True
 
+def ui_play_audio(selected_idx, df, tenant_id):
+    """Прайграць аўдыё па выбраным радку.
 
-def _recording_url(unique_id: str) -> str:
-    return f"{BASE_URL}/calllogs/{CLIENT_ID}/{unique_id}"
+    Лагіка:
+    - калі selected_idx выглядае як UID (не лічба) -> гуляем яго;
+    - калі гэта індэкс радка -> шукаем у df і бярэм UniqueId.
+    """
+    if not PROJECT_IMPORTS_AVAILABLE:
+        return "Project dependencies are not loaded.", None, ""
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Gradio handlers
-# ─────────────────────────────────────────────────────────────────────────────
+    unique_id = None
 
-def ui_fetch_calls(date_str: str):
-    try:
-        items = fetch_calllogs(date_str.strip())
-        df = pd.DataFrame(items)
-        opts = [(label_row(r), i) for i, r in df.iterrows()]
-        msg = f"Calls found: {len(df)}"
-        # Update dropdown choices and default value
-        dd = gr.update(choices=[(lbl, idx) for lbl, idx in opts], value=(opts[0][1] if opts else None))
-        return df, dd, msg
-    except requests.HTTPError as e:
-        body = ""
+    if selected_idx is not None:
         try:
-            body = e.response.text[:800]
-        except Exception:
-            pass
-        # CORRECTED LINE: Use triple quotes for multi-line f-string
-        return pd.DataFrame(), gr.update(choices=[], value=None), f"""HTTP error: {e}
-{body}"""
-    except Exception as e:
-        return pd.DataFrame(), gr.update(choices=[], value=None), f"Load error: {e}"
-
-
-def ui_play_audio(selected_idx: Optional[int], df: pd.DataFrame):
-    if selected_idx is None or df is None or df.empty:
-        return "<em>First fetch the list and select a row.</em>", None, None, ""
-    try:
-        row = df.iloc[int(selected_idx)]
-    except Exception:
-        return "<em>Invalid row selection.</em>", None, None, ""
-    unique_id = str(row.get("UniqueId"))
+            # калі дропдаўн ужо захоўвае UID на��рамую
+            if not str(selected_idx).isdigit():
+                unique_id = str(selected_idx)
+            elif df is not None and not df.empty:
+                row = df.iloc[int(selected_idx)]
+                unique_id = str(row.get("UniqueId"))
+        except (ValueError, IndexError):
+            return "<em>Invalid selection.</em>", None, ""
+
+    if not unique_id:
+        return "<em>Select a call to play.</em>", None, ""
+
     try:
-        fpath = f"/tmp/call_{unique_id}.mp3"
-        url_used = _recording_url(unique_id)
-        # Download only if not exists (avoid re-fetch)
-        if not os.path.exists(fpath) or os.path.getsize(fpath) == 0:
-            fpath, url_used = fetch_mp3_by_unique_id(unique_id)
-        html = f'<a href="{url_used}" target="_blank">Recording URL</a>'
-        return html, fpath, fpath, "Ready ✅"
-    except requests.HTTPError as e:
-        body = ""
-        try:
-            body = e.response.text[:800]
-        except Exception:
-            pass
-        return f"HTTP error: {e}<br><pre>{body}</pre>", None, None, ""
-    except Exception as e:
-        return f"Playback failed: {e}", None, None, ""
+        tenant = tenant_service.resolve(tenant_id or None)
+        handle = call_log_service.ensure_recording(unique_id, tenant)
 
+        listen_url = (
+            f"{tenant.vochi_base_url.rstrip('/')}/calllogs/"
+            f"{tenant.vochi_client_id}/{unique_id}"
+        )
+        html = f'URL: <a href="{listen_url}" target="_blank">{listen_url}</a>'
 
-def ui_toggle_custom_prompt(template_key: str):
-    return gr.update(visible=(template_key == "custom"))
+        return html, handle.local_uri, "Ready ✅"
+    except Exception as exc:
+        return f"Playback failed: {exc}", None, ""
 
 
-def ui_analyze(selected_idx: Optional[int], df: pd.DataFrame,
-               template_key: str, custom_prompt: str, lang_code: str, model_pref: str):
-    if df is None or df.empty or selected_idx is None:
-        return "First fetch the list, choose a call, and (optionally) click ‘🎧 Play’."
-    if not _HAS_GENAI:
-        return "❌ google-genai library not found. Make sure it's in requirements.txt."
+def ui_toggle_custom_prompt(template_key):
+    """Паказаць/схаваць поле Custom prompt."""
+    return gr.update(visible=(template_key == "custom"))
 
-    try:
-        row = df.iloc[int(selected_idx)]
-    except Exception:
-        return "Invalid row selection."
 
-    unique_id = str(row.get("UniqueId"))
-    mp3_path = f"/tmp/call_{unique_id}.mp3"
+def ui_mass_analyze(
+    date_value,
+    time_from_value,
+    time_to_value,
+    call_type_value,
+    tenant_id,
+    authed,
+):
+    """
+    Масавы аналіз (STREAMING).
+    Гэта генератар (yield), Gradio будзе адлюстроўваць вынікі паступова.
+    Паведамленні прагрэс-статусу і выніковае паведамленне ідуць буйным шрыфтам (Markdown ## / ###).
+    """
 
-    # Ensure audio file exists (download if needed)
-    try:
-        if not os.path.exists(mp3_path) or os.path.getsize(mp3_path) == 0:
-            mp3_path, _ = fetch_mp3_by_unique_id(unique_id)
-    except Exception as e:
-        return f"Failed to obtain audio for analysis: {e}"
+    empty_df = pd.DataFrame()
+    hidden_df_update = gr.update(value=empty_df, visible=False)
+    hidden_file = gr.update(value=None, visible=False)
 
-    api_key = os.environ.get("GOOGLE_API_KEY", "").strip()
-    if not api_key:
-        return "GOOGLE_API_KEY is not set in Space Secrets. Add it in Settings → Secrets and restart the Space."
+    def h3(txt: str) -> str:
+        # сярэдні буйны шрыфт
+        return f"### {txt}"
 
-    try:
-        client = genai.Client(api_key=api_key)
-    except Exception as e:
-        return f"Failed to initialize the client: {e}"
+    def h2_success(txt: str) -> str:
+        # вялікі тэкст для фінальнага выніку
+        return f"## {txt}"
 
-    # Upload file
-    try:
-        uploaded_file = client.files.upload(file=mp3_path)
-    except Exception as e:
-        return f"File upload error: {e}"
+    def h2_error(txt: str) -> str:
+        return f"## {txt}"
 
-    # Prepare prompt
-    if template_key == "custom":
-        prompt = (custom_prompt or "").strip() or PROMPT_TEMPLATES["simple"]
-    else:
-        prompt = PROMPT_TEMPLATES.get(template_key, PROMPT_TEMPLATES["simple"])
+    # 1) праверкі доступу і канфіга
+    if not authed:
+        yield (
+            hidden_df_update,
+            h2_error("🔐 Enter the password to run batch analysis."),
+            hidden_file,
+        )
+        return
 
-    sys_inst = _system_instruction(lang_code)
-    model_name = _resolve_model(client, model_pref)
+    if not PROJECT_IMPORTS_AVAILABLE:
+        yield (
+            hidden_df_update,
+            h2_error("Project dependencies are not loaded."),
+            hidden_file,
+        )
+        return
 
-    # Call model
+    if len(ai_registry) == 0 or not BATCH_MODEL_KEY:
+        yield (
+            hidden_df_update,
+            h2_error("❌ Batch analysis is unavailable: AI model is not configured."),
+            hidden_file,
+        )
+        return
+
+    # 2) асноўная логіка збору спісу званкоў
     try:
-        merged = f"""[SYSTEM INSTRUCTION: {sys_inst}]
-
-{prompt}"""
-        resp = client.models.generate_content(model=model_name, contents=[uploaded_file, merged])
-        text = getattr(resp, "text", None)
-        if not text:
-            return "Analysis finished but returned no text. Check model settings and file format."
-        # Add a listening link at the end
-        url = _recording_url(unique_id)
-        return f"""### Analysis result
-
-{text}
-
-**Recording:** {url}"""
-    except Exception as e:
-        # Try to attach more error details
-        msg = str(e)
-        try:
-            if hasattr(e, "args") and e.args:
-                msg = msg + "\n\n" + str(e.args[0])
-        except Exception:
-            pass
-        return f"Error during model call: {msg}"
-    finally:
-        # Best-effort cleanup of remote file
-        try:
-            if 'uploaded_file' in locals() and hasattr(uploaded_file, 'name'):
-                client.files.delete(name=uploaded_file.name)
-        except Exception:
-            pass
+        day = _parse_day(date_value)
+        time_from = _parse_time_value(time_from_value)
+        time_to = _parse_time_value(time_to_value)
+        _validate_time_range(time_from, time_to)
+        call_type = _resolve_call_type(call_type_value)
+
+        tenant = tenant_service.resolve(tenant_id or None)
+        entries = call_log_service.list_calls(
+            day,
+            tenant,
+            time_from=time_from,
+            time_to=time_to,
+            call_type=call_type,
+        )
 
-# ─────────────────────────────────────────────────────────────────────────────
-# NEW: Batch helpers for dynamic calltype choices and preview
-# ─────────────────────────────────────────────────────────────────────────────
+        if not entries:
+            yield (
+                hidden_df_update,
+                h3("ℹ️ No calls for the selected filter."),
+                hidden_file,
+            )
+            return
 
-def ui_batch_load(date_str: str, authed: bool):
-    """Fetch calls for the date, return DF, calltype choices, and status."""
-    if not authed:
-        return gr.update(), gr.update(), "🔒 Увядзіце пароль, каб атрымаць званкі.", gr.update(visible=True)
+        rows = []
+        total = len(entries)
 
-    date_str = (date_str or "").strip() or _today_str()
-    try:
-        calls = fetch_calllogs(date_str)
-        df = pd.DataFrame(calls)
-    except Exception as e:
-        return gr.update(), gr.update(choices=[""], value=""), f"Не ўдалося загрузіць спіс: {e}", gr.update(visible=False)
-
-    if df.empty:
-        return gr.update(value=pd.DataFrame()), gr.update(choices=[""], value=""), "За гэты дзень званкоў не знойдзена.", gr.update(visible=False)
-
-    # Build calltype list automatically
-    col = _infer_calltype_col(df)
-    if col:
-        types = sorted(set(str(x).strip() for x in df[col].dropna().unique() if str(x).strip()))
-        choices = [""] + types  # allow empty = no filter
-    else:
-        choices = [""]
+        # пачатковы апдэйт
+        yield (
+            gr.update(value=pd.DataFrame(), visible=False),
+            h3(f"Starting batch analysis for {total} call(s)..."),
+            hidden_file,
+        )
 
-    return (
-        df,  # store DF in state via gr.State
-        gr.update(choices=choices, value=""),
-        f"Загружана званкоў: {len(df)}. Абярыце фільтр і націсніце ‘Папярэдні прагляд’.",
-        gr.update(visible=False),
-    )
+        # 3) цыкл аналізу
+        for i, entry in enumerate(entries, start=1):
+            pct = int((i / total) * 100)
 
+            row_data = {
+                "Start": entry.started_at.isoformat() if entry.started_at else "",
+                "Caller": entry.caller_id or "",
+                "Destination": entry.destination or "",
+                "Duration (s)": entry.duration_seconds,
+                "UniqueId": entry.unique_id,
+            }
 
-def ui_batch_preview(df: pd.DataFrame, t_from: str, t_to: str, calltype: str):
-    ok, msg, from_ok, to_ok = _validate_times(t_from, t_to)
-    if not ok:
-        return pd.DataFrame(), f"{msg}", gr.update(info=("✓" if from_ok else "Format: HH:MM")), gr.update(info=("✓" if to_ok else "Format: HH:MM"))
+            try:
+                result = analysis_service.analyze_call(
+                    unique_id=entry.unique_id,
+                    tenant=tenant,
+                    lang=BATCH_LANGUAGE,
+                    options=AnalysisOptions(
+                        model_key=BATCH_MODEL_KEY,
+                        prompt_key=BATCH_PROMPT_KEY,
+                        custom_prompt=BATCH_PROMPT_TEXT or None,
+                    ),
+                )
+
+                link = (
+                    f"{tenant.vochi_base_url.rstrip('/')}/calllogs/"
+                    f"{tenant.vochi_client_id}/{entry.unique_id}"
+                )
+
+                # спроба structured JSON
+                try:
+                    text = str(result.text or "").strip()
+                    l, r = text.find("{"), text.rfind("}")
+                    if l != -1 and r != -1 and r > l:
+                        text = text[l : r + 1]
+                    payload = json.loads(text)
+
+                    row_data["Needs follow-up"] = (
+                        "Yes" if payload.get("needs_follow_up") else "No"
+                    )
+                    row_data["Reason"] = str(payload.get("reason") or "")
+                except Exception:
+                    row_data["Needs follow-up"] = ""
+                    row_data["Reason"] = result.text
+
+                row_data["Link"] = f'<a href="{link}" target="_blank">Listen</a>'
+                row_data["Status"] = "✅"
+            except Exception as exc:
+                row_data["Needs follow-up"] = ""
+                row_data["Reason"] = f"❌ {exc}"
+                row_data["Link"] = ""
+                row_data["Status"] = "❌"
+
+            rows.append(row_data)
+
+            partial_df = pd.DataFrame(rows)
+            interim_msg = f"Analyzing {i}/{total} ({pct}%)… UID `{entry.unique_id}`"
+
+            # прамежкавы yield (жывое абнаўленне табліцы + статус)
+            yield (
+                gr.update(value=partial_df, visible=True),
+                h3(interim_msg),
+                hidden_file,
+            )
 
-    if df is None or len(df) == 0:
-        return pd.DataFrame(), "Спачатку загрузіце спіс на дату.", gr.update(), gr.update()
+        # 4) фінал
+        final_df = pd.DataFrame(rows)
+        ok_count = len(final_df[final_df["Status"] == "✅"])
+        final_msg = (
+            "✅ Batch analysis completed. "
+            f"Found: {total}, processed successfully: {ok_count}"
+        )
 
-    # Filter
-    df_f = _filter_calls(df, t_from, t_to, calltype)
+        yield (
+            gr.update(value=final_df, visible=True),
+            h2_success(final_msg),
+            hidden_file,
+        )
 
-    # Add recording URL column for quick listening
-    if not df_f.empty and "UniqueId" in df_f.columns:
-        df_f = df_f.copy()
-        df_f["RecordingURL"] = df_f["UniqueId"].astype(str).map(_recording_url)
+    except Exception as exc:
+        yield (
+            hidden_df_update,
+            h2_error(f"❌ Analysis failed: {exc}"),
+            hidden_file,
+        )
+        return
 
-    count = len(df_f)
-    info = f"Фільтр: {t_from}–{t_to}{' | calltype=' + calltype if calltype else ''}. Знойдзена: <b>{count}</b>."
-    return df_f, info, gr.update(info=""), gr.update(info="")
 
+def ui_hide_call_list():
+    """Схаваць ручны спіс выклікаў пасля батча, каб не блытаць карыстальніка."""
+    return gr.update(visible=False)
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Batch analysis with time interval + calltype filter + URL in output
-# ─────────────────────────────────────────────────────────────────────────────
 
-def ui_analyze_calls_by_date(
-    authed: bool,
-    df_loaded: pd.DataFrame,
-    date_str: str,
-    t_from: str,
-    t_to: str,
-    calltype: str,
-    template_key: str,
-    custom_prompt: str,
-    lang_code: str,
-    model_pref: str,
-):
-    """
-    Analyze filtered calls one-by-one. Uses the already loaded DF to allow
-    dynamic calltype dropdown and preview step. Adds listening URL to each block.
-    """
-    # Password gate
-    if not authed:
-        return (
-            "🔒 Увядзіце пароль, каб запусціць аналіз.",  # results_md
-            None,                                          # file
-            "Доступ закрыты.",                             # status
-            gr.update(visible=True),                       # show pwd group
-        )
+def ui_export_results(results_df):
+    """Захаваць батч-аналіз у CSV і вярнуць файл у UI."""
+    if results_df is None or results_df.empty:
+        return gr.update(value=None, visible=False), "❌ No data to export."
 
-    # Validate time inputs
-    ok, msg, from_ok, to_ok = _validate_times(t_from, t_to)
-    if not ok:
-        return (msg, None, "", gr.update(visible=False))
+    with tempfile.NamedTemporaryFile(
+        "w", suffix=".csv", delete=False, encoding="utf-8"
+    ) as tmp:
+        results_df.to_csv(tmp.name, index=False)
+        return gr.update(value=tmp.name, visible=True), "✅ File is ready to save."
 
-    # Ensure DF is present; if not, fallback to fetch (safety)
-    if df_loaded is None or len(df_loaded) == 0:
-        try:
-            calls = fetch_calllogs((date_str or _today_str()).strip())
-            df_loaded = pd.DataFrame(calls)
-        except Exception as e:
-            return (f"Не ўдалося загрузіць спіс: {e}", None, "", gr.update())
 
-    if df_loaded.empty:
-        return ("За гэты дзень званкоў не знойдзена.", None, "", gr.update())
+def ui_check_password(pwd: str):
+    """Праверка доступу ў UI."""
+    _UI_PASSWORD = os.environ.get("VOCHI_UI_PASSWORD", "")
 
-    # Filter by time + calltype
-    df_f = _filter_calls(df_loaded, t_from, t_to, calltype)
-    total = len(df_f)
+    if not _UI_PASSWORD:
+        # пароль не настроены -> усім можна
+        return (
+            False,
+            "⚠️ <b>VOCHI_UI_PASSWORD</b> is not configured. Access granted without password.",
+            gr.update(visible=False),
+        )
 
-    if total == 0:
-        info = f"Па фільтру ({t_from}–{t_to}{' | ' + calltype if calltype else ''}) — 0 званкоў."
-        return (info, None, info, gr.update())
+    if (pwd or "").strip() == _UI_PASSWORD:
+        return True, "✅ Access granted.", gr.update(visible=False)
 
-    # Prepare model
-    if not _HAS_GENAI:
-        return ("❌ google-genai library not found.", None, "", gr.update())
+    return False, "❌ Incorrect password.", gr.update(visible=True)
 
-    api_key = os.environ.get("GOOGLE_API_KEY", "").strip()
-    if not api_key:
-        return ("GOOGLE_API_KEY не зададзены ў Secrets.", None, "", gr.update())
 
-    try:
-        client = genai.Client(api_key=api_key)
-        model_name = _resolve_model(client, model_pref)
-    except Exception as e:
-        return (f"Не ўдалося ініцыялізаваць кліента: {e}", None, "", gr.update())
+def ui_show_current_uid(current_uid: str):
+    """Паказаць выбраны UID у табе AI Analysis."""
+    uid = (current_uid or "").strip()
+    return (
+        f"**Selected UniqueId:** `{uid}`"
+        if uid
+        else "No file selected for AI Analysis."
+    )
 
-    sys_inst = _system_instruction(lang_code)
-    prompt = _prepare_prompt(template_key, custom_prompt)
 
-    # Iterate filtered calls
-    results_blocks: List[str] = [
-        f"""## Вынікі
-Дата: {(date_str or _today_str()).strip()}
+def ui_analyze_bridge(
+    selected_idx,
+    df,
+    template_key,
+    custom_prompt,
+    lang_code,
+    model_pref,
+    tenant_id,
+    current_uid,
+):
+    """
+    Аналіз адной размовы З ПРАГРЭСАМ.
+    ВАЖНА:
+    - Гэта цяпер генератар (yield), а не звычайная функцыя.
+    - Мы не выкарыстоўваем аргумент progress=... (ён ламаецца ў Gradio 5).
+    - Зрабляем некалькі крокаў:
+        1) праверкі і падрыхтоўка -> yield статычны статус
+        2) выклік аналізу -> пасля гэтага яшчэ адзін yield з вынікам
+    - Gradio сам пакажа built-in progress bar праз show_progress="full".
+    """
 
-Фільтр: {t_from}–{t_to}{' | calltype=' + calltype if calltype else ''}
+    # STEP 0. Вызначаем, які UID трэба аналізаваць
+    uid_to_analyze = (current_uid or "").strip()
+    if not uid_to_analyze and selected_idx is not None and df is not None and not df.empty:
+        try:
+            uid_to_analyze = str(df.iloc[int(selected_idx)].get("UniqueId") or "").strip()
+        except (ValueError, IndexError):
+            uid_to_analyze = ""
 
-Знойдзена званкоў: {total}
+    # Калі няма UID -> адразу вынікаем
+    if not uid_to_analyze:
+        yield "Select a call from the list or batch results first."
+        return
 
----"""
-    ]
-    analyzed = 0
+    # STEP 1. Праверкі канфігурацыі перад выклікам мадэлі
+    if not PROJECT_IMPORTS_AVAILABLE:
+        yield "Project dependencies are not loaded."
+        return
 
-    for i, row in df_f.reset_index(drop=True).iterrows():
-        unique_id = str(row.get("UniqueId", ""))
-        if not unique_id:
-            continue
+    if len(ai_registry) == 0:
+        yield "❌ No AI models are configured."
+        return
 
-        # Download/cache mp3
-        try:
-            mp3_path = f"/tmp/call_{unique_id}.mp3"
-            if not os.path.exists(mp3_path) or os.path.getsize(mp3_path) == 0:
-                mp3_path, _ = fetch_mp3_by_unique_id(unique_id)
-        except Exception as e:
-            url = _recording_url(unique_id)
-            results_blocks.append(
-                f"""### Call {i+1}
-- UniqueId: {unique_id}
-- Start: {row.get('Start','')}
-- CallerId: {row.get('CallerId','')}
-- Destination: {row.get('Destination','')}
-- Duration: {row.get('Duration','')}
-- Recording: {url}
-
-**Памылка загрузкі аўдыё:** {e}
----"""
-            )
-            continue
+    if model_pref not in ai_registry:
+        yield "❌ Selected model is not available."
+        return
 
-        # Upload + generate
-        try:
-            uploaded_file = client.files.upload(file=mp3_path)
-            merged = f"""[SYSTEM INSTRUCTION: {sys_inst}]
+    # паказваем карыстальніку, што пачынаем
+    yield f"### Preparing analysis...\n\n- UID: `{uid_to_analyze}`\n- Model: `{model_pref}`\n- Lang: `{lang_code}`\n\nPlease wait…"
 
-{prompt}"""
-            resp = client.models.generate_content(
-                model=model_name,
-                contents=[uploaded_file, merged],
-            )
-            text = getattr(resp, "text", "") or "(пусты адказ)"
-        except Exception as e:
-            text = f"Памылка аналізу: {e}"
-        finally:
-            try:
-                if 'uploaded_file' in locals() and hasattr(uploaded_file, 'name'):
-                    client.files.delete(name=uploaded_file.name)
-            except Exception:
-                pass
-
-        # Result block with listening URL
-        url = _recording_url(unique_id)
-        block = (
-            f"""### Call {i+1}
-- UniqueId: {unique_id}
-- Start: {row.get('Start','')}
-- CallerId: {row.get('CallerId','')}
-- Destination: {row.get('Destination','')}
-- Duration: {row.get('Duration','')}
-- Recording: {url}
-
-**Analysis:**
-
-{text}
----"""
+    # STEP 2. Рэальны аналіз
+    try:
+        tenant = tenant_service.resolve(tenant_id or None)
+        lang = Language(lang_code)
+
+        result = analysis_service.analyze_call(
+            unique_id=uid_to_analyze,
+            tenant=tenant,
+            lang=lang,
+            options=AnalysisOptions(
+                model_key=model_pref,
+                prompt_key=template_key,
+                custom_prompt=custom_prompt,
+            ),
         )
-        results_blocks.append(block)
-        analyzed += 1
 
-    if analyzed == 0:
-        info = "Не атрымалася прааналізаваць ніводнага званка."
-        return (info, None, info, gr.update())
+        # STEP 3. Гатова, вяртаем вынік
+        yield f"### Analysis result\n\n{result.text}"
 
-    # Save to .txt and return
-    results_text = "\n\n".join(results_blocks)
-    fname = f"/tmp/batch_analysis_{(date_str or _today_str()).strip()}_{t_from.replace(':','')}-{t_to.replace(':','')}_{int(time.time())}.txt"
-    with open(fname, "w", encoding="utf-8") as f:
-        f.write(results_text)
+    except Exception as exc:
+        yield f"Analysis failed: {exc}"
 
-    status = f"Гатова ✅. Па фільтру — {total} званкоў. Прааналізавана: {analyzed}."
-    return (results_text, fname, status, gr.update(visible=False))
 
-# ─────────────────────────────────────────────────────────────────────────────
-# Password / gating helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def ui_check_password(pwd: str):
+def ui_on_batch_row_select(
+    displayed_df: pd.DataFrame,
+    full_df_state: pd.DataFrame,
+    tenant_id: str,
+    evt: gr.SelectData,
+):
     """
-    Check password against VOCHI_UI_PASSWORD.
-    Returns: (authed_state, status_msg_md, pwd_group_visibility)
+    Апрацоўвае выбар радка з табліцы вынікаў (Batch results).
+    ВАЖНА:
+      - evt.index дае індэкс радка ў адлюстраванай табліцы (пасля сартыроўкі/фільтрацыі),
+        а не ў зыходных дадзеных.
+      - Мы дастаём UniqueId з гэтага радка і будуем адзін варыянт для выпадаючага спісу "Call".
     """
-    if not _UI_PASSWORD:
-        # Admin hint if password not configured
-        return False, (
-            "⚠️ <b>VOCHI_UI_PASSWORD</b> не наладжаны ў Secrets. "
-            "Дадайце яго ў Settings → Secrets і перазапусціце Space."
-        ), gr.update(visible=True)
+    # Значэнні па змаўчанні, калі нешта пойдзе не так
+    empty_return = (
+        gr.update(choices=[], value=None),
+        "",
+        "No file selected for AI Analysis.",
+    )
 
-    if (pwd or "").strip() == _UI_PASSWORD:
-        return True, "✅ Доступ адкрыты. Цяпер можна націскаць <b>Fetch list</b> і працаваць.", gr.update(visible=False)
-    else:
-        return False, "❌ Няправільны пароль. Паспрабуйце яшчэ раз.", gr.update(visible=True)
+    # Праверка, ці ёсць даныя для апрацоўкі
+    if (
+        evt is None
+        or displayed_df is None
+        or displayed_df.empty
+        or full_df_state is None
+        or full_df_state.empty
+    ):
+        return empty_return
 
+    try:
+        # КРОК 1: Атрымліваем індэкс выбранага радка з аб'екта падзеі (evt)
+        # evt.index тут успрымаем як спіс выбраных радкоў, бярэм першы
+        visual_row_index = evt.index[0]
+        clicked_row_from_view = displayed_df.iloc[visual_row_index]
+
+        # КРОК 2: Здабываем унікальны ідэнтыфікатар (UniqueId)
+        uid = str(clicked_row_from_view.get("UniqueId", "")).strip()
+        if not uid:
+            return empty_return
+
+        # Шукай арыгінальны радок у поўным наборы даных
+        original_row_series = full_df_state[full_df_state["UniqueId"] == uid]
+        if original_row_series.empty:
+            return empty_return
+        original_row = original_row_series.iloc[0]
+        row_dict = original_row.to_dict()
+
+        # КРОК 3: Чалавечы лэйбл для выпадаючага спісу
+        label = (
+            f"{row_dict.get('Start','')} | "
+            f"{row_dict.get('Caller','')} → "
+            f"{row_dict.get('Destination','')} "
+            f"({row_dict.get('Duration (s)','')}s)"
+        )
 
-def ui_fetch_or_auth(date_str: str, authed: bool):
-    """
-    If not authed, open password box instead of fetching.
-    Otherwise, fetch calls.
-    Returns: calls_df, row_dd, status_md, pwd_group_visibility
-    """
-    if not authed:
-        return gr.update(), gr.update(), "🔒 Увядзіце пароль, каб атрымаць званкі.", gr.update(visible=True)
-    df, dd, msg = ui_fetch_calls(date_str)
-    return df, dd, msg, gr.update(visible=False)
+        # КРОК 4: Абнаўленне для Dropdown "Call"
+        # choices = [("бачны тэкст", value_for_component)]
+        dd_update = gr.update(choices=[(f"Batch: {label}", uid)], value=uid)
+
+        # КРОК 5: Вяртаем:
+        #  - абнаўленне row_dd
+        #  - сам uid -> кладзецца ў current_uid_state
+        #  - фарматаваны Markdown з UID у табе "AI Analysis"
+        return dd_update, uid, ui_show_current_uid(uid)
+
+    except (AttributeError, IndexError, KeyError):
+        return empty_return
 
 
-# ─────────────────────────────────────────────────────────────────────────────
+# ----------------------------------------------------------------------------
 # Build Gradio UI
-# ─────────────────────────────────────────────────────────────────────────────
+# ----------------------------------------------------------------------------
+def _today_str():
+    return _dt.date.today().strftime("%Y-%m-%d")
+
 
 with gr.Blocks(title="Vochi CRM Call Logs (Gradio)") as demo:
     gr.Markdown(
-        """
-# Vochi CRM → MP3 → AI analysis
-*Fetch daily calls, play/download MP3, and analyze the call with an AI model.*
-"""
+        "# Vochi CRM → MP3 → AI analysis\n"
+        "*Filter calls by date, time and type, listen to recordings and run batch AI analysis.*"
     )
 
-    # Auth state (False by default)
     authed = gr.State(False)
+    batch_results_state = gr.State(pd.DataFrame())
+    current_uid_state = gr.State("")
 
-    # States for batch tab
-    batch_df_state = gr.State(pd.DataFrame())
-
-    # Password "modal" (group shown on demand)
-    with gr.Group(visible=False) as pwd_group:
-        gr.Markdown("### 🔐 Увядзіце пароль")
-        pwd_tb = gr.Textbox(label="Password", type="password", placeholder="••••••••", lines=1)
-        pwd_btn = gr.Button("Адкрыць доступ", variant="primary")
+    with gr.Group(visible=os.environ.get("VOCHI_UI_PASSWORD", "") != "") as pwd_group:
+        gr.Markdown("### 🔐 Enter password")
+        pwd_tb = gr.Textbox(
+            label="Password", type="password", placeholder="••••••••", lines=1
+        )
+        pwd_btn = gr.Button("Unlock", variant="primary")
 
     with gr.Tabs() as tabs:
         with gr.Tab("Vochi CRM"):
             with gr.Row():
-                date_inp = gr.Textbox(label="Date", value=_today_str(), scale=1)
-                fetch_btn = gr.Button("Fetch list", variant="primary", scale=0)
-            calls_df = gr.Dataframe(value=pd.DataFrame(), label="Call list", interactive=False)
-            row_dd = gr.Dropdown(choices=[], label="Call", info="Select a row for playback/analysis")
+                tenant_tb = gr.Textbox(
+                    label="Tenant ID", value=DEFAULT_TENANT_ID, scale=1
+                )
+                date_inp = gr.Textbox(
+                    label="Date", value=_today_str(), placeholder="YYYY-MM-DD", scale=1
+                )
+                time_from_inp = gr.Textbox(
+                    label="Time from", placeholder="HH:MM", scale=1
+                )
+                time_to_inp = gr.Textbox(label="Time to", placeholder="HH:MM", scale=1)
+                call_type_dd = gr.Dropdown(
+                    choices=CALL_TYPE_OPTIONS,
+                    value="",
+                    label="Call type",
+                    type="value",
+                    scale=1,
+                )
             with gr.Row():
-                play_btn = gr.Button("🎧 Play")
-            url_html = gr.HTML()
-            audio_out = gr.Audio(label="Audio", type="filepath")
-            file_out = gr.File(label="MP3 download")
+                filter_btn = gr.Button("Filter", variant="primary", scale=0)
+                batch_btn = gr.Button("Batch analyze", variant="secondary", scale=0)
+                save_btn = gr.Button("Save to file", scale=0)
+
             status_fetch = gr.Markdown()
+            batch_status_md = gr.Markdown()
 
-        with gr.Tab("AI Analysis"):
-            with gr.Row():
-                tpl_dd = gr.Dropdown(choices=TPL_OPTIONS, value="simple", label="Template")
-                lang_dd = gr.Dropdown(choices=LANG_OPTIONS, value="default", label="Language")
-                model_dd = gr.Dropdown(choices=MODEL_OPTIONS, value="models/gemini-2.5-flash", label="Model")
-            custom_prompt_tb = gr.Textbox(label="Custom prompt", lines=8, visible=False)
-            analyze_btn = gr.Button("🧠 Analyze", variant="primary")
-            analysis_md = gr.Markdown()
+            calls_df = gr.DataFrame(
+                value=pd.DataFrame(),
+                label="Call list (manual filter)",
+                interactive=False,
+            )
 
-        # Пакетны аналіз з фільтрамі па часе і calltype + прэв'ю
-        with gr.Tab("Аналіз званкоў за дзень/час"):
-            batch_date_inp = gr.Textbox(label="Date", value=_today_str(), scale=1)
+            batch_results_df = gr.DataFrame(
+                value=pd.DataFrame(),
+                label="Batch results",
+                interactive=True,
+                visible=False,
+                datatype=[
+                    "str",    # Start
+                    "str",    # Caller
+                    "str",    # Destination
+                    "number", # Duration (s)
+                    "str",    # UniqueId
+                    "str",    # Needs follow-up
+                    "str",    # Reason
+                    "markdown",  # Link
+                    "str",    # Status
+                ],
+            )
 
-            with gr.Row():
-                t_from_inp = gr.Textbox(label="Time from (HH:MM)", value=_DEF_T_FROM)
-                t_to_inp   = gr.Textbox(label="Time to (HH:MM)",   value=_DEF_T_TO)
-                calltype_dd = gr.Dropdown(label="calltype", choices=[""], value="", info="Аўта-значэнні пасля загрузкі")
+            row_dd = gr.Dropdown(
+                choices=[],
+                label="Call",
+                info="Choose a row to listen/analyze",
+                type="value",
+            )
 
             with gr.Row():
-                load_btn = gr.Button("Атрымаць спіс (для фільтраў)", variant="secondary")
-                preview_btn = gr.Button("Папярэдні прагляд", variant="secondary")
-                batch_btn = gr.Button("прааналізаваць", variant="primary")
+                play_btn = gr.Button("🎧 Play")
 
-            preview_info_md = gr.Markdown()
-            preview_df = gr.Dataframe(value=pd.DataFrame(), label="Адфільтраваныя званкі", interactive=False)
+            url_html = gr.HTML()
+            audio_out = gr.Audio(label="Audio", type="filepath")
+            batch_file = gr.File(label="Export CSV", visible=False)
 
+        with gr.Tab("AI Analysis"):
             with gr.Row():
-                tpl_batch_dd = gr.Dropdown(choices=TPL_OPTIONS, value="simple", label="Template")
-                lang_batch_dd = gr.Dropdown(choices=LANG_OPTIONS, value="default", label="Language")
-                model_batch_dd = gr.Dropdown(choices=MODEL_OPTIONS, value="models/gemini-2.5-flash", label="Model")
+                tpl_dd = gr.Dropdown(
+                    choices=TPL_OPTIONS,
+                    value="simple" if TPL_OPTIONS else "custom",
+                    label="Template",
+                )
+                lang_dd = gr.Dropdown(
+                    choices=LANG_OPTIONS,
+                    value=Language.AUTO,
+                    label="Language",
+                )
+                model_dd = gr.Dropdown(
+                    choices=MODEL_CHOICES,
+                    value=MODEL_DEFAULT,
+                    label="Model",
+                    interactive=bool(MODEL_OPTIONS),
+                    info=MODEL_INFO,
+                )
+
+            custom_prompt_tb = gr.Textbox(
+                label="Custom prompt", lines=8, visible=False
+            )
 
-            custom_batch_tb = gr.Textbox(label="Custom prompt", lines=8, visible=False)
+            current_uid_md = gr.Markdown(
+                value="No file selected for AI Analysis."
+            )
 
-            batch_status_md = gr.Markdown()
-            batch_results_md = gr.Markdown()
-            batch_file_out = gr.File(label="Вынікі (.txt)")
-
-    # Wire events
-    # 1) Fetch button: gate by password
-    fetch_btn.click(
-        ui_fetch_or_auth,
-        inputs=[date_inp, authed],
-        outputs=[calls_df, row_dd, status_fetch, pwd_group],
-    )
+            analyze_btn = gr.Button("🧠 Analyze", variant="primary")
+            analysis_md = gr.Markdown()
+
+    # --- wiring events ---
 
-    # 2) Password submit → set authed state, show message, hide group on success
+    # пароль
     pwd_btn.click(
         ui_check_password,
         inputs=[pwd_tb],
         outputs=[authed, status_fetch, pwd_group],
     )
 
-    # 3) Other interactions (single analysis)
-    play_btn.click(ui_play_audio, inputs=[row_dd, calls_df], outputs=[url_html, audio_out, file_out, status_fetch])
-    tpl_dd.change(ui_toggle_custom_prompt, inputs=[tpl_dd], outputs=[custom_prompt_tb])
-    analyze_btn.click(
-        ui_analyze,
-        inputs=[row_dd, calls_df, tpl_dd, custom_prompt_tb, lang_dd, model_dd],
-        outputs=[analysis_md],
+    # ручная фільтрацыя
+    filter_btn.click(
+        ui_filter_calls,
+        inputs=[date_inp, time_from_inp, time_to_inp, call_type_dd, authed, tenant_tb],
+        outputs=[calls_df, batch_results_df, row_dd, status_fetch, pwd_group],
     )
 
-    # 4) Batch tab interactions
-    tpl_batch_dd.change(ui_toggle_custom_prompt, inputs=[tpl_batch_dd], outputs=[custom_batch_tb])
+    # масавы аналіз (stream з yield -> жывое абнаўленне і "прагрэс-бар" у выглядзе статусу)
+    batch_btn.click(
+        fn=ui_mass_analyze,
+        inputs=[date_inp, time_from_inp, time_to_inp, call_type_dd, tenant_tb, authed],
+        outputs=[batch_results_df, batch_status_md, batch_file],
+    ).then(
+        fn=lambda df: df,
+        inputs=[batch_results_df],
+        outputs=[batch_results_state],
+    ).then(
+        fn=ui_hide_call_list,
+        outputs=[calls_df],
+    )
 
-    # Load list for date → populate state & calltype dropdown
-    load_btn.click(
-        ui_batch_load,
-        inputs=[batch_date_inp, authed],
-        outputs=[batch_df_state, calltype_dd, preview_info_md, pwd_group],
+    # выбар радка з батчу -> абнаўляем поле Call + UID у AI Analysis
+    batch_results_df.select(
+        fn=ui_on_batch_row_select,
+        inputs=[batch_results_df, batch_results_state, tenant_tb],
+        outputs=[row_dd, current_uid_state, current_uid_md],
     )
 
-    # Preview filtered table
-    preview_btn.click(
-        ui_batch_preview,
-        inputs=[batch_df_state, t_from_inp, t_to_inp, calltype_dd],
-        outputs=[preview_df, preview_info_md, t_from_inp, t_to_inp],
+    # прайграванне аўдыё
+    play_btn.click(
+        ui_play_audio,
+        inputs=[row_dd, calls_df, tenant_tb],
+        outputs=[url_html, audio_out, status_fetch],
     )
 
-    # Analyze filtered
-    batch_btn.click(
-        ui_analyze_calls_by_date,
-        inputs=[authed, batch_df_state, batch_date_inp, t_from_inp, t_to_inp, calltype_dd, tpl_batch_dd, custom_batch_tb, lang_batch_dd, model_batch_dd],
-        outputs=[batch_results_md, batch_file_out, batch_status_md, pwd_group],
+    # экспарт CSV
+    save_btn.click(
+        ui_export_results,
+        inputs=[batch_results_state],
+        outputs=[batch_file, batch_status_md],
     )
 
+    # паказаць поле для свайго prompt
+    tpl_dd.change(
+        ui_toggle_custom_prompt,
+        inputs=[tpl_dd],
+        outputs=[custom_prompt_tb],
+    )
+
+    # аналіз адной размовы з прагрэсам
+    analyze_btn.click(
+        fn=ui_analyze_bridge,
+        inputs=[
+            row_dd,
+            calls_df,
+            tpl_dd,
+            custom_prompt_tb,
+            lang_dd,
+            model_dd,
+            tenant_tb,
+            current_uid_state,
+        ],
+        outputs=[analysis_md],
+        show_progress="full",  # Gradio будзе паказваць progress bar аўтаматычна
+    )
 
 if __name__ == "__main__":
-    # On HF Spaces, just running this file is enough; launch() is fine for local dev, too.
-    demo.launch()
+    # УВАГА: Замяні "D:\\tmp" на шлях, дзе ляжаць MP3-запісы,
+    # каб кнопка 🎧 Play магла іх прайграваць лакальна.
+    demo.launch(allowed_paths=["D:\\tmp"])