Fix: use final_app with default data embedded

app.py

@@ -1,466 +1,748 @@
-import os, json, time
-import numpy as np
+import os
 import pandas as pd
-from flask import Flask, request, Response
+import numpy as np
+from flask import Flask, request, jsonify
 from flask_cors import CORS
-import joblib
-import warnings
-warnings.filterwarnings('ignore')
+from prophet import Prophet
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import accuracy_score
+import shap
+import json
+
+# ── Custom JSON encoder ──
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (np.integer,)):  return int(obj)
+        if isinstance(obj, (np.floating,)): return float(obj)
+        if isinstance(obj, (np.bool_,)):    return bool(obj)
+        if isinstance(obj, (np.ndarray,)):  return obj.tolist()
+        return super().default(obj)
+
+def safe_jsonify(data):
+    from flask import Response
+    return Response(json.dumps(data, cls=NumpyEncoder, ensure_ascii=False), mimetype='application/json')
 
 app = Flask(__name__)
 CORS(app)
 
-# ── Load models ──
-BASE = os.path.dirname(os.path.abspath(__file__))
-MODELS_DIR = os.path.join(BASE, "models")
+@app.after_request
+def add_headers(response):
+    response.headers["ngrok-skip-browser-warning"] = "true"
+    response.headers["Access-Control-Allow-Origin"] = "*"
+    response.headers["Access-Control-Allow-Headers"] = "Content-Type"
+    response.headers["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
+    return response
 
-FEATURES = joblib.load(os.path.join(MODELS_DIR, "features.pkl"))
-with open(os.path.join(MODELS_DIR, "results.json")) as f:
-    MODEL_RESULTS = json.load(f)
+# ════════════════════════════════════════════════════════
+# DEFAULT DATA — embedded สำหรับสอน นศ
+# ถ้า user ไม่ browse ไฟล์ → ใช้ข้อมูลนี้อัตโนมัติ
+# ════════════════════════════════════════════════════════
+import random as _rnd
+_rnd.seed(42); np.random.seed(42)
 
-TARGETS = ["dm_readmission", "sepsis_risk", "ckd_progression", "ht_crisis"]
-TARGET_NAMES = {
-    "dm_readmission":  "DM Readmission (30-day)",
-    "sepsis_risk":     "Sepsis Risk",
-    "ckd_progression": "CKD Progression",
-    "ht_crisis":       "Hypertension Crisis",
-}
+def _def_sales():
+    months = pd.date_range("2022-01-01", periods=36, freq="MS")
+    base=850000; trend=np.linspace(0,200000,36)
+    seas=np.array([0.85,0.80,0.90,0.95,1.05,1.10,1.15,1.20,1.10,1.00,0.95,1.30]*3)
+    s=(base+trend)*seas+np.random.normal(0,30000,36)
+    return [{"ds":m.strftime("%Y-%m-%d"),"y":max(0,round(float(v),0))} for m,v in zip(months,s)]
 
-ALGO_MAP = {"lr": "Logistic Regression", "rf": "Random Forest", "xgb": "XGBoost"}
-
-# Pre-load all models
-LOADED = {}
-for target in TARGETS:
-    LOADED[target] = {}
-    for algo in ["lr", "rf", "xgb"]:
-        path = os.path.join(MODELS_DIR, f"{target}_{algo}.pkl")
-        LOADED[target][algo] = joblib.load(path)
-        
-print(f"✅ Loaded {len(TARGETS) * 3} models")
-
-# Normal ranges for lab interpretation
-NORMAL_RANGES = {
-    "hba1c":          (4.0, 6.4, "%"),
-    "fasting_glucose": (70, 100, "mg/dL"),
-    "creatinine":     (0.6, 1.2, "mg/dL"),
-    "egfr":           (60, 120, "mL/min"),
-    "wbc":            (4.0, 11.0, "×10³/μL"),
-    "hemoglobin":     (12.0, 17.5, "g/dL"),
-    "sbp":            (90, 140, "mmHg"),
-    "dbp":            (60, 90, "mmHg"),
-    "heart_rate":     (60, 100, "bpm"),
-    "temperature":    (36.1, 37.5, "°C"),
-    "spo2":           (95, 100, "%"),
-    "bmi":            (18.5, 24.9, "kg/m²"),
-    "sodium":         (135, 145, "mEq/L"),
-    "potassium":      (3.5, 5.0, "mEq/L"),
-    "cholesterol":    (0, 200, "mg/dL"),
-    "ldl":            (0, 130, "mg/dL"),
-    "bun":            (7, 25, "mg/dL"),
-    "platelet":       (150, 400, "×10³/μL"),
-}
+def _def_health():
+    rows=[]
+    for i in range(100):
+        risk=_rnd.choices(["low","medium","high"],weights=[0.5,0.35,0.15])[0]
+        r={"low":1.0,"medium":1.3,"high":1.7}[risk]
+        rows.append({"patient_id":f"PT{i+1:04d}","age":_rnd.randint(30,80),"gender":_rnd.choice(["M","F"]),
+            "glucose_mg_dl":round(_rnd.gauss(95*r,20),1),"cholesterol_mg_dl":round(_rnd.gauss(200*r,35),1),
+            "hdl_mg_dl":round(_rnd.gauss(50/r,8),1),"ldl_mg_dl":round(_rnd.gauss(120*r,25),1),
+            "triglycerides_mg_dl":round(_rnd.gauss(130*r,40),1),"systolic_bp_mmhg":round(_rnd.gauss(120*r,15),1),
+            "diastolic_bp_mmhg":round(_rnd.gauss(80*r,10),1),"bmi":round(_rnd.gauss(24*r,4),1),
+            "hba1c_percent":round(_rnd.gauss(5.5*r,0.8),1),"risk_level":risk})
+    return rows
 
-def interpret_value(key, value):
-    if key not in NORMAL_RANGES:
-        return "normal"
-    lo, hi, _ = NORMAL_RANGES[key]
-    if value > hi:   return "high"
-    if value < lo:   return "low"
-    return "normal"
-
-def get_risk_recommendations(target, risk_prob, top_factors):
-    recs = {
-        "dm_readmission": {
-            "high":   ["นัดติดตามผลภายใน 2 สัปดาห์", "ตรวจ HbA1c ซ้ำ", "ประเมินการใช้ยา Insulin", "ให้ความรู้การดูแลเท้าและอาหาร"],
-            "medium": ["นัดติดตามผลภายใน 1 เดือน", "ตรวจ HbA1c และ Fasting glucose", "ทบทวนการใช้ยาเบาหวาน"],
-            "low":    ["นัดติดตามปกติ 3 เดือน", "ตรวจ HbA1c ปีละ 2 ครั้ง"],
-        },
-        "sepsis_risk": {
-            "high":   ["ส่งต่อห้องฉุกเฉินทันที", "เก็บ Blood culture 2 set", "เริ่ม Broad-spectrum antibiotics ภายใน 1 ชั่วโมง", "ให้สารน้ำ IV 30 mL/kg"],
-            "medium": ["Monitor vital signs ทุก 4 ชั่วโมง", "ตรวจ CBC, Lactate, CRP", "เตรียม IV access"],
-            "low":    ["Monitor ปกติ", "แนะนำสังเกตอาการไข้และหนาวสั่น"],
-        },
-        "ckd_progression": {
-            "high":   ["ส่งพบอายุรแพทย์โรคไต", "ลด protein diet < 0.8 g/kg/day", "ควบคุม BP < 130/80", "หลีกเลี่ยง NSAIDs และ contrast"],
-            "medium": ["ติดตาม Creatinine และ eGFR ทุก 3 เดือน", "ควบคุม DM และ HT ให้ดี", "ตรวจ Urine protein/creatinine ratio"],
-            "low":    ["ติดตาม eGFR ปีละครั้ง", "ดูแลความดันโลหิตและน้ำตาล"],
-        },
-        "ht_crisis": {
-            "high":   ["วัด BP ซ้ำทั้ง 2 แขน", "ตรวจ ECG และ Fundoscopy", "ให้ยาลด BP ฉุกเฉิน IV", "Monitor ใน ICU"],
-            "medium": ["ปรับยา Antihypertensive", "ลดเกลือ < 2g/วัน", "นัดติดตาม BP ใน 1 สัปดาห์"],
-            "low":    ["ติดตาม BP สม่ำเสมอ", "ให้ Lifestyle modification"],
-        },
-    }
-    level = "high" if risk_prob > 0.7 else "medium" if risk_prob > 0.4 else "low"
-    return recs.get(target, {}).get(level, ["ติดตามตามปกติ"])
-
-def safe_json(data):
-    class Enc(json.JSONEncoder):
-        def default(self, o):
-            if isinstance(o, (np.integer,)): return int(o)
-            if isinstance(o, (np.floating,)): return float(o)
-            if isinstance(o, (np.bool_,)): return bool(o)
-            if isinstance(o, np.ndarray): return o.tolist()
-            return super().default(o)
-    return Response(json.dumps(data, cls=Enc, ensure_ascii=False), mimetype='application/json')
+def _def_coffee():
+    months=pd.date_range("2022-01-01",periods=36,freq="MS")
+    base=320000; trend=np.linspace(0,80000,36)
+    seas=np.array([0.82,0.78,0.88,0.92,1.02,1.08,1.12,1.18,1.05,0.98,0.90,1.25]*3)
+    r=(base+trend)*seas+np.random.normal(0,12000,36)
+    return [{"ds":m.strftime("%Y-%m-%d"),"y":max(0,round(float(v),0))} for m,v in zip(months,r)]
 
-@app.after_request
-def add_cors(r):
-    r.headers["Access-Control-Allow-Origin"] = "*"
-    r.headers["Access-Control-Allow-Headers"] = "Content-Type"
-    r.headers["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
-    return r
+def _def_menu():
+    menus=[("ลาเต้ร้อน","coffee",280,0.68),("อเมริกาโน่","coffee",220,0.72),
+           ("คาปูชิโน่","coffee",250,0.65),("มอคค่า","coffee",300,0.62),
+           ("ชาเย็น","tea",180,0.70),("ชานมไข่มุก","tea",220,0.58),
+           ("ชาไทย","tea",160,0.74),("เค้กช็อกโกแลต","bakery",150,0.55),
+           ("บราวนี่","bakery",90,0.60),("คุกกี้","bakery",120,0.65),
+           ("แซนวิชไข่","food",95,0.52),("โทสต์","food",80,0.58),
+           ("ลาเต้เย็น","coffee",310,0.66),("กรีนที","tea",140,0.68),
+           ("ช็อกโกแลตฮอท","coffee",200,0.63)]
+    rows=[]
+    for name,cat,qty_b,mg in menus:
+        qty=int(qty_b*_rnd.uniform(0.7,1.3)); price=_rnd.choice([55,65,75,85,95,105]); rev=qty*price
+        rows.append({"menu_name":name,"category":cat,"total_qty":qty,"total_revenue":rev,
+                     "total_profit":round(rev*mg,0),"margin_pct":round(mg*100,1),"avg_price":price})
+    return rows
+
+def _def_hr():
+    depts=["Engineering","Sales","Marketing","HR","Finance","Operations","IT"]; rows=[]
+    for i in range(200):
+        dept=_rnd.choice(depts); sat=max(1,min(5,round(_rnd.gauss(3.5,0.8),1)))
+        ot=max(0,round(_rnd.gauss(20,10),0)); yrs=_rnd.randint(1,15); sal=_rnd.randint(25000,120000)
+        rp=((0.3 if sat<2.5 else 0)+(0.2 if ot>35 else 0)+(0.15 if sal<35000 else 0)
+            +(0.1 if yrs<2 else 0)+_rnd.uniform(-0.1,0.1))
+        rows.append({"employee_id":f"EMP{i+1:04d}","department":dept,"gender":_rnd.choice(["M","F"]),
+            "education":_rnd.choice(["Bachelor","Master","PhD","Diploma"]),
+            "position":f"Senior {dept} Specialist" if yrs>5 else f"{dept} Officer",
+            "age":_rnd.randint(22,55),"years_at_company":yrs,"years_in_current_role":_rnd.randint(1,yrs),
+            "salary_thb":sal,"salary_hike_pct":round(_rnd.gauss(8,3),1),
+            "distance_from_home_km":_rnd.randint(1,60),"overtime_hours_monthly":ot,
+            "monthly_absent_days":round(_rnd.gauss(1.5,1),1),"satisfaction_score":sat,
+            "performance_rating":round(_rnd.gauss(3.5,0.6),1),"num_projects":_rnd.randint(1,8),
+            "training_hours_yearly":_rnd.randint(0,80),"promotion_last_3years":_rnd.randint(0,2),
+            "work_life_balance":round(_rnd.gauss(3,0.8),1),"job_involvement":round(_rnd.gauss(3.2,0.7),1),
+            "manager_rating":round(_rnd.gauss(3.5,0.6),1),"resigned":1 if rp>0.35 else 0})
+    return rows
+
+def _def_lottery():
+    dates=pd.date_range("2020-01-01",periods=120,freq="SMS")
+    return [{"draw_date":d.strftime("%Y-%m-%d"),"last2_num":_rnd.randint(0,99),
+             "last3_num":_rnd.randint(0,999),"first_prize":"".join([str(_rnd.randint(0,9)) for _ in range(6)])}
+            for d in dates]
+
+_PR=["สินค้าดีมาก คุ้มค่า แนะนำเลย","บริการประทับใจ ส่งเร็ว","excellent quality love it",
+     "ของดี ชอบมาก","very satisfied","คุณภาพดี ใช้งานง่าย"]
+_NR=["สินค้าแย่มาก ผิดหวัง","ส่งช้ามาก ไม่พอใจ","terrible disappointed",
+     "คุณภาพห่วย ไม่คุ้มราคา","slow delivery bad service"]
+_NU=["ใช้งานได้ปกติ","สินค้าโอเค ตรงปก","okay nothing special","พอใช้งานได้","average as expected"]
+
+def _def_reviews():
+    channels=["LINE","Facebook","Website","Shopee","Lazada"]
+    months=[f"2024-{m:02d}" for m in range(1,13)]+[f"2025-{m:02d}" for m in range(1,7)]
+    rows=[]
+    for i in range(800):
+        s=_rnd.choices(["Positive","Negative","Neutral"],weights=[0.55,0.20,0.25])[0]
+        text=_rnd.choice(_PR if s=="Positive" else _NR if s=="Negative" else _NU)
+        rating=_rnd.choice([4,5]) if s=="Positive" else _rnd.choice([1,2]) if s=="Negative" else 3
+        mo=_rnd.choice(months)
+        rows.append({"review_id":f"REV{i+1:04d}","review_text":text,"sentiment":s,"rating":rating,
+                     "channel":_rnd.choice(channels),
+                     "category":_rnd.choice(["สินค้า","บริการ","การจัดส่ง"]),
+                     "month":mo,"date":f"{mo}-{_rnd.randint(1,28):02d}"})
+    return rows
+
+DEFAULT_INFO = {
+    "sales":   {"rows":36, "desc":"ยอดขาย 36 เดือน 2022-2024"},
+    "health":  {"rows":100,"desc":"ผู้ป่วยจำลอง 100 คน"},
+    "coffee":  {"rows":36, "desc":"รายได้กาแฟ 36 เดือน"},
+    "menu":    {"rows":15, "desc":"เมนูกาแฟ 15 รายการ"},
+    "hr":      {"rows":200,"desc":"พนักงานจำลอง 200 คน"},
+    "lottery": {"rows":120,"desc":"ล็อตเตอรี่ 120 งวด"},
+    "reviews": {"rows":800,"desc":"รีวิวจำลอง 800 รายการ"},
+}
+# ════════════════════════════════════════════════════════
 
 @app.route("/", methods=["GET"])
 def index():
-    return safe_json({
+    return safe_jsonify({
         "status": "ok",
-        "service": "Healthcare AI — Risk Prediction API",
-        "models": list(ALGO_MAP.values()),
-        "targets": TARGET_NAMES,
+        "message": "AI Analytics API — Forecast Hub",
+        "default_data": DEFAULT_INFO,
         "endpoints": [
-            "POST /api/health/classify      — single patient",
-            "POST /api/health/batch         — multiple patients",
-            "GET  /api/health/model-info    — model performance",
-            "GET  /api/health/population    — population stats",
-            "GET  /health",
+            "POST /api/forecast",
+            "POST /api/health/classify",
+            "POST /api/coffee/forecast",
+            "POST /api/coffee/menu-analysis",
+            "POST /api/hr/classify",
+            "POST /api/lottery/analyze",
+            "POST /api/sentiment/analyze"
         ]
     })
 
 @app.route("/health", methods=["GET"])
-def health():
-    return safe_json({"status": "ok", "models_loaded": len(TARGETS)*3})
-
-@app.route("/api/health/model-info", methods=["GET"])
-def model_info():
-    return safe_json({
-        "features": FEATURES,
-        "feature_count": len(FEATURES),
-        "targets": MODEL_RESULTS,
-        "algorithms": ALGO_MAP,
-    })
+def health_check():
+    return safe_jsonify({"status":"ok","default_data_available":True})
+
+# ─────────────────────────────────────
+# POST /api/forecast — Sales
+# ─────────────────────────────────────
+@app.route("/api/forecast", methods=["POST","OPTIONS"])
+def forecast():
+    if request.method == "OPTIONS": return jsonify({}), 200
+    try:
+        body = request.get_json()
+        data = body.get("data", [])
+        periods = body.get("periods", 6)
+        model_type = body.get("model","auto").lower()
+
+        # ── DEFAULT FALLBACK ──
+        using_default = not data
+        if using_default:
+            data = _def_sales()
+            print("📊 /api/forecast: using default sales data")
+
+        df = pd.DataFrame(data)
+        df.columns = ["ds","y"]
+        df["ds"] = pd.to_datetime(df["ds"])
+        if len(df) < 6:
+            return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 6 เดือน"}), 400
+
+        y = df["y"].values
+        last_date = df["ds"].iloc[-1]
+        forecast_dates = pd.date_range(start=last_date, periods=periods+1, freq="MS")[1:]
+
+        if model_type in ["auto","prophet"]:
+            m = Prophet(yearly_seasonality=True, weekly_seasonality=False,
+                        daily_seasonality=False, seasonality_mode="additive",
+                        changepoint_prior_scale=0.3, interval_width=0.90)
+            m.fit(df)
+            future = m.make_future_dataframe(periods=periods, freq="MS")
+            result = m.predict(future)
+            fdf = result.tail(periods)
+            preds=np.clip(fdf["yhat"].values,0,None)
+            lowers=np.clip(fdf["yhat_lower"].values,0,None)
+            uppers=fdf["yhat_upper"].values
+            used_model="Prophet"
+        elif model_type in ["holt-winters","holtwinters"]:
+            from statsmodels.tsa.holtwinters import ExponentialSmoothing
+            sp=min(12,len(y)//2)
+            hw=ExponentialSmoothing(y,trend="add",seasonal="add",seasonal_periods=sp).fit()
+            preds=np.clip(hw.forecast(periods),0,None)
+            std=np.std(y-hw.fittedvalues)*1.96
+            lowers=np.clip(preds-std,0,None); uppers=preds+std; used_model="Holt-Winters"
+        elif model_type == "sarima":
+            from statsmodels.tsa.statespace.sarimax import SARIMAX
+            fit=SARIMAX(y,order=(1,1,1),seasonal_order=(1,1,1,12)).fit(disp=False)
+            res=fit.get_forecast(steps=periods)
+            preds=np.clip(res.predicted_mean,0,None); ci=res.conf_int()
+            lowers=np.clip(ci[:,0],0,None); uppers=ci[:,1]; used_model="SARIMA"
+        elif model_type == "linear":
+            from sklearn.linear_model import LinearRegression
+            X=np.arange(len(y)).reshape(-1,1); lr=LinearRegression().fit(X,y)
+            X_f=np.arange(len(y),len(y)+periods).reshape(-1,1)
+            preds=np.clip(lr.predict(X_f),0,None); std=np.std(y-lr.predict(X))*1.96
+            lowers=np.clip(preds-std,0,None); uppers=preds+std; used_model="Linear"
+        elif model_type == "arima":
+            from statsmodels.tsa.arima.model import ARIMA
+            fit=ARIMA(y,order=(2,1,2)).fit()
+            res=fit.get_forecast(steps=periods)
+            preds=np.clip(res.predicted_mean,0,None); ci=res.conf_int()
+            lowers=np.clip(ci.iloc[:,0].values,0,None); uppers=ci.iloc[:,1].values; used_model="ARIMA"
+        else:
+            return safe_jsonify({"error":f"ไม่รู้จัก model: {model_type}"}), 400
 
-# ── Single patient predict ──
-@app.route("/api/health/classify", methods=["POST", "OPTIONS"])
-def classify():
-    if request.method == "OPTIONS":
-        return safe_json({}), 200
+        diff_pct=(preds[0]-y[-1])/y[-1]*100
+        trend="up" if diff_pct>2 else "down" if diff_pct<-2 else "stable"
+        forecast_list=[{"period":d.strftime("%Y-%m"),"predicted":round(float(preds[i]),2),
+                        "lower":round(float(lowers[i]),2),"upper":round(float(uppers[i]),2)}
+                       for i,d in enumerate(forecast_dates)]
+        return safe_jsonify({"forecast":forecast_list,"trend":trend,"confidence":85,
+                             "used_model":used_model,"using_default_data":using_default,
+                             "default_info":DEFAULT_INFO["sales"] if using_default else None})
+    except Exception as e:
+        return safe_jsonify({"error":str(e)}), 500
+
+# ─────────────────────────────────────
+# POST /api/health/classify
+# ─────────────────────────────────────
+@app.route("/api/health/classify", methods=["POST","OPTIONS"])
+def health_classify():
+    if request.method == "OPTIONS": return jsonify({}), 200
     try:
-        t0   = time.time()
         body = request.get_json()
-        
-        algo   = body.get("model", "xgb")
-        target = body.get("target", "ckd_progression")
-        patient = body.get("patient", {})
-        
-        if algo not in ALGO_MAP:
-            return safe_json({"error": f"Unknown model: {algo}"}), 400
-        if target not in TARGETS:
-            return safe_json({"error": f"Unknown target: {target}"}), 400
-        if not patient:
-            return safe_json({"error": "patient data required"}), 400
-        
-        # Build feature vector
-        row = {}
-        for feat in FEATURES:
-            val = patient.get(feat)
-            if val is None:
-                val = 0  # default
-            row[feat] = float(val)
-        
-        X = pd.DataFrame([row])[FEATURES]
-        
-        loaded = LOADED[target][algo]
-        model  = loaded["model"]
-        scaler = loaded["scaler"]
-        
-        X_input = scaler.transform(X) if scaler else X
-        prob    = float(model.predict_proba(X_input)[0][1])
-        pred    = int(prob > 0.5)
-        
-        # Risk level
-        if prob > 0.7:   risk_level = "HIGH"
-        elif prob > 0.4: risk_level = "MEDIUM"
-        else:            risk_level = "LOW"
-        
-        # Feature importance / pseudo-SHAP
-        if algo == "xgb":
-            fi = model.feature_importances_
-        elif algo == "rf":
-            fi = model.feature_importances_
+        data = body.get("data",[])
+        model_type = body.get("model","random_forest").lower()
+
+        # ── DEFAULT FALLBACK ──
+        using_default = not data
+        if using_default:
+            data = _def_health()
+            print("📊 /api/health/classify: using default health data")
+
+        if len(data) < 6:
+            return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 6 แถว"}), 400
+
+        feature_cols=["glucose_mg_dl","cholesterol_mg_dl","hdl_mg_dl","ldl_mg_dl",
+                      "triglycerides_mg_dl","systolic_bp_mmhg","diastolic_bp_mmhg","bmi","hba1c_percent"]
+        df=pd.DataFrame(data)
+        missing=[c for c in feature_cols if c not in df.columns]
+        if missing: return safe_jsonify({"error":f"Missing columns: {missing}"}), 400
+
+        X=df[feature_cols].fillna(df[feature_cols].median())
+        if "risk_level" in df.columns:
+            y_raw=df["risk_level"].str.lower().str.strip()
         else:
-            fi = np.abs(model.coef_[0])
-        
-        fi_norm = fi / fi.sum()
-        top_factors = sorted(
-            [{"feature": f, "importance": round(float(v), 4),
-              "value": round(float(row[f]), 2),
-              "status": interpret_value(f, row[f]),
-              "unit": NORMAL_RANGES.get(f, (None,None,""))[2]}
-             for f, v in zip(FEATURES, fi_norm)],
-            key=lambda x: x["importance"], reverse=True
-        )[:5]
-        
-        # Lab interpretation
-        lab_status = {
-            feat: {"value": round(float(row[feat]), 2),
-                   "status": interpret_value(feat, row[feat]),
-                   "unit": NORMAL_RANGES.get(feat, (None,None,""))[2]}
-            for feat in NORMAL_RANGES if feat in row
-        }
-        
-        recs = get_risk_recommendations(target, prob, top_factors)
-        elapsed = round(time.time() - t0, 3)
-        
-        return safe_json({
-            "patient_id":    patient.get("patient_id", "unknown"),
-            "target":        target,
-            "target_name":   TARGET_NAMES[target],
-            "model":         algo,
-            "model_name":    ALGO_MAP[algo],
-            "risk_prob":     round(prob, 3),
-            "risk_pct":      round(prob * 100, 1),
-            "prediction":    pred,
-            "risk_level":    risk_level,
-            "top_factors":   top_factors,
-            "lab_status":    lab_status,
-            "recommendations": recs,
-            "model_auroc":   MODEL_RESULTS[target]["auroc"][algo],
-            "processing_ms": round(elapsed * 1000, 1),
-        })
+            y_raw=pd.Series("low",index=df.index)
+            y_raw[(df["hba1c_percent"]>5.7)|(df["glucose_mg_dl"]>100)|(df["cholesterol_mg_dl"]>200)|(df["systolic_bp_mmhg"]>120)]="medium"
+            y_raw[(df["hba1c_percent"]>7.0)|(df["glucose_mg_dl"]>130)|(df["cholesterol_mg_dl"]>240)|(df["systolic_bp_mmhg"]>140)]="high"
+
+        le=LabelEncoder(); y=le.fit_transform(y_raw)
+        if model_type=="random_forest":
+            clf=RandomForestClassifier(n_estimators=100,random_state=42); model_name="Random Forest"
+        elif model_type in ["xgboost","gradient_boosting"]:
+            clf=GradientBoostingClassifier(n_estimators=100,random_state=42); model_name="Gradient Boosting"
+        else:
+            clf=Pipeline([("scaler",StandardScaler()),("clf",LogisticRegression(max_iter=1000,random_state=42))]); model_name="Logistic Regression"
+
+        clf.fit(X,y); y_pred=clf.predict(X); accuracy=round(accuracy_score(y,y_pred)*100,1)
+        proba=clf.predict_proba(X)
+
+        try:
+            explainer=shap.TreeExplainer(clf); shap_vals=explainer.shap_values(X)
+            mean_shap={col:round(float(np.mean([abs(shap_vals[c][:,i]).mean() for c in range(len(le.classes_))])),4)
+                       for i,col in enumerate(feature_cols)}
+        except:
+            mean_shap=({col:round(float(clf.feature_importances_[i]),4) for i,col in enumerate(feature_cols)}
+                       if hasattr(clf,"feature_importances_") else {col:0.0 for col in feature_cols})
+
+        sorted_shap=dict(sorted(mean_shap.items(),key=lambda x:x[1],reverse=True))
+        pred_labels=le.inverse_transform(y_pred)
+        results=[{"patient_id":str(row.get("patient_id",f"PT{i:04d}")),
+                  "age":int(row.get("age",0)),"gender":str(row.get("gender","")),
+                  "risk_level":le.inverse_transform([y_pred[i]])[0].capitalize(),
+                  "confidence":round(float(proba[i].max()),3),
+                  "key_values":{"hba1c_percent":round(float(row.get("hba1c_percent",0)),1),
+                                "glucose_mg_dl":round(float(row.get("glucose_mg_dl",0)),1),
+                                "bmi":round(float(row.get("bmi",0)),1)},
+                  "shap_values":sorted_shap} for i,row in df.iterrows()]
+        alerts=[{"patient_id":r["patient_id"],"reasons":
+                 (["HbA1c "+str(r["key_values"]["hba1c_percent"])+"%"] if r["key_values"]["hba1c_percent"]>8.0 else[])+
+                 (["Glucose "+str(r["key_values"]["glucose_mg_dl"])+" mg/dL"] if r["key_values"]["glucose_mg_dl"]>180 else[])}
+                for r in results if r["risk_level"].lower()=="high" and
+                (r["key_values"]["hba1c_percent"]>8.0 or r["key_values"]["glucose_mg_dl"]>180)]
+
+        return safe_jsonify({"results":results,
+            "summary":{"high":int((pred_labels=="high").sum()),"medium":int((pred_labels=="medium").sum()),"low":int((pred_labels=="low").sum())},
+            "model_performance":{"accuracy":accuracy,"model_used":model_name,"n_patients":len(df)},
+            "feature_importance":sorted_shap,"alerts":alerts,
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["health"] if using_default else None})
     except Exception as e:
         import traceback; print(traceback.format_exc())
-        return safe_json({"error": str(e)}), 500
+        return safe_jsonify({"error":str(e)}), 500
 
-# ── Batch predict ──
-@app.route("/api/health/batch", methods=["POST", "OPTIONS"])
-def batch_classify():
-    if request.method == "OPTIONS":
-        return safe_json({}), 200
+# ─────────────────────────────────────
+# POST /api/coffee/forecast
+# ─────────────────────────────────────
+@app.route("/api/coffee/forecast", methods=["POST","OPTIONS"])
+def coffee_forecast():
+    if request.method == "OPTIONS": return jsonify({}), 200
     try:
-        t0 = time.time()
-        body    = request.get_json()
-        algo    = body.get("model", "xgb")
-        target  = body.get("target", "ckd_progression")
-        patients = body.get("patients", [])
-        
-        if not patients:
-            return safe_json({"error": "patients list required"}), 400
-        
-        loaded = LOADED[target][algo]
-        model  = loaded["model"]
-        scaler = loaded["scaler"]
-        
-        rows = []
-        for p in patients:
-            row = {feat: float(p.get(feat, 0)) for feat in FEATURES}
-            rows.append(row)
-        
-        X = pd.DataFrame(rows)[FEATURES]
-        X_input = scaler.transform(X) if scaler else X
-        probs   = model.predict_proba(X_input)[:, 1]
-        
-        results = []
-        for i, (p, prob) in enumerate(zip(patients, probs)):
-            prob = float(prob)
-            risk_level = "HIGH" if prob > 0.7 else "MEDIUM" if prob > 0.4 else "LOW"
-            results.append({
-                "patient_id":  p.get("patient_id", f"P{i:04d}"),
-                "full_name":   p.get("full_name", ""),
-                "age":         p.get("age", 0),
-                "risk_prob":   round(prob, 3),
-                "risk_pct":    round(prob * 100, 1),
-                "risk_level":  risk_level,
-            })
-        
-        results.sort(key=lambda x: x["risk_prob"], reverse=True)
-        
-        cnt = {"HIGH":0,"MEDIUM":0,"LOW":0}
-        for r in results:
-            cnt[r["risk_level"]] += 1
-        
-        elapsed = round(time.time() - t0, 3)
-        return safe_json({
-            "total":        len(results),
-            "target":       target,
-            "target_name":  TARGET_NAMES[target],
-            "model":        algo,
-            "model_name":   ALGO_MAP[algo],
-            "risk_summary": cnt,
-            "results":      results,
-            "processing_ms": round(elapsed * 1000, 1),
-        })
+        body=request.get_json(); data=body.get("data",[]); periods=body.get("periods",6)
+        model_type=body.get("model","prophet").lower(); branch=body.get("branch","ทุกสาขา")
+
+        using_default = not data
+        if using_default:
+            data = _def_coffee()
+            print("📊 /api/coffee/forecast: using default coffee data")
+
+        if len(data)<6: return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 6 เดือน"}), 400
+
+        df=pd.DataFrame(data); df.columns=["ds","y"]
+        df["ds"]=pd.to_datetime(df["ds"]); df=df.sort_values("ds").reset_index(drop=True)
+        y=df["y"].values; last_date=df["ds"].iloc[-1]
+        forecast_dates=pd.date_range(start=last_date,periods=periods+1,freq="MS")[1:]
+
+        if model_type=="prophet":
+            m=Prophet(yearly_seasonality=True,weekly_seasonality=False,daily_seasonality=False,
+                      seasonality_mode="additive",changepoint_prior_scale=0.3,
+                      seasonality_prior_scale=10,interval_width=0.90)
+            m.fit(df); future=m.make_future_dataframe(periods=periods,freq="MS"); result=m.predict(future)
+            fdf=result.tail(periods); preds=np.clip(fdf["yhat"].values,0,None)
+            lowers=np.clip(fdf["yhat_lower"].values,0,None); uppers=fdf["yhat_upper"].values; used_model="Prophet"
+        elif model_type in ["holt-winters","holtwinters"]:
+            from statsmodels.tsa.holtwinters import ExponentialSmoothing
+            sp=min(12,len(y)//2)
+            hw=ExponentialSmoothing(y,trend="add",seasonal="add",seasonal_periods=sp).fit()
+            preds=np.clip(hw.forecast(periods),0,None); std=np.std(y-hw.fittedvalues)*1.96
+            lowers=np.clip(preds-std,0,None); uppers=preds+std; used_model="Holt-Winters"
+        elif model_type=="arima":
+            from statsmodels.tsa.arima.model import ARIMA
+            fit=ARIMA(y,order=(2,1,2)).fit(); res=fit.get_forecast(steps=periods)
+            preds=np.clip(res.predicted_mean,0,None); ci=res.conf_int()
+            lowers=np.clip(ci.iloc[:,0].values,0,None); uppers=ci.iloc[:,1].values; used_model="ARIMA"
+        else:
+            return safe_jsonify({"error":f"ไม่รู้จัก model: {model_type}"}), 400
+
+        diff_pct=(preds[0]-y[-1])/y[-1]*100
+        trend="up" if diff_pct>2 else "down" if diff_pct<-2 else "stable"
+        avg_growth=round(float(np.mean(np.diff(preds)/preds[:-1]*100)),2) if len(preds)>1 else 0
+        mape=np.mean(np.abs((y-np.mean(y))/y))*100; confidence=max(60,min(95,int(100-mape)))
+        forecast_list=[{"period":d.strftime("%Y-%m"),"predicted":round(float(preds[i]),0),
+                        "lower":round(float(lowers[i]),0),"upper":round(float(uppers[i]),0)}
+                       for i,d in enumerate(forecast_dates)]
+        peak=forecast_list[int(np.argmax([f["predicted"] for f in forecast_list]))]["period"]
+
+        return safe_jsonify({"forecast":forecast_list,"trend":trend,"confidence":confidence,
+            "used_model":used_model,"branch":branch,"avg_monthly_growth_pct":avg_growth,
+            "peak_forecast_month":peak,"total_forecast_revenue":round(sum(f["predicted"] for f in forecast_list),0),
+            "historical_avg":round(float(np.mean(y)),0),
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["coffee"] if using_default else None})
     except Exception as e:
         import traceback; print(traceback.format_exc())
-        return safe_json({"error": str(e)}), 500
+        return safe_jsonify({"error":str(e)}), 500
 
-# ── Population stats ──
-@app.route("/api/health/population", methods=["GET"])
-def population():
+# ─────────────────────────────────────
+# POST /api/coffee/menu-analysis
+# ─────────────────────────────────────
+@app.route("/api/coffee/menu-analysis", methods=["POST","OPTIONS"])
+def coffee_menu_analysis():
+    if request.method == "OPTIONS": return jsonify({}), 200
     try:
-        csv_path = os.path.join(BASE, "synthetic_patients.csv")
-        df = pd.read_csv(csv_path)
-        
-        algo   = request.args.get("model", "xgb")
-        target = request.args.get("target", "ckd_progression")
-        
-        loaded = LOADED[target][algo]
-        model  = loaded["model"]
-        scaler = loaded["scaler"]
-        
-        X = df[FEATURES].fillna(df[FEATURES].median())
-        X_input = scaler.transform(X) if scaler else X
-        probs   = model.predict_proba(X_input)[:, 1]
-        
-        df["risk_prob"]  = probs
-        df["risk_level"] = pd.cut(probs,
-            bins=[-0.001, 0.4, 0.7, 1.001],
-            labels=["LOW","MEDIUM","HIGH"])
-        
-        # Sample for scatter plot (50 points)
-        sample = df.sample(min(200, len(df)), random_state=42)
-        scatter = sample[["patient_id","full_name","age","risk_prob",
-                           "risk_level","has_diabetes","has_hypertension",
-                           "has_ckd","sbp","hba1c","creatinine"]].to_dict("records")
-        
-        # Age group breakdown
-        df["age_group"] = pd.cut(df["age"],
-            bins=[0,30,45,60,75,100],
-            labels=["<30","30-44","45-59","60-74","75+"])
-        age_risk = df.groupby("age_group")["risk_prob"].mean().round(3).to_dict()
-        
-        return safe_json({
-            "total":        len(df),
-            "target":       target,
-            "model":        algo,
-            "risk_summary": df["risk_level"].value_counts().to_dict(),
-            "mean_risk":    round(float(probs.mean()), 3),
-            "high_risk_count": int((probs > 0.7).sum()),
-            "age_risk_trend":  {str(k): float(v) for k,v in age_risk.items()},
-            "scatter_data": scatter,
-        })
+        body=request.get_json(); data=body.get("data",[]); branch=body.get("branch","ทุกสาขา")
+
+        using_default = not data
+        if using_default:
+            data = _def_menu()
+            print("📊 /api/coffee/menu-analysis: using default menu data")
+
+        df=pd.DataFrame(data)
+        if branch!="ทุกสาขา" and "branch" in df.columns: df=df[df["branch"]==branch]
+        required=["menu_name","total_qty","total_revenue","total_profit","margin_pct"]
+        missing=[c for c in required if c not in df.columns]
+        if missing: return safe_jsonify({"error":f"Missing columns: {missing}"}), 400
+
+        for col in ["total_qty","total_revenue","total_profit","margin_pct"]:
+            df[col]=pd.to_numeric(df[col],errors="coerce").fillna(0)
+        avg_qty=df["total_qty"].mean()
+        top_qty=df.nlargest(5,"total_qty")[["menu_name","total_qty","total_revenue","margin_pct"]].to_dict("records")
+        top_rev=df.nlargest(5,"total_revenue")[["menu_name","total_qty","total_revenue","margin_pct"]].to_dict("records")
+        low=df[df["total_qty"]<avg_qty*0.3].nsmallest(5,"total_qty")[["menu_name","total_qty","margin_pct"]].to_dict("records")
+        stars=df[(df["margin_pct"]>65)&(df["total_qty"]>avg_qty)][["menu_name","margin_pct","total_qty"]].to_dict("records")
+        recs=([{"menu":i["menu_name"],"action":"พิจารณาตัดเมนูหรือปรับราคา",
+                "reason":f"ขายได้ {i['total_qty']} ชิ้น — ต่ำกว่าค่าเฉลี่ย 70%"} for i in low]+
+              [{"menu":i["menu_name"],"action":"โปรโมตเพิ่ม — Margin ดี",
+                "reason":f"Margin {i['margin_pct']}% และขายดี"} for i in stars[:3]])
+
+        return safe_jsonify({"branch":branch,"total_menus":len(df),
+            "top_by_quantity":top_qty,"top_by_revenue":top_rev,"low_performers":low,
+            "high_margin_stars":stars,"recommendations":recs,
+            "summary":{"avg_margin_pct":round(float(df["margin_pct"].mean()),1),
+                       "total_revenue":round(float(df["total_revenue"].sum()),0),
+                       "total_profit":round(float(df["total_profit"].sum()),0),
+                       "best_menu":df.loc[df["total_revenue"].idxmax(),"menu_name"]},
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["menu"] if using_default else None})
     except Exception as e:
         import traceback; print(traceback.format_exc())
-        return safe_json({"error": str(e)}), 500
+        return safe_jsonify({"error":str(e)}), 500
 
+# ─────────────────────────────────────
+# POST /api/hr/classify
+# ─────────────────────────────────────
+@app.route("/api/hr/classify", methods=["POST","OPTIONS"])
+def hr_classify():
+    if request.method == "OPTIONS": return jsonify({}), 200
+    try:
+        import time
+        t0=time.time()
+        body=request.get_json(); data=body.get("data",[]); model_type=body.get("model","xgboost").lower()
+
+        using_default = not data
+        if using_default:
+            data = _def_hr()
+            print("📊 /api/hr/classify: using default HR data")
+
+        if len(data)<10: return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 10 แถว"}), 400
+
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import accuracy_score,recall_score,precision_score,f1_score,roc_auc_score
+
+        df=pd.DataFrame(data)
+        num_features=['age','years_at_company','years_in_current_role','salary_thb','salary_hike_pct',
+                      'distance_from_home_km','overtime_hours_monthly','monthly_absent_days',
+                      'satisfaction_score','performance_rating','num_projects','training_hours_yearly',
+                      'promotion_last_3years','work_life_balance','job_involvement','manager_rating']
+        cat_features=['department','gender','education']
+        missing=[c for c in num_features if c not in df.columns]
+        if missing: return safe_jsonify({"error":f"Missing columns: {missing}"}), 400
+        for c in cat_features:
+            if c not in df.columns: df[c]='Unknown'
+
+        df_enc=pd.get_dummies(df[num_features+cat_features+(['resigned'] if 'resigned' in df.columns else [])],columns=cat_features)
+        feature_cols=[c for c in df_enc.columns if c!='resigned']
+        has_label='resigned' in df.columns
+        X=df_enc[feature_cols].fillna(0)
+        y=df_enc['resigned'].astype(int) if has_label else None
+
+        if has_label and len(df)>=20:
+            X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=42,
+                stratify=y if y.sum()>=2 else None)
+        else:
+            X_train,X_test=X,X; y_train=y if has_label else pd.Series([0]*len(X)); y_test=y_train
+
+        results={}; models_to_run=['logistic','random_forest','xgboost'] if model_type=='all' else [model_type]
+        for m_name in models_to_run:
+            if m_name=='logistic':
+                clf=Pipeline([('scaler',StandardScaler()),('clf',LogisticRegression(max_iter=1000,random_state=42))]); label='Logistic Regression'
+            elif m_name=='random_forest':
+                clf=RandomForestClassifier(n_estimators=100,random_state=42); label='Random Forest'
+            else:
+                clf=GradientBoostingClassifier(n_estimators=100,random_state=42); label='XGBoost'
+            clf.fit(X_train,y_train); y_pred=clf.predict(X_test); y_prob=clf.predict_proba(X_test)[:,1]
+            perf={} if not has_label else {
+                "accuracy_pct":round(accuracy_score(y_test,y_pred)*100,1),
+                "recall_pct":round(recall_score(y_test,y_pred,zero_division=0)*100,1),
+                "precision_pct":round(precision_score(y_test,y_pred,zero_division=0)*100,1),
+                "f1_pct":round(f1_score(y_test,y_pred,zero_division=0)*100,1),
+                "auc":round(roc_auc_score(y_test,y_prob) if len(y_test.unique())>1 else 0.5,3)}
+            if hasattr(clf,'feature_importances_'):
+                fi=sorted(zip(feature_cols,clf.feature_importances_),key=lambda x:x[1],reverse=True)[:10]
+            elif hasattr(clf,'named_steps'):
+                coef=clf.named_steps['clf'].coef_[0]
+                fi=sorted(zip(feature_cols,abs(coef)),key=lambda x:x[1],reverse=True)[:10]
+            else: fi=[]
+            results[m_name]={"model_name":label,"performance":perf,
+                             "feature_importance":[{"feature":k,"importance":round(float(v),4)} for k,v in fi]}
+
+        threshold=float(body.get("threshold",0.5)); threshold=max(0.1,min(0.9,threshold))
+        best_model_name=model_type if model_type!='all' else 'xgboost'
+        if best_model_name not in results: best_model_name=list(results.keys())[0]
+
+        if best_model_name=='logistic':
+            best_clf=Pipeline([('scaler',StandardScaler()),('clf',LogisticRegression(max_iter=1000,random_state=42))])
+        elif best_model_name=='random_forest':
+            best_clf=RandomForestClassifier(n_estimators=100,random_state=42)
+        else:
+            best_clf=GradientBoostingClassifier(n_estimators=100,random_state=42)
 
-# ── Patient list by risk level — ครบทุกคน ไม่ใช่ sample ──
-@app.route("/api/health/patients", methods=["GET","OPTIONS"])
-def get_patients():
-    if request.method == "OPTIONS":
-        return safe_json({}), 200
+        best_clf.fit(X_train,y_train); all_probs=best_clf.predict_proba(X)[:,1]
+        all_preds=(all_probs>=threshold).astype(int)
+
+        predictions=[]
+        for i,(_,row) in enumerate(df.iterrows()):
+            prob=float(all_probs[i]); risk='High' if prob>=0.6 else 'Medium' if prob>=0.3 else 'Low'
+            predictions.append({"employee_id":str(row.get('employee_id',f'EMP{i:04d}')),
+                "department":str(row.get('department','')),"position":str(row.get('position','')),
+                "resign_probability":round(prob,3),"risk_level":risk,
+                "actual_resigned":int(row['resigned']) if 'resigned' in row else None,
+                "key_factors":{"satisfaction_score":float(row.get('satisfaction_score',0)),
+                    "overtime_hours":float(row.get('overtime_hours_monthly',0)),
+                    "salary_thb":float(row.get('salary_thb',0)),
+                    "years_at_company":float(row.get('years_at_company',0))}})
+
+        high=sum(1 for p in predictions if p['risk_level']=='High')
+        medium=sum(1 for p in predictions if p['risk_level']=='Medium')
+        low=sum(1 for p in predictions if p['risk_level']=='Low')
+        dept_risk={}
+        for p in predictions:
+            dept=p['department']
+            if dept not in dept_risk: dept_risk[dept]={'count':0,'high_risk':0,'total_prob':0}
+            dept_risk[dept]['count']+=1; dept_risk[dept]['total_prob']+=p['resign_probability']
+            if p['risk_level']=='High': dept_risk[dept]['high_risk']+=1
+        dept_summary=[{"department":dept,"total":v['count'],"high_risk":v['high_risk'],
+                       "avg_resign_prob":round(v['total_prob']/v['count']*100,1)}
+                      for dept,v in sorted(dept_risk.items(),key=lambda x:x[1]['high_risk'],reverse=True)]
+        elapsed=round(time.time()-t0,1)
+
+        return safe_jsonify({"total_employees":len(df),"model_requested":model_type,
+            "processing_time_sec":elapsed,
+            "risk_summary":{"high_risk":high,"medium_risk":medium,"low_risk":low,
+                            "high_risk_pct":round(high/len(df)*100,1)},
+            "department_summary":dept_summary,"model_results":results,"best_model":best_model_name,
+            "predictions":sorted(predictions,key=lambda x:x['resign_probability'],reverse=True),
+            "top_at_risk":sorted(predictions,key=lambda x:x['resign_probability'],reverse=True)[:10],
+            "threshold_used":threshold,"threshold_analysis":[],
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["hr"] if using_default else None,
+            "disclaimer":"ผลการพยากรณ์ใช้เพื่อสนับสนุนการตัดสินใจ HR เท่านั้น"})
+    except Exception as e:
+        import traceback; print(traceback.format_exc())
+        return safe_jsonify({"error":str(e)}), 500
+
+# ─────────────────────────────────────
+# POST /api/lottery/analyze
+# ─────────────────────────────────────
+@app.route("/api/lottery/analyze", methods=["POST","OPTIONS"])
+def lottery_analyze():
+    if request.method == "OPTIONS": return jsonify({}), 200
     try:
-        algo     = request.args.get("model", "xgb")
-        target   = request.args.get("target", "ckd_progression")
-        risk     = request.args.get("risk", "all").upper()
-        page     = int(request.args.get("page", 1))
-        per_page = int(request.args.get("per_page", 20))
-
-        csv_path = os.path.join(BASE, "synthetic_patients.csv")
-        df = pd.read_csv(csv_path)
-
-        loaded = LOADED[target][algo]
-        model  = loaded["model"]
-        scaler = loaded["scaler"]
-
-        X = df[FEATURES].fillna(df[FEATURES].median())
-        X_input = scaler.transform(X) if scaler else X
-        probs   = model.predict_proba(X_input)[:, 1]
-
-        df["risk_prob"]  = probs
-        df["risk_pct"]   = (probs * 100).round(1)
-        df["risk_level"] = pd.cut(probs,
-            bins=[-0.001, 0.4, 0.7, 1.001],
-            labels=["LOW","MEDIUM","HIGH"])
-
-        if risk in ["HIGH","MEDIUM","LOW"]:
-            filtered = df[df["risk_level"] == risk].copy()
+        body=request.get_json(); data=body.get("data",[])
+
+        using_default = not data
+        if using_default:
+            data = _def_lottery()
+            print("📊 /api/lottery/analyze: using default lottery data")
+
+        if len(data)<10: return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 10 งวด"}), 400
+
+        df=pd.DataFrame(data)
+        if "last2_num" not in df.columns: return safe_jsonify({"error":"Missing column: last2_num"}), 400
+        sequence=df["last2_num"].astype(int).values; n=len(sequence)
+
+        counter={}
+        for v in sequence: k=f"{int(v):02d}"; counter[k]=counter.get(k,0)+1
+        sorted_freq=sorted(counter.items(),key=lambda x:x[1],reverse=True)
+        hot=[{"number":k,"count":v} for k,v in sorted_freq[:10]]
+        cold=[{"number":k,"count":v} for k,v in sorted_freq[-10:]]
+        never=[f"{i:02d}" for i in range(100) if f"{i:02d}" not in counter]
+
+        transitions={}
+        for i in range(len(sequence)-1):
+            c=int(sequence[i]); nx=int(sequence[i+1])
+            if c not in transitions: transitions[c]={}
+            transitions[c][nx]=transitions[c].get(nx,0)+1
+
+        last_num=int(sequence[-1])
+        if last_num in transitions:
+            mn=sorted(transitions[last_num].items(),key=lambda x:x[1],reverse=True)[:5]
+            markov_predictions=[{"number":f"{k:02d}","count":v,
+                "probability":round(v/sum(transitions[last_num].values())*100,1)} for k,v in mn]
+        else:
+            markov_predictions=[{"number":hot[0]["number"],"count":hot[0]["count"],
+                                  "probability":round(hot[0]["count"]/n*100,1)}]
+
+        tens_count={str(d):0 for d in range(10)}; units_count={str(d):0 for d in range(10)}
+        for v in sequence: tens_count[str(int(v)//10)]+=1; units_count[str(int(v)%10)]+=1
+
+        TRAIN=min(40,n//2); test_seq=sequence[TRAIN:]; correct=0
+        for i in range(len(test_seq)):
+            c2={}
+            for v in sequence[:TRAIN+i]: c2[int(v)]=c2.get(int(v),0)+1
+            if c2 and max(c2,key=c2.get)==int(test_seq[i]): correct+=1
+        freq_accuracy=round(correct/len(test_seq)*100,2) if test_seq.size>0 else 0
+
+        from scipy import stats as scipy_stats
+        obs=[counter.get(f"{i:02d}",0) for i in range(100)]; exp=[n/100]*100
+        chi2,p_value=scipy_stats.chisquare(obs,exp)
+
+        return safe_jsonify({"total_draws":n,
+            "frequency":{"hot_numbers":hot,"cold_numbers":cold,"never_appeared":never,"never_count":len(never)},
+            "digit_analysis":{"tens":tens_count,"units":units_count},
+            "markov":{"last_number":f"{last_num:02d}","predictions":markov_predictions},
+            "predictions":{"frequency_model":hot[0]["number"] if hot else "00",
+                           "markov_model":markov_predictions[0]["number"] if markov_predictions else "00",
+                           "disclaimer":"การพยากรณ์นี้ใช้เพื่อการศึกษาสถิติเท่านั้น"},
+            "model_performance":{"frequency_accuracy_pct":freq_accuracy,"random_baseline_pct":1.0,
+                                  "test_draws":len(test_seq),"note":"Accuracy ใกล้เคียง Random = ไม่มี pattern"},
+            "statistical_test":{"chi_square":round(float(chi2),2),"p_value":round(float(p_value),4),
+                                 "is_random":bool(p_value>0.05),
+                                 "interpretation":"สุ่มจริง ไม่มี pattern" if p_value>0.05 else "อาจมี pattern"},
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["lottery"] if using_default else None})
+    except Exception as e:
+        import traceback; print(traceback.format_exc())
+        return safe_jsonify({"error":str(e)}), 500
+
+# ─────────────────────────────────────
+# POST /api/sentiment/analyze
+# ─────────────────────────────────────
+@app.route("/api/sentiment/analyze", methods=["POST","OPTIONS"])
+def sentiment_analyze():
+    if request.method == "OPTIONS": return jsonify({}), 200
+    try:
+        import time; t0=time.time()
+        from sklearn.feature_extraction.text import TfidfVectorizer
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import accuracy_score,f1_score,confusion_matrix
+        from collections import Counter
+
+        body=request.get_json(); data=body.get("data",[]); model_type=body.get("model","logistic").lower()
+
+        using_default = not data
+        if using_default:
+            data = _def_reviews()
+            print("📊 /api/sentiment/analyze: using default reviews data")
+
+        if len(data)<5: return safe_jsonify({"error":"ต้องการข้อมูลอย่างน้อย 5 reviews"}), 400
+
+        df=pd.DataFrame(data)
+        if "review_text" not in df.columns: return safe_jsonify({"error":"Missing column: review_text"}), 400
+        df["review_text"]=df["review_text"].fillna("").astype(str)
+        has_label="sentiment" in df.columns and df["sentiment"].notna().sum()>0
+        X=df["review_text"]; results={}; pipes={}
+        models_to_run=["logistic","random_forest","xgboost"] if model_type=="all" else [model_type]
+
+        if has_label:
+            y=df["sentiment"].fillna("Neutral")
+            if len(df)>=20:
+                X_tr,X_te,y_tr,y_te=train_test_split(X,y,test_size=0.2,random_state=42,
+                    stratify=y if y.value_counts().min()>=2 else None)
+            else: X_tr,X_te,y_tr,y_te=X,X,y,y
         else:
-            filtered = df.copy()
-
-        filtered = filtered.sort_values("risk_prob", ascending=False)
-        total    = len(filtered)
-        start    = (page - 1) * per_page
-        page_df  = filtered.iloc[start:start+per_page]
-
-        def safe_float(v):
-            try: return round(float(v), 3)
-            except: return 0.0
-
-        def safe_int(v):
-            try: return int(v)
-            except: return 0
-
-        patients = []
-        for _, row in page_df.iterrows():
-            patients.append({
-                "patient_id":   row["patient_id"],
-                "full_name":    row["full_name"],
-                "age":          safe_int(row["age"]),
-                "gender":       str(row.get("gender","")),
-                "risk_prob":    round(float(row["risk_prob"]), 3),
-                "risk_pct":     round(float(row["risk_pct"]), 1),
-                "risk_level":   str(row["risk_level"]),
-                "bmi":          safe_float(row.get("bmi",0)),
-                "sbp":          safe_float(row.get("sbp",0)),
-                "dbp":          safe_float(row.get("dbp",0)),
-                "heart_rate":   safe_float(row.get("heart_rate",0)),
-                "temperature":  safe_float(row.get("temperature",0)),
-                "spo2":         safe_float(row.get("spo2",0)),
-                "respiratory_rate": safe_float(row.get("respiratory_rate",0)),
-                "hba1c":        safe_float(row.get("hba1c",0)),
-                "fasting_glucose": safe_float(row.get("fasting_glucose",0)),
-                "creatinine":   safe_float(row.get("creatinine",0)),
-                "egfr":         safe_float(row.get("egfr",0)),
-                "bun":          safe_float(row.get("bun",0)),
-                "wbc":          safe_float(row.get("wbc",0)),
-                "hemoglobin":   safe_float(row.get("hemoglobin",0)),
-                "platelet":     safe_float(row.get("platelet",0)),
-                "sodium":       safe_float(row.get("sodium",0)),
-                "potassium":    safe_float(row.get("potassium",0)),
-                "cholesterol":  safe_float(row.get("cholesterol",0)),
-                "ldl":          safe_float(row.get("ldl",0)),
-                "hdl":          safe_float(row.get("hdl",0)),
-                "triglyceride": safe_float(row.get("triglyceride",0)),
-                "has_diabetes": safe_int(row.get("has_diabetes",0)),
-                "has_hypertension": safe_int(row.get("has_hypertension",0)),
-                "has_ckd":      safe_int(row.get("has_ckd",0)),
-                "has_cvd":      safe_int(row.get("has_cvd",0)),
-                "has_sepsis_hx": safe_int(row.get("has_sepsis_hx",0)),
-                "num_medications": safe_int(row.get("num_medications",0)),
-                "visit_per_year": safe_int(row.get("visit_per_year",0)),
-                "admit_per_year": safe_int(row.get("admit_per_year",0)),
-                "er_visit":     safe_int(row.get("er_visit",0)),
-                "days_since_visit": safe_int(row.get("days_since_visit",0)),
-                "province":     str(row.get("province","")),
-                "smoking":      str(row.get("smoking","")),
-                "alcohol":      str(row.get("alcohol","")),
-                "icd10_codes":  str(row.get("icd10_codes","")),
-                "medications":  str(row.get("medications","")),
-            })
-
-        all_levels = df["risk_level"].value_counts().to_dict()
-
-        return safe_json({
-            "total_filtered": total,
-            "total_patients": len(df),
-            "page":           page,
-            "per_page":       per_page,
-            "total_pages":    max(1, (total + per_page - 1) // per_page),
-            "risk_filter":    risk,
-            "model":          algo,
-            "target":         target,
-            "risk_summary": {
-                "HIGH":   int(all_levels.get("HIGH", 0)),
-                "MEDIUM": int(all_levels.get("MEDIUM", 0)),
-                "LOW":    int(all_levels.get("LOW", 0)),
-            },
-            "patients": patients,
-        })
+            def rule_label(text):
+                tl=text.lower()
+                pos_w=["ดี","เยี่ยม","ประทับใจ","แนะนำ","คุ้ม","ชอบ","excellent","great","perfect","love","good","satisfied"]
+                neg_w=["แย่","ผิดหวัง","ห่วย","ช้า","เสีย","ไม่ดี","terrible","worst","poor","bad","horrible","disappointed"]
+                p=sum(1 for w in pos_w if w in tl); n=sum(1 for w in neg_w if w in tl)
+                return "Positive" if p>n else "Negative" if n>p else "Neutral"
+            y=X.apply(rule_label); X_tr,X_te,y_tr,y_te=X,X,y,y
+
+        for m_name in models_to_run:
+            if m_name=="logistic": clf=LogisticRegression(max_iter=1000,C=0.5,random_state=42); label="Logistic + TF-IDF"
+            elif m_name=="random_forest": clf=RandomForestClassifier(n_estimators=100,random_state=42); label="Random Forest + TF-IDF"
+            else: clf=GradientBoostingClassifier(n_estimators=100,random_state=42); label="XGBoost + TF-IDF"
+            pipe=Pipeline([("tfidf",TfidfVectorizer(max_features=1500,ngram_range=(1,2),sublinear_tf=True,min_df=1)),("clf",clf)])
+            pipe.fit(X_tr,y_tr); y_pred=pipe.predict(X_te)
+            perf={}
+            if has_label and len(set(y_te))>1:
+                perf={"accuracy_pct":round(accuracy_score(y_te,y_pred)*100,1),
+                      "f1_macro_pct":round(f1_score(y_te,y_pred,average="macro",zero_division=0)*100,1),
+                      "f1_weighted_pct":round(f1_score(y_te,y_pred,average="weighted",zero_division=0)*100,1)}
+            tfidf_step=pipe.named_steps["tfidf"]; feature_names=tfidf_step.get_feature_names_out()
+            keywords={}
+            for cls in ["Positive","Negative","Neutral"]:
+                mask=y_tr==cls
+                if mask.sum()>0:
+                    vecs=tfidf_step.transform(X_tr[mask]); mean_sc=vecs.mean(axis=0).A1
+                    top_idx=mean_sc.argsort()[-10:][::-1]
+                    keywords[cls]=[str(feature_names[i]) for i in top_idx if len(str(feature_names[i]))>1][:8]
+            results[m_name]={"model_name":label,"performance":perf,"keywords":keywords}
+            pipes[m_name]=pipe
+
+        best_name=model_type if model_type!="all" else "logistic"
+        if best_name not in pipes: best_name=list(pipes.keys())[0]
+        best_pipe=pipes[best_name]; all_preds=best_pipe.predict(X)
+        all_proba=best_pipe.predict_proba(X); all_classes=best_pipe.classes_
+
+        predictions=[]
+        for i,row in df.iterrows():
+            prob_arr=all_proba[i]; pred=all_preds[i]; conf=float(prob_arr.max())
+            prob_dict={c:round(float(p)*100,1) for c,p in zip(all_classes,prob_arr)}
+            predictions.append({"review_id":str(row.get("review_id",f"REV{i:04d}")),
+                "review_text":str(row.get("review_text",""))[:200],
+                "channel":str(row.get("channel","")),"branch":str(row.get("branch","")),
+                "category":str(row.get("category","")),"date":str(row.get("date","")),
+                "rating":int(row["rating"]) if "rating" in row and pd.notna(row.get("rating")) else None,
+                "actual_sentiment":str(row.get("sentiment","")) if has_label else None,
+                "predicted_sentiment":pred,"confidence":round(conf,3),"probabilities":prob_dict})
+
+        pred_counts=Counter(all_preds); total=len(predictions)
+        sentiment_summary={
+            "Positive":pred_counts.get("Positive",0),"Neutral":pred_counts.get("Neutral",0),"Negative":pred_counts.get("Negative",0),
+            "positive_pct":round(pred_counts.get("Positive",0)/total*100,1),
+            "neutral_pct":round(pred_counts.get("Neutral",0)/total*100,1),
+            "negative_pct":round(pred_counts.get("Negative",0)/total*100,1),
+            "net_sentiment_score":round((pred_counts.get("Positive",0)-pred_counts.get("Negative",0))/total*100,1)}
+
+        channel_breakdown={}
+        if "channel" in df.columns:
+            for ch in df["channel"].dropna().unique():
+                mask=df["channel"]==ch; ch_preds=[p["predicted_sentiment"] for p,m in zip(predictions,mask) if m]
+                c2=Counter(ch_preds); n2=len(ch_preds)
+                channel_breakdown[ch]={"total":n2,"Positive":c2.get("Positive",0),"Negative":c2.get("Negative",0),"Neutral":c2.get("Neutral",0),
+                    "positive_pct":round(c2.get("Positive",0)/n2*100,1) if n2 else 0,
+                    "negative_pct":round(c2.get("Negative",0)/n2*100,1) if n2 else 0}
+
+        monthly_trend={}
+        if "month" in df.columns:
+            for mo in sorted(df["month"].dropna().unique()):
+                mask=df["month"]==mo; mo_preds=[p["predicted_sentiment"] for p,m in zip(predictions,mask) if m]
+                c4=Counter(mo_preds)
+                monthly_trend[mo]={"Positive":c4.get("Positive",0),"Negative":c4.get("Negative",0),"Neutral":c4.get("Neutral",0)}
+
+        elapsed=round(time.time()-t0,1)
+        return safe_jsonify({"total_reviews":total,"model_requested":model_type,"best_model":best_name,
+            "processing_time_sec":elapsed,"has_label":has_label,"sentiment_summary":sentiment_summary,
+            "channel_breakdown":channel_breakdown,"monthly_trend":monthly_trend,
+            "model_results":results,"predictions":predictions,
+            "top_negative":sorted([p for p in predictions if p["predicted_sentiment"]=="Negative"],
+                key=lambda x:x["confidence"],reverse=True)[:10],
+            "top_positive":sorted([p for p in predictions if p["predicted_sentiment"]=="Positive"],
+                key=lambda x:x["confidence"],reverse=True)[:5],
+            "using_default_data":using_default,"default_info":DEFAULT_INFO["reviews"] if using_default else None})
     except Exception as e:
         import traceback; print(traceback.format_exc())
-        return safe_json({"error": str(e)}), 500
+        return safe_jsonify({"error":str(e)}), 500
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False)
+    app.run(host="0.0.0.0", port=port)