from __future__ import annotations

import json
import re
import warnings
from collections import Counter
from pathlib import Path
from typing import Any, Dict, Optional, Tuple

import joblib
import numpy as np
import pandas as pd
import streamlit as st
import torch
import torch.nn as nn
from pyvi import ViTokenizer
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
from torch.utils.data import DataLoader, Dataset

try:
    from teencode_normalizer import normalize_teencode
except ImportError:
    def normalize_teencode(t: str) -> str:
        return t

warnings.filterwarnings("ignore")

st.set_page_config(
    page_title="DLNLP Demo",
    page_icon="🧠",
    layout="wide",
    initial_sidebar_state="collapsed",
)

PROJECT_ROOT = Path(__file__).resolve().parent
DATA_DIR = PROJECT_ROOT / "data"
MODEL_DIR = PROJECT_ROOT / "outputs" / "models"
RESULT_DIR = PROJECT_ROOT / "outputs" / "results"
FIG_DIR = PROJECT_ROOT / "outputs" / "figures"
PHOBERT_DIR = MODEL_DIR / "phobert_base"
DEBERTA_DIR = MODEL_DIR / "deberta"

LABEL_MAP = {0: "CLEAN", 1: "OFFENSIVE", 2: "HATE"}
LABEL_VI = {0: "Bình thường", 1: "Công kích", 2: "Thù ghét"}
LABEL_COLOR = {0: "#16a34a", 1: "#f59e0b", 2: "#dc2626"}
LABEL_BG = {0: "#dcfce7", 1: "#ffedd5", 2: "#fee2e2"}
LABEL_TEXT = {0: "#14532d", 1: "#7c2d12", 2: "#7f1d1d"}

DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

SAMPLES = {
    "Câu tích cực": "Bài viết này rất hữu ích, cảm ơn bạn đã chia sẻ.",
    "Câu công kích nhẹ": "Đọc mà chán thật, nói năng kiểu này thì ai chịu nổi.",
    "Câu thù ghét": "Mấy đứa đó đúng là phải biến khỏi đây ngay.",
    "Câu trung tính": "Hôm nay trời khá mát, mình vừa đi học về.",
}


class BiLSTMClassifier(nn.Module):
    def __init__(self, vocab_size: int, embed_dim: int, hidden_dim: int, num_classes: int, num_layers: int = 2, dropout: float = 0.4):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        self.emb_dropout = nn.Dropout(dropout)
        self.lstm = nn.LSTM(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,
            bidirectional=True,
            dropout=dropout if num_layers > 1 else 0.0,
        )
        self.dropout = nn.Dropout(dropout)
        self.fc = nn.Linear(hidden_dim * 4, num_classes)

    def forward(self, input_ids, lengths):
        emb = self.emb_dropout(self.embedding(input_ids))
        packed = nn.utils.rnn.pack_padded_sequence(
            emb,
            lengths.cpu(),
            batch_first=True,
            enforce_sorted=False,
        )
        packed_out, _ = self.lstm(packed)
        output, _ = nn.utils.rnn.pad_packed_sequence(
            packed_out,
            batch_first=True,
            total_length=input_ids.size(1),
        )

        mask = (input_ids != 0).unsqueeze(-1)
        output_masked = output.masked_fill(~mask, -1e9)
        max_pool = output_masked.max(dim=1).values

        sum_pool = (output * mask).sum(dim=1)
        valid_len = mask.sum(dim=1).clamp(min=1)
        mean_pool = sum_pool / valid_len

        feat = torch.cat([max_pool, mean_pool], dim=1)
        logits = self.fc(self.dropout(feat))
        return logits


class TextDataset(Dataset):
    def __init__(self, texts, vocab, max_len):
        self.texts = list(texts)
        self.vocab = vocab
        self.max_len = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        input_ids, length = encode_text(self.texts[idx], self.vocab, self.max_len)
        return {
            "input_ids": torch.tensor(input_ids, dtype=torch.long),
            "length": torch.tensor(length, dtype=torch.long),
        }


@st.cache_resource(show_spinner=False)
def load_svm_artifacts() -> Tuple[Any, Any]:
    vectorizer = joblib.load(MODEL_DIR / "tfidf_vectorizer.joblib")
    model = joblib.load(MODEL_DIR / "svm_model.joblib")
    return vectorizer, model


@st.cache_resource(show_spinner=False)
def load_bilstm_artifacts() -> Optional[Dict[str, Any]]:
    vocab_path = MODEL_DIR / "bilstm_vocab.json"
    model_path = MODEL_DIR / "bilstm_best.pt"
    metrics_path = RESULT_DIR / "bilstm_metrics.csv"

    if not vocab_path.exists() or not model_path.exists() or not metrics_path.exists():
        return None

    vocab = json.loads(vocab_path.read_text(encoding="utf-8"))
    metrics_df = pd.read_csv(metrics_path)
    if metrics_df.empty:
        return None

    row = metrics_df.iloc[0]
    max_len = int(row.get("max_len", 64))
    embed_dim = int(row.get("embed_dim", 300))
    hidden_dim = int(row.get("hidden_dim", 128))
    num_layers = int(row.get("num_layers", 2))

    model = BiLSTMClassifier(
        vocab_size=len(vocab),
        embed_dim=embed_dim,
        hidden_dim=hidden_dim,
        num_classes=3,
        num_layers=num_layers,
        dropout=0.4,
    ).to(DEVICE)
    state_dict = torch.load(model_path, map_location=DEVICE)
    model.load_state_dict(state_dict)
    model.eval()

    return {
        "model": model,
        "vocab": vocab,
        "max_len": max_len,
        "embed_dim": embed_dim,
        "hidden_dim": hidden_dim,
        "num_layers": num_layers,
    }


@st.cache_resource(show_spinner=False)
def find_phobert_model_dir() -> Optional[Path]:
    if not PHOBERT_DIR.exists():
        return None

    candidates = []
    for pattern in ("**/config.json", "**/pytorch_model.bin", "**/model.safetensors"):
        for file_path in PHOBERT_DIR.glob(pattern):
            candidates.append(file_path.parent)

    if not candidates:
        return None

    unique_dirs = []
    seen = set()
    for candidate in candidates:
        resolved = candidate.resolve()
        if resolved not in seen:
            seen.add(resolved)
            unique_dirs.append(candidate)

    return max(unique_dirs, key=lambda item: item.stat().st_mtime)


@st.cache_resource(show_spinner=False)
def load_phobert_artifacts() -> Optional[Dict[str, Any]]:
    model_dir = find_phobert_model_dir()
    if model_dir is None:
        return None

    try:
        from transformers.models.auto.modeling_auto import AutoModelForSequenceClassification
        from transformers.models.auto.tokenization_auto import AutoTokenizer

        tokenizer = AutoTokenizer.from_pretrained(model_dir)
        model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(DEVICE)
        model.eval()
        return {"tokenizer": tokenizer, "model": model, "model_dir": model_dir}
    except Exception:
        return None


@st.cache_resource(show_spinner=False)
def find_deberta_model_dir() -> Optional[Path]:
    if not DEBERTA_DIR.exists():
        return None

    candidates = []
    for pattern in ("**/config.json", "**/pytorch_model.bin", "**/model.safetensors"):
        for file_path in DEBERTA_DIR.glob(pattern):
            candidates.append(file_path.parent)

    if not candidates:
        return None

    unique_dirs = []
    seen = set()
    for candidate in candidates:
        resolved = candidate.resolve()
        if resolved not in seen:
            seen.add(resolved)
            unique_dirs.append(candidate)

    return max(unique_dirs, key=lambda item: item.stat().st_mtime)


@st.cache_resource(show_spinner=False)
def load_deberta_artifacts() -> Optional[Dict[str, Any]]:
    model_dir = find_deberta_model_dir()
    if model_dir is None:
        return None

    try:
        from transformers import AutoModelForSequenceClassification, DebertaV2Tokenizer

        tokenizer = DebertaV2Tokenizer.from_pretrained(model_dir)
        model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(DEVICE)
        model.eval()
        return {"tokenizer": tokenizer, "model": model, "model_dir": model_dir}
    except Exception:
        return None


@st.cache_data(show_spinner=False)
def clean_text(text: str) -> str:
    text = "" if text is None else str(text)
    text = text.replace("\n", " ").replace("\t", " ")
    text = re.sub(r"https?://\S+|www\.\S+", "[URL]", text)
    text = re.sub(r"\s+", " ", text).strip()
    return text


@st.cache_data(show_spinner=False)
def segment_text(text: str) -> str:
    text = "" if text is None else str(text)
    text = re.sub(r"\s+", " ", text.strip().lower())
    return ViTokenizer.tokenize(text)


@st.cache_data(show_spinner=False)
def tokenize_text(text: str):
    return str(text).split()


@st.cache_data(show_spinner=False)
def encode_text(text: str, vocab: Dict[str, int], max_len: int):
    tokens = tokenize_text(text)[:max_len]
    ids = [vocab.get(token, 1) for token in tokens]

    if len(ids) == 0:
        ids = [1]

    length = len(ids)
    if length < max_len:
        ids += [0] * (max_len - length)

    return ids, length


@torch.no_grad()
def predict_bilstm(text: str, artifacts: Dict[str, Any]):
    model = artifacts["model"]
    vocab = artifacts["vocab"]
    max_len = artifacts["max_len"]

    seg_text = segment_text(clean_text(text))
    input_ids, length = encode_text(seg_text, vocab, max_len)
    batch = {
        "input_ids": torch.tensor([input_ids], dtype=torch.long, device=DEVICE),
        "length": torch.tensor([length], dtype=torch.long, device=DEVICE),
    }
    logits = model(batch["input_ids"], batch["length"])
    probs = torch.softmax(logits, dim=1).squeeze(0).detach().cpu().numpy()
    pred_id = int(np.argmax(probs))
    return pred_id, probs


@torch.no_grad()
def predict_phobert(text: str, artifacts: Dict[str, Any]):
    tokenizer = artifacts["tokenizer"]
    model = artifacts["model"]

    seg_text = segment_text(clean_text(text))
    encoding = tokenizer(
        [seg_text],
        truncation=True,
        padding=True,
        max_length=128,
        return_tensors="pt",
    )
    encoding = {key: value.to(DEVICE) for key, value in encoding.items()}
    outputs = model(**encoding)
    logits = outputs.logits
    probs = torch.softmax(logits, dim=1).squeeze(0).detach().cpu().numpy()
    pred_id = int(np.argmax(probs))
    return pred_id, probs


@torch.no_grad()
def predict_deberta(text: str, artifacts: Dict[str, Any]):
    tokenizer = artifacts["tokenizer"]
    model = artifacts["model"]

    # DeBERTa uses teencode normalizer instead of ViTokenizer
    normalized_text = normalize_teencode(text)
    clean_t = clean_text(normalized_text)
    
    encoding = tokenizer(
        [clean_t],
        truncation=True,
        padding=False,
        max_length=256,
        return_tensors="pt",
    )
    encoding = {key: value.to(DEVICE) for key, value in encoding.items()}
    outputs = model(**encoding)
    logits = outputs.logits
    probs = torch.softmax(logits, dim=1).squeeze(0).detach().cpu().numpy()
    pred_id = int(np.argmax(probs))
    return pred_id, probs


@st.cache_resource(show_spinner=False)
def load_models():
    svm_vectorizer, svm_model = load_svm_artifacts()
    bilstm_artifacts = load_bilstm_artifacts()
    phobert_artifacts = load_phobert_artifacts()
    deberta_artifacts = load_deberta_artifacts()
    return {
        "svm": (svm_vectorizer, svm_model),
        "bilstm": bilstm_artifacts,
        "phobert": phobert_artifacts,
        "deberta": deberta_artifacts,
    }


def predict_svm(text: str, artifacts: Tuple[Any, Any]):
    vectorizer, model = artifacts
    cleaned = clean_text(text)
    features = vectorizer.transform([cleaned])
    pred_id = int(model.predict(features)[0])

    if hasattr(model, "predict_proba"):
        probs = model.predict_proba(features)[0]
    elif hasattr(model, "decision_function"):
        scores = model.decision_function(features)
        if np.ndim(scores) == 1:
            scores = np.column_stack([-scores, scores])
        probs = torch.softmax(torch.tensor(scores, dtype=torch.float32), dim=1).squeeze(0).detach().cpu().numpy()
    else:
        probs = None

    return pred_id, probs


def top2_labels(probs: Optional[np.ndarray]) -> str:
    if probs is None:
        return "Top 2: N/A"

    probs = np.asarray(probs, dtype=float)
    if probs.size == 0:
        return "Top 2: N/A"

    order = probs.argsort()[::-1][:2]
    parts = [f"{LABEL_MAP.get(int(index), 'Unknown')} {probs[int(index)]:.1%}" for index in order]
    return f"Top 2: {' | '.join(parts)}"


def _safe_label_id(label_id: Optional[int]) -> Optional[int]:
    if label_id is None:
        return None
    try:
        label_id = int(label_id)
    except Exception:
        return None
    return label_id if label_id in LABEL_MAP else None


def _format_confidence(conf: Optional[float]) -> str:
    if conf is None:
        return "N/A"
    try:
        return f"{float(conf) * 100:.1f}%"
    except Exception:
        return "N/A"


def confidence_from_probs(pred_id: Optional[int], probs: Optional[np.ndarray]) -> Optional[float]:
    safe_id = _safe_label_id(pred_id)
    if safe_id is None or probs is None:
        return None
    try:
        probs = np.asarray(probs, dtype=float)
        if probs.size == 0:
            return None
        return float(probs[safe_id])
    except Exception:
        return None


def majority_vote(pred_ids: list[int]) -> int:
    valid = [pred for pred in pred_ids if pred in LABEL_MAP]
    if not valid:
        return 0
    return Counter(valid).most_common(1)[0][0]


def consensus_status(pred_ids: list[int]) -> bool:
    valid = [pred for pred in pred_ids if pred in LABEL_MAP]
    if len(valid) <= 1:
        return True
    return len(set(valid)) == 1


def render_model_card(model_name: str, label_id: Optional[int], confidence: Optional[float], *, available: bool):
    safe_id = _safe_label_id(label_id)
    if not available:
        label_code = "-"
        label_primary = "KHÔNG KHẢ DỤNG"
    elif safe_id is None:
        label_code = "-"
        label_primary = "CHƯA DỰ ĐOÁN"
    else:
        label_code = LABEL_MAP[safe_id]
        label_primary = label_code

    bg = "#f1f5f9" if safe_id is None else LABEL_BG[safe_id]
    border = "#94a3b8" if safe_id is None else LABEL_COLOR[safe_id]
    text = "#0f172a" if safe_id is None else LABEL_TEXT[safe_id]

    conf_text = _format_confidence(confidence) if available and safe_id is not None else "N/A"

    st.markdown(
        f"""
        <div class="model-card" style="background: {bg}; border: 1px solid rgba(148,163,184,0.35);">
            <div class="model-card__head">
                <div class="model-card__name">{model_name}</div>
                <div class="model-card__status">{'Sẵn sàng' if available else 'Thiếu artifact'}</div>
            </div>
            <div class="model-card__label" style="color: {text};">{label_primary}</div>
            <div class="model-card__meta">
                <span class="pill" style="border-color:{border}; color:{border};">{label_code}</span>
                <span class="confidence">Độ tin cậy: <b>{conf_text}</b></span>
            </div>
        </div>
        """,
        unsafe_allow_html=True,
    )


def render_final_conclusion(label_id: int, confidence: Optional[float] = None, note: Optional[str] = None):
    safe_id = _safe_label_id(label_id) or 0
    bg = LABEL_BG[safe_id]
    border = LABEL_COLOR[safe_id]
    text = LABEL_TEXT[safe_id]
    conf_text = _format_confidence(confidence)
    note_html = "" if not note else f"<div class='final-note'>{note}</div>"

    st.markdown(
        f"""
        <div class="final-card" style="background:{bg}; border: 1px solid rgba(148,163,184,0.35);">
            <div class="final-card__head">
                <div class="final-card__title">Kết luận cuối</div>
                <span class="pill" style="background:{border}; color:white; border-color:{border};">{LABEL_MAP[safe_id]}</span>
            </div>
            <div class="final-card__label" style="color:{text};">{LABEL_MAP[safe_id]}</div>
            <div class="final-card__meta">Độ tin cậy (tham khảo): <b>{conf_text}</b></div>
            {note_html}
        </div>
        """,
        unsafe_allow_html=True,
    )


def inject_ui_css():
    st.markdown(
        """
        <style>
        .stApp {
            background: linear-gradient(180deg, #f8fafc 0%, #eef2ff 100%);
        }
        .block-container {
            padding-top: 1.2rem;
            padding-bottom: 2.2rem;
        }

        section[data-testid="stSidebar"] .block-container {
            padding-top: 1.2rem;
        }
        .sidebar-card {
            padding: 0.9rem 0.95rem;
            border-radius: 18px;
            background: rgba(255, 255, 255, 0.9);
            border: 1px solid rgba(148, 163, 184, 0.25);
        }
        .status-row {
            display: flex;
            justify-content: space-between;
            gap: 0.6rem;
            margin: 0.3rem 0;
            font-size: 0.92rem;
            color: #0f172a;
        }
        .status-row span {
            color: #475569;
        }

        .hero {
            padding: 1.15rem 1.25rem;
            border-radius: 22px;
            background: rgba(255, 255, 255, 0.92);
            border: 1px solid rgba(148, 163, 184, 0.25);
            box-shadow: 0 18px 40px rgba(15, 23, 42, 0.08);
            margin-bottom: 1rem;
        }
        .hero h1 {
            margin: 0;
            font-size: 1.85rem;
            color: #0f172a;
        }
        .hero p {
            margin: 0.4rem 0 0 0;
            color: #475569;
            font-size: 1rem;
            line-height: 1.55;
        }

        .model-card {
            padding: 1.0rem 1.05rem;
            border-radius: 18px;
            box-shadow: 0 10px 26px rgba(15, 23, 42, 0.06);
            min-height: 140px;
        }
        .model-card__head {
            display: flex;
            justify-content: space-between;
            align-items: baseline;
            gap: 0.8rem;
            margin-bottom: 0.55rem;
        }
        .model-card__name {
            font-size: 0.95rem;
            font-weight: 800;
            color: #0f172a;
            letter-spacing: 0.02em;
        }
        .model-card__status {
            font-size: 0.82rem;
            color: #64748b;
        }
        .model-card__label {
            font-size: 1.25rem;
            font-weight: 900;
            margin-bottom: 0.55rem;
        }
        .model-card__meta {
            display: flex;
            justify-content: space-between;
            align-items: center;
            gap: 0.8rem;
            flex-wrap: wrap;
        }
        .pill {
            display: inline-flex;
            align-items: center;
            border: 1px solid rgba(148, 163, 184, 0.35);
            border-radius: 999px;
            padding: 0.18rem 0.55rem;
            font-weight: 800;
            font-size: 0.82rem;
            background: rgba(255, 255, 255, 0.5);
        }
        .confidence {
            color: #0f172a;
            font-size: 0.9rem;
        }

        .final-card {
            padding: 1.15rem 1.2rem;
            border-radius: 20px;
            box-shadow: 0 16px 34px rgba(15, 23, 42, 0.09);
        }
        .final-card__head {
            display: flex;
            justify-content: space-between;
            align-items: center;
            gap: 0.8rem;
            margin-bottom: 0.45rem;
        }
        .final-card__title {
            font-size: 1.0rem;
            font-weight: 900;
            color: #0f172a;
        }
        .final-card__label {
            font-size: 1.55rem;
            font-weight: 950;
            margin-bottom: 0.25rem;
        }
        .final-card__meta {
            color: #334155;
            font-size: 0.95rem;
        }
        .final-note {
            margin-top: 0.6rem;
            color: #475569;
            font-size: 0.92rem;
            line-height: 1.55;
        }

        div[data-testid="stTextArea"] textarea {
            border-radius: 16px;
        }

        button[data-testid="baseButton-primary"] {
            border-radius: 14px !important;
            padding: 0.55rem 1rem !important;
            border: 1px solid rgba(59, 130, 246, 0.35) !important;
            background: linear-gradient(90deg, #2563eb 0%, #4f46e5 100%) !important;
            color: white !important;
            font-weight: 800 !important;
        }
        button[data-testid="baseButton-secondary"] {
            border-radius: 14px !important;
        }
        </style>
        """,
        unsafe_allow_html=True,
    )


inject_ui_css()

st.markdown(
    """
    <div class="hero">
        <h1>Phân loại bình luận độc hại tiếng Việt</h1>
        <p>Nhập một bình luận bất kỳ và so sánh dự đoán từ các mô hình: TF‑IDF + SVM, BiLSTM, PhoBERT và DeBERTa.</p>
    </div>
    """,
    unsafe_allow_html=True,
)

models = None
with st.spinner("Đang tải mô hình đã lưu..."):
    try:
        models = load_models()
    except Exception as exc:
        st.error(f"Không thể tải model: {exc}")
        st.stop()

svm_available = (MODEL_DIR / "tfidf_vectorizer.joblib").exists() and (MODEL_DIR / "svm_model.joblib").exists()
bilstm_available = models["bilstm"] is not None
phobert_available = models["phobert"] is not None
deberta_available = models["deberta"] is not None

with st.sidebar:
    st.markdown("### Demo")
    st.markdown(
        f"""
        <div class="sidebar-card">
            <div class="status-row"><b>Thiết bị</b><span>{DEVICE}</span></div>
            <div class="status-row"><b>SVM</b><span>{'Sẵn sàng' if svm_available else 'Thiếu artifact'}</span></div>
            <div class="status-row"><b>BiLSTM</b><span>{'Sẵn sàng' if bilstm_available else 'Thiếu artifact'}</span></div>
            <div class="status-row"><b>PhoBERT</b><span>{'Sẵn sàng' if phobert_available else 'Thiếu artifact'}</span></div>
            <div class="status-row"><b>DeBERTa</b><span>{'Sẵn sàng' if deberta_available else 'Thiếu artifact'}</span></div>
        </div>
        """,
        unsafe_allow_html=True,
    )

    st.markdown("\n")
    with st.expander("Văn bản mẫu", expanded=True):
        if "input_text" not in st.session_state:
            st.session_state["input_text"] = ""

        for label, sample_text in SAMPLES.items():
            if st.button(label, use_container_width=True):
                st.session_state["input_text"] = sample_text

left_col, right_col = st.columns([0.93, 1.47], gap="large")

with left_col:
    st.markdown("### Nhập nội dung")
    input_text = st.text_area(
        "Nội dung bình luận",
        key="input_text",
        height=220,
        placeholder="Nhập một câu bình luận tiếng Việt ở đây...",
        label_visibility="collapsed",
    )

    action_col, helper_col = st.columns([0.33, 0.67], gap="medium")
    with action_col:
        predict_clicked = st.button("Dự đoán", use_container_width=True, type="primary")
    with helper_col:
        if st.button("Xóa nội dung", use_container_width=True):
            st.session_state["input_text"] = ""
            st.session_state.pop("last_results", None)
            st.session_state.pop("last_vote", None)
            st.rerun()

    cleaned_preview = clean_text(input_text)
    segmented_preview = segment_text(cleaned_preview)

    with st.expander("Tiền xử lý đầu vào", expanded=False):
        st.markdown("**Văn bản sau chuẩn hóa**")
        st.code(cleaned_preview or "(trống)")
        st.markdown("**Văn bản sau tách từ**")
        st.code(segmented_preview or "(trống)")

with right_col:
    st.markdown("### Kết quả dự đoán")

    if "last_results" not in st.session_state:
        st.session_state["last_results"] = None
    if "last_vote" not in st.session_state:
        st.session_state["last_vote"] = None

    if predict_clicked and input_text.strip():
        results: Dict[str, Dict[str, Any]] = {
            "svm": {"name": "TF‑IDF + SVM", "available": svm_available, "pred": None, "probs": None},
            "bilstm": {"name": "BiLSTM", "available": bilstm_available, "pred": None, "probs": None},
            "phobert": {"name": "PhoBERT", "available": phobert_available, "pred": None, "probs": None},
            "deberta": {"name": "DeBERTa", "available": deberta_available, "pred": None, "probs": None},
        }

        if svm_available:
            pred, probs = predict_svm(input_text, models["svm"])
            results["svm"].update({"pred": pred, "probs": probs})

        if bilstm_available:
            pred, probs = predict_bilstm(input_text, models["bilstm"])
            results["bilstm"].update({"pred": pred, "probs": probs})

        if phobert_available:
            pred, probs = predict_phobert(input_text, models["phobert"])
            results["phobert"].update({"pred": pred, "probs": probs})
            
        if deberta_available:
            pred, probs = predict_deberta(input_text, models["deberta"])
            results["deberta"].update({"pred": pred, "probs": probs})

        preds_for_vote = [
            results["svm"]["pred"],
            results["bilstm"]["pred"],
            results["phobert"]["pred"],
            results["deberta"]["pred"],
        ]
        preds_for_vote = [p for p in preds_for_vote if p is not None]
        vote = majority_vote([int(p) for p in preds_for_vote]) if preds_for_vote else 0

        st.session_state["last_results"] = results
        st.session_state["last_vote"] = vote

    results = st.session_state.get("last_results")
    vote = st.session_state.get("last_vote")

    cards = st.columns(4, gap="large")
    if results is None:
        with cards[0]:
            render_model_card("TF‑IDF + SVM", None, None, available=svm_available)
        with cards[1]:
            render_model_card("BiLSTM", None, None, available=bilstm_available)
        with cards[2]:
            render_model_card("PhoBERT", None, None, available=phobert_available)
        with cards[3]:
            render_model_card("DeBERTa", None, None, available=deberta_available)
        st.info("Nhập một bình luận và bấm **Dự đoán** để xem kết quả.")
    else:
        svm_pred = results["svm"]["pred"]
        bilstm_pred = results["bilstm"]["pred"]
        phobert_pred = results["phobert"]["pred"]
        deberta_pred = results["deberta"]["pred"]

        svm_conf = confidence_from_probs(svm_pred, results["svm"]["probs"])
        bilstm_conf = confidence_from_probs(bilstm_pred, results["bilstm"]["probs"])
        phobert_conf = confidence_from_probs(phobert_pred, results["phobert"]["probs"])
        deberta_conf = confidence_from_probs(deberta_pred, results["deberta"]["probs"])

        with cards[0]:
            render_model_card("TF‑IDF + SVM", svm_pred, svm_conf, available=bool(results["svm"]["available"]))
        with cards[1]:
            render_model_card("BiLSTM", bilstm_pred, bilstm_conf, available=bool(results["bilstm"]["available"]))
        with cards[2]:
            render_model_card("PhoBERT", phobert_pred, phobert_conf, available=bool(results["phobert"]["available"]))
        with cards[3]:
            render_model_card("DeBERTa", deberta_pred, deberta_conf, available=bool(results["deberta"]["available"]))

        st.caption("Diễn giải nhãn: CLEAN = Bình thường · OFFENSIVE = Công kích · HATE = Thù ghét")

        pred_ids = [
            int(svm_pred) if svm_pred is not None else -1,
            int(bilstm_pred) if bilstm_pred is not None else -1,
            int(phobert_pred) if phobert_pred is not None else -1,
            int(deberta_pred) if deberta_pred is not None else -1,
        ]
        is_consensus = consensus_status(pred_ids)

        st.markdown("\n")
        if not is_consensus:
            st.warning("Đây là trường hợp khó, các mô hình đưa ra dự đoán khác nhau.")

        st.markdown("\n")
        note = "Theo nguyên tắc đa số phiếu từ các mô hình khả dụng." if vote is not None else None
        final_label = int(vote or 0)
        final_conf_candidates: list[float] = []
        for pred, conf in (
            (svm_pred, svm_conf),
            (bilstm_pred, bilstm_conf),
            (phobert_pred, phobert_conf),
            (deberta_pred, deberta_conf),
        ):
            if pred is None or conf is None:
                continue
            try:
                if int(pred) == final_label:
                    final_conf_candidates.append(float(conf))
            except Exception:
                continue

        final_conf = float(np.mean(final_conf_candidates)) if final_conf_candidates else None
        render_final_conclusion(final_label, final_conf, note)

        st.caption("Độ tin cậy là xác suất lớp dự đoán (nếu mô hình có cung cấp).")