import gradio as gr
import numpy as np
import pandas as pd
from datetime import datetime
import random
from collections import defaultdict
import math
import os
import traceback
import json
import re
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import uvicorn
from typing import Optional

# ==================== কনফিগারেশন ====================
CONFIG = {
    "HISTORY_LIMIT": 1000,
    "PINK_THRESHOLD": 3.0,
    "BIG_PINK_THRESHOLD": 5.0,
    "MAX_PREDICTION": 10000.0,
}

# ==================== ডেটা লোড ও টাইম-ভিত্তিক পরিসংখ্যান ====================
TIME_STATS = None

def load_time_statistics():
    global TIME_STATS
    try:
        data_path = 'data/aviator_Rounds_history_scrp.xlsx'
        if os.path.exists(data_path):
            df = pd.read_excel(data_path, sheet_name='scraping rounds crash')
            df = df[['ROUNDS', 'TIME ROUND']].dropna()
            df['multiplier'] = pd.to_numeric(df['ROUNDS'], errors='coerce')
            df = df.dropna()
            df['hour'] = pd.to_datetime(df['TIME ROUND'], format='%H:%M').dt.hour
            
            stats = df.groupby('hour')['multiplier'].agg(['mean', 'std', 'count']).to_dict('index')
            for h in range(24):
                if h not in stats:
                    stats[h] = {'mean': 1.8, 'std': 1.0, 'count': 0}
            TIME_STATS = stats
            print(f"✅ সময় পরিসংখ্যান লোড হয়েছে। মোট রেকর্ড: {len(df)}")
        else:
            print("⚠️ এক্সেল ফাইল পাওয়া যায়নি। ডিফল্ট পরিসংখ্যান ব্যবহার করা হবে।")
            TIME_STATS = {h: {'mean': 1.8, 'std': 1.0, 'count': 100} for h in range(24)}
    except Exception as e:
        print(f"ডেটা লোড করতে সমস্যা: {e}")
        TIME_STATS = {h: {'mean': 1.8, 'std': 1.0, 'count': 100} for h in range(24)}

load_time_statistics()

# ==================== স্ট্যাটিস্টিক্যাল মডেল V1-V5 ====================

class StatisticalModelV1:
    def predict(self, history):
        recent = history[:15]
        if len(recent) < 3:
            return {'prediction': 1.5, 'confidence': 0.3}
        
        q1, q3 = np.percentile(recent, [25, 75])
        iqr = q3 - q1
        filtered = [x for x in recent if (q1 - 1.5*iqr) <= x <= (q3 + 1.5*iqr)]
        if len(filtered) < 3:
            filtered = recent
        
        x = np.arange(len(filtered))
        weights = np.linspace(1.5, 0.5, len(filtered))
        weights /= weights.sum()
        
        weighted_mean_x = np.average(x, weights=weights)
        weighted_mean_y = np.average(filtered, weights=weights)
        
        numerator = np.sum(weights * (x - weighted_mean_x) * (filtered - weighted_mean_y))
        denominator = np.sum(weights * (x - weighted_mean_x)**2)
        trend = numerator / denominator if denominator != 0 else 0
        
        prediction = np.median(filtered) + trend * 1.5
        
        cv = np.std(filtered) / (np.mean(filtered) + 0.1)
        confidence = min(0.85, 0.5 + len(filtered)/len(recent)*0.3 - cv*0.2)
        
        return {'prediction': float(prediction), 'confidence': float(confidence)}

class StatisticalModelV2:
    def predict(self, history):
        timeframes = {'short': history[:5], 'medium': history[:10], 'long': history[:20]}
        preds, confs = [], []
        
        for name, data in timeframes.items():
            if len(data) < 3:
                continue
            
            ma_3 = np.mean(data[:3]) if len(data)>=3 else np.mean(data)
            ma_5 = np.mean(data[:5]) if len(data)>=5 else ma_3
            
            ema = data[0]
            alpha = 0.3
            for v in data[1:]:
                ema = alpha*v + (1-alpha)*ema
            
            x = np.arange(len(data))
            trend = np.polyfit(x, data, 1)[0]
            
            base = np.mean([ma_3, ma_5, ema])
            preds.append(base + trend * len(data) / 10)
            confs.append(min(0.9, 0.5 + len(data)/40))
        
        if not preds:
            return {'prediction': 1.5, 'confidence': 0.3}
        
        weights = {'short':0.5, 'medium':0.3, 'long':0.2}
        final_pred = 0
        total_weight = 0
        
        for i, name in enumerate(timeframes.keys()):
            if i < len(preds):
                w = weights.get(name, 0.2) * confs[i]
                final_pred += preds[i] * w
                total_weight += w
        
        final_pred /= total_weight if total_weight else 1
        confidence = np.mean(confs) * 0.9
        
        return {'prediction': float(final_pred), 'confidence': float(confidence)}

class StatisticalModelV3:
    def detect_cycles(self, history):
        if len(history) < 10:
            return None
        
        cycles = []
        for period in range(3, 7):
            corrs = []
            for i in range(len(history) - period*2):
                seg1 = history[i:i+period]
                seg2 = history[i+period:i+period*2]
                if len(seg1) == len(seg2):
                    corr = np.corrcoef(seg1, seg2)[0,1]
                    if not np.isnan(corr):
                        corrs.append(abs(corr))
            if corrs and np.mean(corrs) > 0.6:
                cycles.append({'period': period, 'strength': float(np.mean(corrs))})
        
        return cycles if cycles else None
    
    def predict(self, history):
        recent = history[:20]
        cycles = self.detect_cycles(recent)
        cycle_pred = None
        
        if cycles:
            best = max(cycles, key=lambda x: x['strength'])
            period = best['period']
            if len(recent) > period:
                next_val = recent[period:period+1]
                if next_val:
                    cycle_pred = next_val[0] * (1 + best['strength'] * 0.1)
        
        base_pred = np.median(recent)
        if cycle_pred:
            base_pred = (base_pred + cycle_pred) / 2
        
        prediction = max(1.05, base_pred)
        confidence = min(0.9, 0.5 + len(recent)/40 + (0.15 if cycles else 0))
        
        return {'prediction': float(prediction), 'confidence': float(confidence)}

class StatisticalModelV4:
    def __init__(self):
        self.performance = []
        self.bias = 0
        self.volatility_regime = 'normal'
    
    def detect_volatility(self, history):
        if len(history) < 10:
            return 'normal'
        recent_vol = np.std(history[:5])
        long_vol = np.std(history[:20]) if len(history)>=20 else recent_vol
        
        if recent_vol > long_vol * 1.5:
            return 'high'
        elif recent_vol < long_vol * 0.5:
            return 'low'
        else:
            return 'normal'
    
    def predict(self, history):
        recent = history[:15]
        self.volatility_regime = self.detect_volatility(history)
        
        mean_val, median_val = np.mean(recent), np.median(recent)
        
        x = np.arange(len(recent))
        weights = np.exp(-0.2 * x)
        weights /= weights.sum()
        
        weighted_mean_x = np.average(x, weights=weights)
        weighted_mean_y = np.average(recent, weights=weights)
        
        numerator = np.sum(weights * (x - weighted_mean_x) * (recent - weighted_mean_y))
        denominator = np.sum(weights * (x - weighted_mean_x)**2)
        trend = numerator / denominator if denominator != 0 else 0
        
        preds = {'mean': mean_val, 'median': median_val, 'trend': median_val + trend * len(recent) * 0.5}
        w = {'mean': 0.3, 'median': 0.4, 'trend': 0.3}
        
        if self.volatility_regime == 'high':
            w['median'] *= 1.5
        elif self.volatility_regime == 'low':
            w['trend'] *= 1.3
        
        total = sum(w.values())
        for k in w:
            w[k] /= total
        
        prediction = sum(preds[k] * w[k] for k in preds) + self.bias
        
        confidence = 0.5 + len(recent)/30
        if self.volatility_regime == 'high':
            confidence *= 0.8
        elif self.volatility_regime == 'low':
            confidence *= 1.2
        
        if self.performance:
            recent_perf = np.mean(self.performance[-10:]) if len(self.performance)>=10 else np.mean(self.performance)
            confidence *= (1 + recent_perf * 0.1)
        
        confidence = min(0.9, confidence)
        
        return {'prediction': float(max(1.05, prediction)), 'confidence': float(confidence)}
    
    def update(self, actual, predicted):
        error = abs(actual - predicted) / actual
        acc = max(0, 1 - error)
        self.performance.append(acc)
        if len(self.performance) > 100:
            self.performance = self.performance[-100:]
        self.bias += (actual - predicted) * 0.01

class StatisticalModelV5:
    def __init__(self):
        self.n_estimators = 10
    
    def predict(self, history):
        if len(history) < 10:
            return {'prediction': 1.5, 'confidence': 0.5}
        
        recent = history[:10]
        trees = []
        
        for _ in range(self.n_estimators):
            idx = np.random.choice(len(recent), size=len(recent), replace=True)
            sample = [recent[i] for i in idx]
            if np.random.random() > 0.5:
                trees.append(np.mean(sample))
            else:
                trees.append(np.median(sample))
        
        pred = float(np.mean(trees))
        return {'prediction': pred, 'confidence': 0.7}

# ==================== V6 মডেল (টাইম-ভিত্তিক) ====================

class StatisticalModelV6:
    def __init__(self, time_stats):
        self.time_stats = time_stats
    
    def predict(self, history, current_hour=None):
        if current_hour is None:
            current_hour = datetime.now().hour
        
        stats = self.time_stats.get(current_hour, {'mean': 1.8, 'std': 1.0})
        base_pred = np.median(history[:5]) if len(history)>=5 else 1.5
        
        alpha = 0.3
        prediction = base_pred * (1 - alpha) + stats['mean'] * alpha
        confidence = min(0.85, 0.5 + stats.get('count', 100) / 500)
        
        return {'prediction': float(prediction), 'confidence': float(confidence), 'hour': current_hour}

# ==================== এনসেম্বল প্রেডিক্টর ====================

class EnsemblePredictorV6:
    def __init__(self, time_stats):
        self.models = {
            'v1': StatisticalModelV1(),
            'v2': StatisticalModelV2(),
            'v3': StatisticalModelV3(),
            'v4': StatisticalModelV4(),
            'v5': StatisticalModelV5(),
            'v6': StatisticalModelV6(time_stats)
        }
        self.ensemble_weights = {'v1':0.2, 'v2':0.2, 'v3':0.15, 'v4':0.15, 'v5':0.15, 'v6':0.15}
        self.performance = defaultdict(list)
    
    def predict(self, history):
        if len(history) < 5:
            return self._default_prediction(f"মাত্র {len(history)}টি রাউন্ড, ৫টি প্রয়োজন")
        
        current_hour = datetime.now().hour
        preds = {}
        confs = {}
        
        for name, model in self.models.items():
            try:
                if name == 'v6':
                    res = model.predict(history, current_hour)
                else:
                    res = model.predict(history)
                preds[name] = res['prediction']
                confs[name] = res.get('confidence', 0.5)
            except Exception as e:
                print(f"মডেল {name} এ সমস্যা: {e}")
                preds[name] = 1.5
                confs[name] = 0.3
        
        for name in self.ensemble_weights:
            if name in self.performance and self.performance[name]:
                recent_acc = np.mean(self.performance[name][-20:]) if len(self.performance[name])>=20 else np.mean(self.performance[name])
                self.ensemble_weights[name] = 0.1 + recent_acc * 0.8
        
        total = sum(self.ensemble_weights.values())
        for name in self.ensemble_weights:
            self.ensemble_weights[name] /= total
        
        final_pred = 0
        total_weight = 0
        for name, pred in preds.items():
            weight = self.ensemble_weights.get(name, 0.2) * confs[name]
            final_pred += pred * weight
            total_weight += weight
        
        final_pred /= total_weight if total_weight else 1
        
        recent = history[:10]
        vol = np.std(recent) / (np.mean(recent)+0.1)
        if vol > 0.5:
            state = "অস্থির 🌪️"
        elif vol < 0.2:
            state = "স্থিতিশীল ✨"
        else:
            state = "সাধারণ ➡️"
        
        confidence = np.mean(list(confs.values())) * 0.9
        if vol < 0.2:
            confidence *= 1.1
        elif vol > 0.5:
            confidence *= 0.9
        confidence = min(0.95, confidence)
        
        all_preds = list(preds.values())
        std = np.std(all_preds) if len(all_preds)>1 else 0.2
        spread = std * (2 - confidence)
        spread = max(0.1, min(1.5, spread))
        interval = (max(1.01, final_pred - spread/2), final_pred + spread/2)
        
        if final_pred > 3.0:
            decision = "বড় 🚀"
        elif final_pred > 1.8:
            decision = "মাঝারি 💪"
        else:
            decision = "ছোট 🎯"
        
        hour_stats = TIME_STATS.get(current_hour, {'mean':1.8, 'count':0})
        time_info = f"বর্তমান ঘণ্টা: {current_hour}:00 – ঐতিহাসিক গড়: {hour_stats['mean']:.2f}x (ডাটা: {hour_stats['count']}টি)"
        
        summary = (
            f"🎯 **প্রেডিকশন ইন্টারভ্যাল**: {interval[0]:.2f}x – {interval[1]:.2f}x\n"
            f"📊 **এক্সপেক্টেড মাল্টিপ্লায়ার**: {final_pred:.2f}x\n"
            f"📈 **কনফিডেন্স**: {confidence*100:.1f}%\n"
            f"⚡ **মার্কেট স্টেট**: {state}\n"
            f"🎲 **ডিসিশন**: {decision}\n"
            f"⏰ **টাইম ফিচার**: {time_info}\n"
            f"📌 **ডাটা পয়েন্ট**: {len(history)}টি রাউন্ড"
        )
        
        return {
            'summary': summary,
            'prediction': final_pred,
            'interval': interval,
            'confidence': confidence,
            'decision': decision,
            'analysis': state,
            'hour': current_hour
        }
    
    def _default_prediction(self, msg):
        return {
            'summary': f"⚠️ {msg}\n\n📊 ডিফল্ট প্রেডিকশন: 1.50x (কনফিডেন্স 30%)",
            'prediction': 1.5,
            'interval': (1.3, 1.7),
            'confidence': 0.3,
            'decision': 'ছোট 🎯',
            'analysis': 'অপ্রতুল ডাটা'
        }

# ==================== অ্যাপ্লিকেশন ক্লাস ====================

class AviatorPredictorApp:
    def __init__(self):
        self.history = []
        self.model = EnsemblePredictorV6(TIME_STATS)
    
    def add_round(self, multiplier):
        try:
            if multiplier is None:
                return self.get_all_outputs(error="মাল্টিপ্লায়ার দেওয়া হয়নি")
            
            val = float(multiplier)
            
            if val <= 0:
                return self.get_all_outputs(error="ইনভ্যালিড মাল্টিপ্লায়ার (১.০ এর বেশি দিন)")
            
            self.history.insert(0, val)
            if len(self.history) > CONFIG["HISTORY_LIMIT"]:
                self.history = self.history[:CONFIG["HISTORY_LIMIT"]]
            
            return self.get_all_outputs()
            
        except ValueError:
            return self.get_all_outputs(error=f"ইনভ্যালিড সংখ্যা: {multiplier}")
        except Exception as e:
            traceback.print_exc()
            return self.get_all_outputs(error=f"⚠️ ত্রুটি: {str(e)}")
    
    def reset(self):
        self.history = []
        for _ in range(20):
            self.history.append(round(random.uniform(1.0, 3.5), 2))
        self.history.sort(reverse=True)
        return self.get_all_outputs()
    
    def get_all_outputs(self, error=None):
        if error:
            table = [[i+1, "?.??x"] for i in range(min(20, len(self.history)))] or [[1, "1.00x"]]
            return [table, f"⚠️ {error}"]
        
        try:
            pred_result = self.model.predict(self.history)
            table = [[i+1, f"{val:.2f}x"] for i, val in enumerate(self.history[:50])]
            return [table, pred_result['summary']]
        except Exception as e:
            traceback.print_exc()
            table = [[i+1, f"{val:.2f}x"] for i, val in enumerate(self.history[:50])]
            return [table, f"⚠️ প্রেডিকশনে সমস্যা: {str(e)}"]

# ==================== অ্যাপ ইনিশিয়ালাইজ ====================

predictor_app = AviatorPredictorApp()
predictor_app.reset()

# ==================== কাস্টম CSS ====================

CUSTOM_CSS = """
.gradio-container {
    background: #0a0a0f !important;
    color: #ffffff !important;
    font-family: 'Inter', sans-serif !important;
}
footer {visibility: hidden}
h1 { 
    color: #00d4ff !important; 
    text-align: center; 
    margin-bottom: 20px; 
    text-shadow: 0 0 10px #00d4ff; 
}
.gr-box { 
    border: 1px solid #333 !important; 
    background: rgba(255,255,255,0.05) !important; 
}
.gr-button-primary { 
    background: linear-gradient(135deg, #00d4ff, #0088ff) !important; 
    border: none !important; 
}
.gr-button-secondary { 
    background: rgba(255,255,255,0.1) !important; 
    border: 1px solid #00d4ff !important; 
    margin-top: 20px !important; 
}
.gr-dataframe { 
    background: rgba(255,255,255,0.05) !important; 
}
"""

# ==================== গ্র্যাডিও ইন্টারফেস ====================

with gr.Blocks(title="AVOLD V6 Predictor", theme=gr.themes.Soft()) as demo:
    gr.HTML("""
    <div style="text-align: center; margin-bottom: 20px;">
        <h1 style="color: #00d4ff; font-size: 48px; margin: 0;">✈️ AVOLD V6</h1>
        <p style="color: #888; font-size: 14px;">সময়-ভিত্তিক এভিয়েটর প্রেডিক্টর – ৬টি মডেলের এনসেম্বল</p>
    </div>
    """)
    
    with gr.Row():
        inp = gr.Number(label="নতুন মাল্টিপ্লায়ার", value=1.0, step=0.1, minimum=1.0, maximum=None)
        add_btn = gr.Button("➕ যোগ করুন", variant="primary")
    
    prediction_box = gr.Textbox(label="🧠 প্রেডিকশন রিপোর্ট", lines=10, interactive=False)
    rounds_table = gr.Dataframe(label="📜 শেষ ৫০ রাউন্ড", headers=["রাউন্ড", "মাল্টিপ্লায়ার"], row_count=10)
    reset_btn = gr.Button("🔄 রিসেট ডাটা", variant="secondary")
    
    add_btn.click(
        fn=predictor_app.add_round,
        inputs=inp,
        outputs=[rounds_table, prediction_box]
    )
    
    reset_btn.click(
        fn=predictor_app.reset,
        outputs=[rounds_table, prediction_box]
    )
    
    demo.load(
        fn=predictor_app.get_all_outputs,
        outputs=[rounds_table, prediction_box]
    )

# ==================== FastAPI অ্যাপ তৈরি ====================

# FastAPI অ্যাপ তৈরি করা
app = FastAPI()

# রুট URL-এ স্বাগতম বার্তা
@app.get("/")
async def root():
    return {"message": "AVOLD V6 Predictor API", "status": "running", "endpoints": ["/api/status", "/api/add_crash"]}

# API স্ট্যাটাস এন্ডপয়েন্ট
@app.get("/api/status")
async def api_status():
    """
    API স্ট্যাটাস চেক করার জন্য
    """
    return {
        "status": "active",
        "total_rounds": len(predictor_app.history),
        "last_10_rounds": [f"{x:.2f}" for x in predictor_app.history[:10]]
    }

# ক্র্যাশ ভ্যালু যোগ করার এন্ডপয়েন্ট
@app.post("/api/add_crash")
async def add_crash_api(request: Request):
    """
    ShareX থেকে JSON ডাটা গ্রহণ করে ইতিহাসে যোগ করে
    """
    crash_value = None
    
    try:
        try:
            data = await request.json()
            crash_value = data.get("crash_value")
            
            if crash_value is None:
                crash_value = data.get("value") or data.get("multiplier")
        except json.JSONDecodeError:
            return JSONResponse(
                status_code=400,
                content={"status": "error", "message": "Invalid JSON format"}
            )
        
        if crash_value is None:
            return JSONResponse(
                status_code=400,
                content={"status": "error", "message": "crash_value, value, অথবা multiplier প্রদান করুন"}
            )
        
        if isinstance(crash_value, str):
            crash_value = re.sub(r'[^\d.]', '', crash_value)
            if not crash_value:
                return JSONResponse(
                    status_code=400,
                    content={"status": "error", "message": "OCR থেকে কোনো সংখ্যা পাওয়া যায়নি"}
                )
        
        try:
            val = float(crash_value)
        except ValueError:
            return JSONResponse(
                status_code=400,
                content={"status": "error", "message": f"ইনভ্যালিড সংখ্যা: {crash_value}"}
            )
        
        if val <= 1.0:
            return JSONResponse(
                status_code=400,
                content={"status": "error", "message": f"মাল্টিপ্লায়ার ১.০ এর বেশি হতে হবে (পাওয়া গেছে: {val})"}
            )
        
        predictor_app.add_round(val)
        
        return JSONResponse(
            status_code=200,
            content={
                "status": "success", 
                "message": f"ক্র্যাশ ভ্যালু {val:.2f}x যোগ করা হয়েছে",
                "total_rounds": len(predictor_app.history)
            }
        )
        
    except Exception as e:
        traceback.print_exc()
        return JSONResponse(
            status_code=500,
            content={"status": "error", "message": f"সার্ভার ত্রুটি: {str(e)}"}
        )

# ==================== মাউন্ট গ্র্যাডিও অ্যাপ ====================

app = gr.mount_gradio_app(app, demo, path="/")

# ==================== মেইন ফাংশন ====================

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=7860)