Upload app.py

app.py

@@ -5,7 +5,6 @@ import numpy as np
 import re
 import os
 import uuid
-from io import BytesIO
 from typing import List, Dict, Tuple, Optional
 try:
     from rapidfuzz import process as rf_process
@@ -16,15 +15,13 @@ except Exception:
 APP_TITLE = "Ward Ranking Random Assigner"
 DESCRIPTION = """
 **Flow**
-1) อัปโหลดไฟล์ .csv/.xlsx  
-2) เลือกวอร์ดที่ใช้ + ใส่ capacity  
-3) ตรวจหัวคอลัมน์ที่อ่านได้ (Available columns)  
-4) **เลือกวิธี mapping**: 
-   - Auto-detect (คำไทย/อังกฤษ + fuzzy) → ระบบเติมให้อัตโนมัติ
-   - หรือกรอก **หมายเลขคอลัมน์** ตามรายการ Available columns (เลขเริ่ม 1)
-5) Clean → เหลือเฉพาะ NAME, ID, และคอลัมน์วอร์ดที่เลือก (ค่าจัดอันดับถูกแปลงเป็นตัวเลข)
-6) Assign → สุ่มตามลำดับอันดับ โดยเคารพ capacity
-   - **จะตรวจว่าจำนวนนักศึกษา <= ผลรวม capacity** (ขาดได้แต่ห้ามเกิน)
+1) Upload .csv/.xlsx  
+2) Choose wards + set capacity  
+3) Check Available columns  
+4) Map by Auto-detect (Thai/English + fuzzy) or by numbers (1-based)  
+5) Clean → keep NAME/ID + selected wards; convert ranks to integers  
+6) Assign → round-by-rank with random tie-breaking; respect capacity  
+   - Check: #students <= total capacity (shortage allowed, not exceed)
 """
 
 WARD_CHOICES = [
@@ -38,14 +35,30 @@ WARD_CHOICES = [
     ("Obstetrics", "สูติศาสตร์"),
 ]
 
+# ===== Display labels (English-first with Thai in parentheses) =====
+WARD_LABELS = {
+    "Medical": ("Internal Medicine", "อายุรศาสตร์"),
+    "Medical_1": ("Internal Medicine 1", "อายุรศาสตร์_1"),
+    "Medical_2": ("Internal Medicine 2", "อายุรศาสตร์_2"),
+    "Surgical": ("Surgery", "ศัลยศาสตร์"),
+    "Pediatric": ("Pediatrics", "เด็ก"),
+    "Community": ("Community Health", "ชุมชน"),
+    "Psychiatric": ("Psychiatry", "จิตเวช"),
+    "Obstetrics": ("Obstetrics", "สูติศาสตร์"),
+}
+
+def ward_display(ward_key: str) -> str:
+    en, th = WARD_LABELS.get(ward_key, (ward_key, ward_key))
+    return f"{en} ({th})"
+
 # Keyword dictionary for auto mapping
 AUTO_MAP = {
     "NAME": ["ชื่อ-สกุล", "ชื่อ - สกุล", "fullname", "full name", "name", "student name"],
     "ID": ["รหัสนักศึกษา", "รหัส", "student id", "id", "studentid"],
     "Medical": ["อายุรศาสตร์", "medical"],
-    "Medical_1": ["อายุรศาสตร์_1", "medical_1", "med_1","med1"],
+    "Medical_1": ["อายุรศาสตร์_1", "medical_1", "med_1", "med1"],
     "Medical_2": ["อายุรศาสตร์_2", "medical_2", "med_2", "med2"],
-    "Surgical": ["ศัลยศาสตร์", "surgical", "surgery","surg"],
+    "Surgical": ["ศัลยศาสตร์", "surgical", "surgery", "surg"],
     "Pediatric": ["เด็ก", "pediatric", "pediatrics"],
     "Community": ["ชุมชน", "community"],
     "Psychiatric": ["จิตเวช", "psychiatric"],
@@ -54,7 +67,7 @@ AUTO_MAP = {
 
 def read_table(file) -> Tuple[Optional[pd.DataFrame], str]:
     if file is None:
-        return None, "กรุณาอัปโหลดไฟล์ก่อน (.csv หรือ .xlsx)"
+        return None, "Please upload a file (.csv or .xlsx)"
     name = file.name.lower() if hasattr(file, "name") else ""
     try:
         if name.endswith(".csv"):
@@ -62,13 +75,12 @@ def read_table(file) -> Tuple[Optional[pd.DataFrame], str]:
         elif name.endswith(".xlsx"):
             df = pd.read_excel(file.name if hasattr(file, "name") else file)
         else:
-            # ลองเดาว่าเป็น csv
             try:
                 df = pd.read_csv(file)
             except Exception:
-                return None, "รองรับเฉพาะ .csv หรือ .xlsx เท่านั้น"
+                return None, "Only .csv or .xlsx are supported"
     except Exception as e:
-        return None, f"อ่านไฟล์ไม่สำเร็จ: {e}"
+        return None, f"Failed to read file: {e}"
     df.columns = [str(c).strip() for c in df.columns]
     return df, ""
 
@@ -91,8 +103,6 @@ def parse_rank(value) -> Optional[int]:
     return None
 
 def auto_map_columns(df: pd.DataFrame, selected_wards: List[str]) -> Dict[str, int]:
-    """Return mapping as index (1-based) for NAME, ID, and selected ward columns.
-       Use keyword dictionary and fuzzy fallback (if available)."""
     cols = list(df.columns)
     col_lower = [c.lower() for c in cols]
     result: Dict[str, int] = {}
@@ -100,11 +110,9 @@ def auto_map_columns(df: pd.DataFrame, selected_wards: List[str]) -> Dict[str, i
     def find_by_keywords(keywords: List[str]) -> Optional[int]:
         for kw in keywords:
             kw_low = kw.lower()
-            # contains search
             for idx, c_low in enumerate(col_lower):
                 if kw_low in c_low:
-                    return idx + 1  # 1-based
-        # fuzzy fallback
+                    return idx + 1
         if HAS_FUZZ:
             best_idx = None
             best_score = -1
@@ -120,28 +128,19 @@ def auto_map_columns(df: pd.DataFrame, selected_wards: List[str]) -> Dict[str, i
                 return best_idx
         return None
 
-    # NAME / ID
     n_idx = find_by_keywords(AUTO_MAP["NAME"])
     if n_idx: result["NAME"] = n_idx
     i_idx = find_by_keywords(AUTO_MAP["ID"])
     if i_idx: result["ID"] = i_idx
-
-    # wards
     for w in selected_wards:
         kws = AUTO_MAP.get(w, [w])
         w_idx = find_by_keywords(kws)
         if w_idx:
             result[w] = w_idx
-
     return result
 
 def build_cleaned_from_indices(df: pd.DataFrame,
                                mapping_indices: Dict[str, int]) -> pd.DataFrame:
-    """
-    mapping_indices: {Field -> 1-based column index in df}
-    Keep only NAME, ID, and ward columns. Convert ward values to Int (ranks).
-    """
-    # Resolve names
     def idx_to_name(k: str) -> str:
         idx = mapping_indices.get(k, None)
         if idx is None: return ""
@@ -154,11 +153,9 @@ def build_cleaned_from_indices(df: pd.DataFrame,
         missing = []
         if not name_col: missing.append("NAME")
         if not id_col: missing.append("ID")
-        raise ValueError(f"หาไม่พบคอลัมน์บังคับ: {', '.join(missing)}")
+        raise ValueError(f"Missing required columns: {', '.join(missing)}")
 
-    # collect ward columns
-    ward_cols_src = []
-    ward_cols_dst = []
+    ward_cols_src, ward_cols_dst = [], []
     for w, _th in WARD_CHOICES:
         if w in mapping_indices:
             c = idx_to_name(w)
@@ -172,31 +169,28 @@ def build_cleaned_from_indices(df: pd.DataFrame,
     rename_map.update({src: dst for src, dst in zip(ward_cols_src, ward_cols_dst)})
     cleaned = cleaned.rename(columns=rename_map)
 
-    # parse ranks
     for c in cleaned.columns:
         if c not in ("NAME", "ID"):
             cleaned[c] = cleaned[c].apply(parse_rank).astype("Int64")
-    # order
     ordered = ["NAME", "ID"] + [c for c in cleaned.columns if c not in ("NAME", "ID")]
     cleaned = cleaned[ordered]
     return cleaned
 
 def random_assign(cleaned: pd.DataFrame,
                   capacities: Dict[str, int]) -> Tuple[pd.DataFrame, pd.DataFrame, Dict[str, int]]:
-    """Assign by rank rounds; tie-break with numpy's global RNG (np.random.choice)."""
     wards = [w for w in cleaned.columns if w not in ("NAME", "ID")]
     cap = {w: int(capacities.get(w, 0)) for w in wards}
 
     assigned = pd.Series(index=cleaned.index, data=pd.NA, dtype="object")
     choice_no = pd.Series(index=cleaned.index, data=pd.NA, dtype="Int64")
 
-    max_rank = 0
+    mr = 0
     for w in wards:
         m = cleaned[w].max(skipna=True)
         if pd.notna(m):
-            max_rank = max(max_rank, int(m))
+            mr = max(mr, int(m))
 
-    for r in range(1, max_rank + 1):
+    for r in range(1, mr + 1):
         if all(c <= 0 for c in cap.values()):
             break
         for w in wards:
@@ -221,13 +215,114 @@ def random_assign(cleaned: pd.DataFrame,
     not_assigned = result[result["AssignedWard"].isna()].copy()
     return result.fillna(""), not_assigned.fillna(""), cap
 
+# ===== Reporting helpers =====
+def ward_display(ward_key: str) -> str:
+    en, th = WARD_LABELS.get(ward_key, (ward_key, ward_key))
+    return f"{en} ({th})"
+
+def max_rank_in(cleaned: pd.DataFrame) -> int:
+    wards = [w for w in cleaned.columns if w not in ("NAME", "ID")]
+    mr = 0
+    for w in wards:
+        m = cleaned[w].max(skipna=True)
+        if pd.notna(m):
+            mr = max(mr, int(m))
+    return int(mr)
+
+def make_rank1_report(cleaned: pd.DataFrame, capacities: Dict[str, int]) -> str:
+    wards = [w for w in cleaned.columns if w not in ("NAME", "ID")]
+    total_students = len(cleaned)
+    total_capacity = sum(int(capacities.get(w, 0)) for w in wards)
+    lines = []
+    lines.append("## Rank 1 Results (การแสดงผลอันดับที่ 1)")
+    lines.append("")
+    lines.append(f"- **Total Students (จำนวนนักศึกษาทั้งหมด):** {total_students} students (คน)")
+    lines.append(f"- **Total Capacity (ความจุรวม):** {total_capacity} people (คน)")
+    lines.append("")
+    header = "| Ward (วอร์ด) | Capacity (ความจุ) | Rank 1 Count (จำนวนเลือกอันดับ 1) | Students (รายชื่อนักศึกษา) |"
+    sep = "|---|---:|---:|---|"
+    lines += [header, sep]
+    over = []
+    under = []
+    for w in wards:
+        cap = int(capacities.get(w, 0))
+        rank1_students = cleaned.loc[cleaned[w] == 1, "NAME"].astype(str).tolist()
+        r1_count = len(rank1_students)
+        display_students = ", ".join(rank1_students[:3]) + ("..." if r1_count > 3 else "")
+        lines.append(f"| {ward_display(w)} | {cap} | {r1_count} | {display_students} |")
+        if r1_count > cap:
+            over.append((w, r1_count, cap))
+        elif r1_count < cap:
+            under.append((w, r1_count, cap))
+    lines.append("")
+    lines.append("### Additional Statistics (สถิติเพิ่มเติม)")
+    lines.append("")
+    if over:
+        lines.append("**Wards where Rank 1 count exceeds capacity (วอร์ดที่มีคนเลือกอันดับ 1 เกินความจุ):**")
+        for w, c, cap in over:
+            lines.append(f"- {ward_display(w)}: {c} selected (capacity {cap})")
+    else:
+        lines.append("- No wards exceed capacity at Rank 1. (ไม่มีวอร์ดใดเกินความจุในอันดับ 1)")
+    if under:
+        lines.append("")
+        lines.append("**Wards where Rank 1 count below capacity (วอร์ดที่มีคนเลือกอันดับ 1 น้อยกว่าความจุ):**")
+        for w, c, cap in under:
+            lines.append(f"- {ward_display(w)}: {c} selected (capacity {cap})")
+    return "\n".join(lines)
+
+def make_rank_report(cleaned: pd.DataFrame, capacities: Dict[str, int], rank: int) -> str:
+    wards = [w for w in cleaned.columns if w not in ("NAME", "ID")]
+    lines = []
+    lines.append(f"## Rank {rank} Results (การแสดงผลอันดับที่ {rank})")
+    total_students = len(cleaned)
+    total_capacity = sum(int(capacities.get(w, 0)) for w in wards)
+    lines.append(f"- **Total Students (จำนวนนักศึกษาทั้งหมด):** {total_students} students (คน)")
+    lines.append(f"- **Total Capacity (ความจุรวม):** {total_capacity} people (คน)")
+    lines.append("")
+    header = "| Ward (วอร์ด) | Capacity (ความจุ) | Rank {rank} Count (จำนวนเลือกอันดับ {rank}) | Students (รายชื่อนักศึกษา) |".format(rank=rank)
+    sep = "|---|---:|---:|---|"
+    lines += [header, sep]
+    over, under = [], []
+    for w in wards:
+        cap = int(capacities.get(w, 0))
+        names = cleaned.loc[cleaned[w] == rank, "NAME"].astype(str).tolist()
+        cnt = len(names)
+        sample = ", ".join(names[:3]) + ("..." if cnt > 3 else "")
+        lines.append(f"| {ward_display(w)} | {cap} | {cnt} | {sample} |")
+        if cnt > cap:
+            over.append((w, cnt, cap))
+        elif cnt < cap:
+            under.append((w, cnt, cap))
+    lines.append("")
+    lines.append("**Additional Statistics (สถิติเพิ่มเติม):**")
+    if over:
+        lines.append("- Wards where count exceeds capacity (เกินความจุ):")
+        for w, c, cap in over:
+            lines.append(f"  - {ward_display(w)}: {c} selected (capacity {cap})")
+    else:
+        lines.append("- No wards exceed capacity at this rank. (ไม่มีวอร์ดเกินความจุในอันดับนี้)")
+    if under:
+        lines.append("- Wards where count below capacity (ต่ำกว่าความจุ):")
+        for w, c, cap in under:
+            lines.append(f"  - {ward_display(w)}: {c} selected (capacity {cap})")
+    return "\n".join(lines)
+
+def make_all_ranks_report(cleaned: pd.DataFrame, capacities: Dict[str, int]) -> str:
+    mr = max_rank_in(cleaned)
+    if mr == 0:
+        return "No ranking numbers found. (ไม่พบข้อมูลอันดับเป็นตัวเลข)"
+    parts = []
+    for r in range(1, mr + 1):
+        parts.append(make_rank_report(cleaned, capacities, r))
+        parts.append("\n---\n")
+    return "\n".join(parts)
+
 # ===== Helpers for temp file paths =====
 def _tmp(name: str) -> str:
     os.makedirs("/tmp", exist_ok=True)
     return f"/tmp/{uuid.uuid4().hex}-{name}"
 
 # ===== Gradio callbacks =====
-
 def update_capacity_table(selected_wards: List[str]) -> pd.DataFrame:
     rows = []
     for w, th in WARD_CHOICES:
@@ -238,13 +333,9 @@ def update_capacity_table(selected_wards: List[str]) -> pd.DataFrame:
 def on_upload(file, selected_wards):
     df, msg = read_table(file)
     if df is None:
-        # return flat outputs for all mapping fields
         return gr.update(value=msg, visible=True), "", None, None, None, None, None, None, None, None, None, None
-    # Show available columns
     avail = available_columns_text(df)
-    # Auto-detect mapping (indices)
     auto_idx = auto_map_columns(df, selected_wards or [])
-    # Prepare number inputs defaults
     def idx_or_none(key):
         return int(auto_idx[key]) if key in auto_idx else None
     name_num = idx_or_none("NAME")
@@ -257,24 +348,23 @@ def on_upload(file, selected_wards):
     comm_num = idx_or_none("Community")
     psy_num = idx_or_none("Psychiatric")
     obs_num = idx_or_none("Obstetrics")
-    return (gr.update(value="✓ อ่านไฟล์สำเร็จ", visible=True), avail, name_num, id_num,
+    return (gr.update(value="✓ File loaded", visible=True), avail, name_num, id_num,
             med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num)
 
 def collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols):
-    """Validate numeric mapping and build mapping dict {Field: index}"""
     errors = []
     mapping = {}
     def valid(num, label):
         if num is None:
-            errors.append(f"- กรุณาใส่หมายเลขของ {label}")
+            errors.append(f"- Please enter column number for {label}")
             return None
         try:
             num = int(num)
         except Exception:
-            errors.append(f"- {label} ต้องเป็นตัวเลข")
+            errors.append(f"- {label} must be a number")
             return None
         if not (1 <= num <= n_cols):
-            errors.append(f"- {label} ต้องอยู่ระหว่าง 1–{n_cols}")
+            errors.append(f"- {label} must be within 1–{n_cols}")
             return None
         return num
 
@@ -293,7 +383,7 @@ def collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols)
 def on_clean(file, selected_wards, capacity_df, name_num, id_num, 
              med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num):
     if not selected_wards:
-        return gr.update(value="กรุณาเลือกวอร์ดอย่างน้อย 1", visible=True), None, None, None
+        return gr.update(value="Please select at least one ward.", visible=True), None, None, None
 
     df, msg = read_table(file)
     if df is None:
@@ -307,29 +397,82 @@ def on_clean(file, selected_wards, capacity_df, name_num, id_num,
     }
     errors, mapping_idx = collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols)
     if errors:
-        return gr.update(value="❌ Mapping ไม่ครบ/ไม่ถูกต้อง:\n" + "\n".join(errors), visible=True), None, None, None
+        return gr.update(value="❌ Mapping invalid:\n" + "\n".join(errors), visible=True), None, None, None
 
     try:
         cleaned = build_cleaned_from_indices(df, mapping_idx)
     except Exception as e:
-        return gr.update(value=f"❌ เกิดข้อผิดพลาด: {e}", visible=True), None, None, None
+        return gr.update(value=f"❌ Error: {e}", visible=True), None, None, None
 
-    # Write to a unique temp file path
     cleaned_path = _tmp("cleaned.csv")
     cleaned.to_csv(cleaned_path, index=False, encoding="utf-8-sig")
 
-    info = "✓ Cleaning สำเร็จ"
+    info = "✓ Cleaning completed"
     return gr.update(value=info, visible=True), cleaned.head(30), cleaned_path, len(cleaned)
 
+def _capacities_from_df(cleaned: pd.DataFrame, capacity_df: Optional[pd.DataFrame]) -> Dict[str, int]:
+    if capacity_df is None or capacity_df.empty:
+        return {w: 0 for w in cleaned.columns if w not in ("NAME", "ID")}
+    cap_df = capacity_df.copy()
+    cap_df.columns = ["Ward", "Thai Name", "Capacity"]
+    cap_df = cap_df[cap_df["Ward"].isin([c for c in cleaned.columns if c not in ("NAME", "ID")])]
+    capacities = {}
+    for _, row in cap_df.iterrows():
+        try:
+            capacities[str(row["Ward"])] = int(row["Capacity"])
+        except Exception:
+            capacities[str(row["Ward"])] = 0
+    return capacities
+
+def on_rank1_report(file, selected_wards, capacity_df, name_num, id_num, 
+                    med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num):
+    df, msg = read_table(file)
+    if df is None:
+        return "Please upload a valid file."
+    n_cols = len(df.columns)
+    ward_nums = {
+        "Medical": med_num, "Medical_1": med1_num, "Medical_2": med2_num,
+        "Surgical": surg_num, "Pediatric": ped_num, "Community": comm_num,
+        "Psychiatric": psy_num, "Obstetrics": obs_num
+    }
+    errors, mapping_idx = collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols)
+    if errors:
+        return "❌ Mapping invalid:\n" + "\n".join(errors)
+    try:
+        cleaned = build_cleaned_from_indices(df, mapping_idx)
+    except Exception as e:
+        return f"❌ Error building cleaned data: {e}"
+    capacities = _capacities_from_df(cleaned, capacity_df)
+    return make_rank1_report(cleaned, capacities)
+
+def on_all_ranks_report(file, selected_wards, capacity_df, name_num, id_num, 
+                        med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num):
+    df, msg = read_table(file)
+    if df is None:
+        return "Please upload a valid file."
+    n_cols = len(df.columns)
+    ward_nums = {
+        "Medical": med_num, "Medical_1": med1_num, "Medical_2": med2_num,
+        "Surgical": surg_num, "Pediatric": ped_num, "Community": comm_num,
+        "Psychiatric": psy_num, "Obstetrics": obs_num
+    }
+    errors, mapping_idx = collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols)
+    if errors:
+        return "❌ Mapping invalid:\n" + "\n".join(errors)
+    try:
+        cleaned = build_cleaned_from_indices(df, mapping_idx)
+    except Exception as e:
+        return f"❌ Error building cleaned data: {e}"
+    capacities = _capacities_from_df(cleaned, capacity_df)
+    return make_all_ranks_report(cleaned, capacities)
+
 def on_assign(file, selected_wards, capacity_df, name_num, id_num,
               med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num):
-    # Clean first to get the cleaned df and student count
     status, cleaned_preview, cleaned_file, n_students = on_clean(file, selected_wards, capacity_df, name_num, id_num,
                                                                  med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num)
     if cleaned_preview is None:
-        return status, None, None, None, None
+        return status, None, None, None, None, None
 
-    # Recreate full cleaned df (not just head) for assignment
     df, _ = read_table(file)
     n_cols = len(df.columns)
     ward_nums = {
@@ -340,56 +483,43 @@ def on_assign(file, selected_wards, capacity_df, name_num, id_num,
     _errors, mapping_idx = collect_mapping_numbers(name_num, id_num, ward_nums, selected_wards, n_cols)
     cleaned = build_cleaned_from_indices(df, mapping_idx)
 
-    # Build capacity map
-    cap_df = capacity_df.copy()
-    if cap_df is None or cap_df.empty:
-        return gr.update(value="กรุณากรอก capacity ก่อน", visible=True), None, None, None, None
-    cap_df.columns = ["Ward", "Thai Name", "Capacity"]
-    cap_df = cap_df[cap_df["Ward"].isin([c for c in cleaned.columns if c not in ("NAME", "ID")])]
-    cap_map = {}
-    for _, row in cap_df.iterrows():
-        try:
-            cap_map[str(row["Ward"])] = int(row["Capacity"])
-        except Exception:
-            cap_map[str(row["Ward"])] = 0
+    capacities = _capacities_from_df(cleaned, capacity_df)
 
-    total_capacity = sum(cap_map.values())
-    # Pre-check: students must be <= total capacity (ขาดได้แต่ห้ามเกิน)
+    total_capacity = sum(capacities.values())
     if n_students is None:
         n_students = len(cleaned)
     if n_students > total_capacity:
-        msg = f"❌ จำนวนผู้สมัคร {n_students} คน มากกว่า capacity รวม {total_capacity} ที่กำหนด (ขาดได้แต่ห้ามเกิน)"
-        return gr.update(value=msg, visible=True), None, None, None, None
+        msg = f"❌ Students {n_students} > total capacity {total_capacity} (shortage allowed, not exceed)"
+        return gr.update(value=msg, visible=True), None, None, None, None, None
 
-    # Assign without seed; use np.random.choice
-    assigned, not_assigned, leftover = random_assign(cleaned, cap_map)
+    assigned, not_assigned, leftover = random_assign(cleaned, capacities)
 
-    # Write files to unique temp paths
     assigned_path = _tmp("assigned.csv")
     not_assigned_path = _tmp("not_assigned.csv")
     assigned.to_csv(assigned_path, index=False, encoding="utf-8-sig")
     not_assigned.to_csv(not_assigned_path, index=False, encoding="utf-8-sig")
 
-    leftover_text = "ความจุคงเหลือ:\n" + "\n".join([f"- {k}: {v}" for k, v in leftover.items()])
+    leftover_text = "Remaining capacity (จำนวนรับที่เหลือ):\n" + "\n".join([f"- {ward_display(k)}: {v}" for k, v in leftover.items()])
+    allocation = make_all_ranks_report(cleaned, capacities) + "\n\n---\n\n" + "## Allocation Summary (สรุปการจัดสรร)\n"  # Keep the all-ranks context too
 
-    return status, assigned.head(30), assigned_path, not_assigned_path, leftover_text
+    return status, assigned.head(30), assigned_path, not_assigned_path, leftover_text, allocation
 
 with gr.Blocks(title=APP_TITLE) as demo:
     gr.Markdown(f"# {APP_TITLE}")
     gr.Markdown(DESCRIPTION)
 
     with gr.Row():
-        file = gr.File(file_count="single", file_types=[".csv", ".xlsx"], label="อัปโหลดข้อมูล (.csv/.xlsx)")
+        file = gr.File(file_count="single", file_types=[".csv", ".xlsx"], label="Upload data (.csv/.xlsx)")
 
-    with gr.Accordion("1) เลือกวอร์ดที่ต้องใช้", open=True):
+    with gr.Accordion("1) Select wards (เลือกวอร์ด)", open=True):
         selected_wards = gr.CheckboxGroup(
             choices=[w for w, _ in WARD_CHOICES],
-            label="เลือกวอร์ด (เลือกได้หลายข้อ)",
+            label="Select wards (เลือกได้หลายข้อ)",
             value=["Medical", "Surgical", "Pediatric", "Community", "Psychiatric", "Obstetrics"]
         )
-        gr.Markdown("คำแปล: " + ", ".join([f"**{w}** = {th}" for w, th in WARD_CHOICES]))
+        gr.Markdown("Legend: " + ", ".join([f"**{w}** = {ward_display(w)}" for w, _ in WARD_CHOICES]))
 
-    with gr.Accordion("2) กำหนด Capacity ต่อวอร์ด", open=True):
+    with gr.Accordion("2) Set capacity per ward (กำหนดความจุต่อวอร์ด)", open=True):
         capacity_df = gr.Dataframe(
             headers=["Ward", "Thai Name", "Capacity"],
             value=[],
@@ -397,38 +527,56 @@ with gr.Blocks(title=APP_TITLE) as demo:
             col_count=3,
             interactive=True,
             wrap=True,
-            label="กรอกเฉพาะแถวของวอร์ดที่เลือก"
+            label="Fill only selected wards"
         )
         selected_wards.change(fn=update_capacity_table, inputs=selected_wards, outputs=capacity_df)
 
-    with gr.Accordion("3) ตรวจหัวคอลัมน์ & เลือก mapping (Auto/ตัวเลข)", open=True):
+    with gr.Accordion("3) Column headers & mapping (หัวคอลัมน์และการจับคู่)", open=True):
         status = gr.Markdown(visible=False)
-        available = gr.Code(label="Available columns (เลขเริ่มที่ 1)", language="markdown", interactive=False)
-        auto_btn = gr.Button("อ่านไฟล์ & Auto-detect mapping")
-        # numeric mapping inputs
-        name_num = gr.Number(label="หมายเลขคอลัมน์สำหรับ NAME", precision=0)
-        id_num = gr.Number(label="หมายเลขคอลัมน์สำหรับ ID", precision=0)
+        available = gr.Code(label="Available columns (index starts at 1)", language="markdown", interactive=False)
+        auto_btn = gr.Button("Read & Auto-detect mapping (อ่านไฟล์ & เดา mapping)")
+        name_num = gr.Number(label="Column number for NAME", precision=0)
+        id_num = gr.Number(label="Column number for ID", precision=0)
         with gr.Row():
-            med_num = gr.Number(label="หมายเลขคอลัมน์ Medical", precision=0)
-            med1_num = gr.Number(label="หมายเลขคอลัมน์ Medical_1", precision=0)
-            med2_num = gr.Number(label="หมายเลขคอลัมน์ Medical_2", precision=0)
+            med_num = gr.Number(label="Column number Medical", precision=0)
+            med1_num = gr.Number(label="Column number Medical_1", precision=0)
+            med2_num = gr.Number(label="Column number Medical_2", precision=0)
         with gr.Row():
-            surg_num = gr.Number(label="หมายเลขคอลัมน์ Surgical", precision=0)
-            ped_num = gr.Number(label="หมายเลขคอลัมน์ Pediatric", precision=0)
-            comm_num = gr.Number(label="หมายเลขคอลัมน์ Community", precision=0)
+            surg_num = gr.Number(label="Column number Surgical", precision=0)
+            ped_num = gr.Number(label="Column number Pediatric", precision=0)
+            comm_num = gr.Number(label="Column number Community", precision=0)
         with gr.Row():
-            psy_num = gr.Number(label="หมายเลขคอลัมน์ Psychiatric", precision=0)
-            obs_num = gr.Number(label="หมายเลขคอลัมน์ Obstetrics", precision=0)
+            psy_num = gr.Number(label="Column number Psychiatric", precision=0)
+            obs_num = gr.Number(label="Column number Obstetrics", precision=0)
 
         auto_btn.click(fn=on_upload, inputs=[file, selected_wards],
                        outputs=[status, available, name_num, id_num, 
                                 med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num])
 
+        # Reports (pre-assignment)
+        rank1_btn = gr.Button("Show Rank 1 Report (ดูสรุปอันดับ 1)")
+        rank1_report = gr.Markdown(label="Rank 1 Results (การแสดงผลอันดับที่ 1)")
+        rank1_btn.click(
+            fn=on_rank1_report,
+            inputs=[file, selected_wards, capacity_df, name_num, id_num,
+                    med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num],
+            outputs=rank1_report
+        )
+
+        all_ranks_btn = gr.Button("Show All Ranks Report (ดูสรุปทุกอันดับ)")
+        all_ranks_report = gr.Markdown(label="All Ranks Report (การแสดงผลทุกอันดับ)")
+        all_ranks_btn.click(
+            fn=on_all_ranks_report,
+            inputs=[file, selected_wards, capacity_df, name_num, id_num,
+                    med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num],
+            outputs=all_ranks_report
+        )
+
     with gr.Row():
         clean_btn = gr.Button("Clean data (ดูพรีวิว)", variant="primary")
 
-    preview = gr.Dataframe(label="พรีวิวข้อมูลที่ผ่านการ clean (หัว 30 แถว)", visible=True)
-    cleaned_file = gr.File(label="ดาวน์โหลดไฟล์ cleaned.csv")
+    preview = gr.Dataframe(label="Cleaned preview (first 30 rows)", visible=True)
+    cleaned_file = gr.File(label="Download cleaned.csv")
 
     clean_btn.click(
         fn=on_clean,
@@ -438,16 +586,17 @@ with gr.Blocks(title=APP_TITLE) as demo:
     )
 
     assign_btn = gr.Button("Assign (สุ่มตามลำดับอันดับ)")
-    assigned_preview = gr.Dataframe(label="ตัวอย่างผลการจัดสรร (หัว 30 แถว)")
-    assigned_file = gr.File(label="ดาวน์โหลดไฟล์ assigned.csv")
-    not_assigned_file = gr.File(label="ดาวน์โหลดไฟล์ not_assigned.csv")
-    leftover_text = gr.Textbox(label="สรุปความจุคงเหลือ", interactive=False)
+    assigned_preview = gr.Dataframe(label="Assigned preview (first 30 rows)")
+    assigned_file = gr.File(label="Download assigned.csv")
+    not_assigned_file = gr.File(label="Download not_assigned.csv")
+    leftover_text = gr.Textbox(label="Remaining capacity summary", interactive=False)
+    allocation_report = gr.Markdown(label="All Ranks & Allocation Report")
 
     assign_btn.click(
         fn=on_assign,
         inputs=[file, selected_wards, capacity_df, name_num, id_num,
                 med_num, med1_num, med2_num, surg_num, ped_num, comm_num, psy_num, obs_num],
-        outputs=[status, assigned_preview, assigned_file, not_assigned_file, leftover_text]
+        outputs=[status, assigned_preview, assigned_file, not_assigned_file, leftover_text, allocation_report]
     )
 
 if __name__ == "__main__":