import os
import yaml
import shutil
from pathlib import Path
try:
    import tomllib
except ModuleNotFoundError:  # Py<3.11
    import tomli as tomllib
import streamlit as st

from database import set_db_path, init_schema
from api_client import APIClient
from utils import ensure_dirs
from auth import initialize_auth_system, render_login_form, render_sidebar, require_login
from mobile_verification import render_mobile_verification_screen, get_user_permissions
from compliance_client import compliance_client
from page_modules.process_video import render_process_video_page
from page_modules.analyze_transcriptions import render_analyze_transcriptions_page
from page_modules.statistics import render_statistics_page
from page_modules.validation import render_validation_page


# -- Move DB ---
os.environ["STREAMLIT_DATA_DIRECTORY"] = "/tmp/.streamlit"
Path("/tmp/.streamlit").mkdir(parents=True, exist_ok=True)
Path("/tmp/data").mkdir(parents=True, exist_ok=True)
source_db = "init_data/veureu.db"
target_db = "/tmp/data/app.db"
if not os.path.exists(target_db) and os.path.exists(source_db):
    shutil.copy(source_db, target_db)

static_videos = Path(__file__).parent / "videos"
runtime_videos = Path("/tmp/data/videos")
if not runtime_videos.exists():
    shutil.copytree(static_videos, runtime_videos, dirs_exist_ok=True)


# --- Config ---
def _load_yaml(path="config.yaml") -> dict:
    with open(path, "r", encoding="utf-8") as f:
        cfg = yaml.safe_load(f) or {}
    # interpolación sencilla de ${VARS} si las usas en el YAML
    def _subst(s: str) -> str:
        return os.path.expandvars(s) if isinstance(s, str) else s

    # aplica sustitución en los campos que te interesan
    if "api" in cfg:
        cfg["api"]["base_url"] = _subst(cfg["api"].get("base_url", ""))
        cfg["api"]["token"]    = _subst(cfg["api"].get("token", ""))

    if "storage" in cfg and "root_dir" in cfg["storage"]:
        cfg["storage"]["root_dir"] = _subst(cfg["storage"]["root_dir"])

    if "sqlite" in cfg and "path" in cfg["sqlite"]:
        cfg["sqlite"]["path"] = _subst(cfg["sqlite"]["path"])

    return cfg

CFG = _load_yaml("config.yaml")

# Ajuste de variables según tu esquema YAML
DATA_DIR = CFG.get("storage", {}).get("root_dir", "data")
BACKEND_BASE_URL = CFG.get("api", {}).get("base_url", "http://localhost:8000")
USE_MOCK = bool(CFG.get("app", {}).get("use_mock", False))  # si no la tienes en el yaml, queda False
API_TOKEN = CFG.get("api", {}).get("token") or os.getenv("API_SHARED_TOKEN")

os.makedirs(DATA_DIR, exist_ok=True)
ensure_dirs(DATA_DIR)
DB_PATH = os.path.join(DATA_DIR, "app.db")
set_db_path(DB_PATH)
init_schema()

# Initialize authentication system and sync default users
initialize_auth_system(DB_PATH)

api = APIClient(BACKEND_BASE_URL, use_mock=USE_MOCK, data_dir=DATA_DIR, token=API_TOKEN)

st.set_page_config(page_title="Veureu — Audiodescripció", page_icon="🎬", layout="wide")

# Initialize session state for user
if "user" not in st.session_state:
    st.session_state.user = None

# Render sidebar and get navigation
page, role = render_sidebar()

# Pre-login screen
if not st.session_state.user:
    st.title("Veureu — Audiodescripció")
    render_login_form()
    st.stop()

# Post-login: Verificación por móvil si es necesaria
if st.session_state.user and 'sms_verified' not in st.session_state:
    st.session_state.sms_verified = None

permissions = None
if st.session_state.user:
    username = st.session_state.user['username']
    role = st.session_state.user['role']
    
    # Obtener permisos para ver si requiere SMS
    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
    
    # Si requiere SMS y aún no está verificado/omitido, mostrar pantalla de verificación
    if permissions["requires_sms"] and st.session_state.sms_verified is None:
        result = render_mobile_verification_screen(username, role)
        if result is None:
            # Aún en proceso de verificación
            st.stop()
        # Si result es True o False, ya se ha completado/omitido y continúa

# --- Pages ---
if page == "Processar vídeo nou":
    require_login(render_login_form)
    
    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
    if not permissions["procesar_videos"]:
        st.error("No tens permisos per processar nous vídeos. Verifica el teu mòbil per obtenir accés complet.")
        st.stop()

    render_process_video_page(api, BACKEND_BASE_URL)

elif page == "Analitzar video-transcripcions":
    require_login(render_login_form)
    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
    render_analyze_transcriptions_page(api, permissions)

elif page == "Estadístiques":
    require_login(render_login_form)
    render_statistics_page()

elif page == "Validació":
    require_login(render_login_form)
    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
    render_validation_page(compliance_client, runtime_videos, permissions, username)