import gradio as gr
import yfinance as yf
import numpy as np
import pandas as pd
from scipy.signal import hilbert, butter, filtfilt
from scipy.fft import fft, ifft
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# --- 1. ADAPTIVE SIGNAL PROCESSING ENGINE ---

def adaptive_kalman_filter(z):
    """
    Dinamik Kalman Filtresi: Interference (Girişim) miktarını ölçerek 
    Q ve R parametrelerini anlık olarak optimize eder.
    """
    n = len(z)
    x_hat = np.zeros(n)
    P = np.zeros(n)
    
    # Başlangıç değerleri
    x_hat[0] = z[0]
    P[0] = 1.0
    
    # Adaptive parametreler için gözlem penceresi
    window_size = 10
    
    for k in range(1, n):
        # 1. Lokal Volatilite Analizi (Interference Tespiti)
        if k > window_size:
            local_variance = np.var(z[k-window_size:k])
            # R (Measurement Noise): Gözlemdeki gürültü arttıkça artar
            R = local_variance + 1e-2
            # Q (Process Noise): Sistemin değişim hızına adaptasyon
            Q = local_variance * 0.1 + 1e-5
        else:
            R = 1e-2
            Q = 1e-5

        # 2. Tahmin (Predict)
        x_hat_minus = x_hat[k-1]
        P_minus = P[k-1] + Q

        # 3. Güncelleme (Correct)
        K = P_minus / (P_minus + R)
        x_hat[k] = x_hat_minus + K * (z[k] - x_hat_minus)
        P[k] = (1 - K) * P_minus

    return x_hat

def wiener_deconvolution(signal, lambd=0.05):
    """
    Kanalın (Piyasanın) fiyata eklediği 'bulanıklığı' (lag) tersine çevirir.
    H_o(f) = H*(f) / (|H(f)|^2 + lambda)
    """
    n = len(signal)
    h = np.exp(-np.arange(n) / 5.0) # Basit bir kanal gecikme modeli
    H = fft(h)
    Y = fft(signal)
    H_inv = np.conj(H) / (np.abs(H)**2 + lambd)
    restored_signal = np.real(ifft(Y * H_inv))
    return restored_signal * (np.std(signal) / np.std(restored_signal))

def calculate_vsb_alpha_pro(ticker, period="6mo"):
    try:
        df = yf.download(ticker, period=period)
        if df.empty: return None, f"Hata: {ticker} için veri bulunamadı."
        
        raw_prices = df['Close'].values.flatten()
        
        # 1. Wiener Deconvolution (Sinyal Restorasyonu)
        restored_prices = wiener_deconvolution(raw_prices, lambd=0.05)
        
        # 2. VSB Demodülasyonu (I/Q Ayrışımı)
        z = hilbert(restored_prices)
        A = np.abs(z) # Envelope (Zarf)
        phase = np.unwrap(np.angle(z))
        
        # 3. Faz Hızı Momentum (w_i = d_phi / d_t)
        omega_i = np.diff(phase)
        omega_i = np.append(omega_i, omega_i[-1])
        omega_norm = np.tanh((omega_i - np.mean(omega_i)) / (np.std(omega_i) + 1e-6))
        
        # 4. Vestige Analizi & Adaptive Kalman Filtreleme
        b, a = butter(4, 0.15, btype='high')
        raw_vestige = np.abs(filtfilt(b, a, restored_prices))
        kalman_vestige = adaptive_kalman_filter(raw_vestige)
        
        # 5. SVR (Signal-to-Vestige Ratio) - Güven Skoru
        svr = 1 - (kalman_vestige / (A + 1e-6))
        svr = np.clip(svr, 0, 1)
        
        # 6. Weighted Alpha Score [-1, 1]
        alpha_raw = (0.6 * omega_norm) + (0.4 * svr * np.sign(omega_norm))
        alpha_score = np.tanh(alpha_raw)
        
        df['Restored'] = restored_prices
        df['Alpha'] = alpha_score
        df['SVR'] = svr
        df['Interference'] = raw_vestige - kalman_vestige
        
        return df, None
    except Exception as e:
        return None, f"Sistem Hatası: {str(e)}"

# --- 2. DASHBOARD & UI ---

def update_dashboard(ticker, period):
    df, error = calculate_vsb_alpha_pro(ticker, period)
    if error: return go.Figure().update_layout(title=error), error

    fig = make_subplots(
        rows=3, cols=1,
        shared_xaxes=True,
        vertical_spacing=0.05,
        row_heights=[0.5, 0.25, 0.25],
        subplot_titles=("Sinyal Restorasyonu & Zarf Analizi", "Adaptive Alpha Score (Interference Aware)", "Interference & Noise Floor")
    )

    # Plot 1: Restored vs Raw
    fig.add_trace(go.Scatter(x=df.index, y=df['Close'], name="Ham Fiyat (Laggard)", line=dict(color='#475569', width=1)), row=1, col=1)
    fig.add_trace(go.Scatter(x=df.index, y=df['Restored'], name="Restored (Wiener)", line=dict(color='#22d3ee', width=2)), row=1, col=1)

    # Plot 2: Alpha Score
    colors = ['#10b981' if x > 0 else '#ef4444' for x in df['Alpha']]
    fig.add_trace(go.Bar(x=df.index, y=df['Alpha'], name="Alpha Score", marker_color=colors), row=2, col=1)
    fig.add_hline(y=0.7, line_dash="dash", line_color="#059669", row=2, col=1)
    fig.add_hline(y=-0.7, line_dash="dash", line_color="#dc2626", row=2, col=1)

    # Plot 3: Interference
    fig.add_trace(go.Scatter(x=df.index, y=df['Interference'], name="Interference Magnitude", fill='tozeroy', line=dict(color='#f43f5e')), row=3, col=1)

    fig.update_layout(height=900, template="plotly_dark", title_text=f"VSB Alpha PRO Dashboard: {ticker}", showlegend=True, paper_bgcolor='black', plot_bgcolor='black')

    last_alpha = df['Alpha'].iloc[-1]
    last_svr = df['SVR'].iloc[-1]
    status = "GÜÇLÜ AL" if last_alpha > 0.7 else "GÜÇLÜ SAT" if last_alpha < -0.7 else "NÖTR"
    
    report = f"""
    ### 🏛️ VSB Alpha PRO Analiz Raporu: {ticker}
    - **Karar Vektörü:** `{status}` (`{last_alpha:.4f}`)
    - **Sinyal Kalitesi (SVR):** `%{last_svr*100:.2f}`
    - **Modülasyon Durumu:** {"Temiz Kanal (Low Interference)" if last_svr > 0.75 else "Kirli Kanal (High Interference)"}
    
    **Teknik Özet:** Piyasa gecikmesi Wiener dekonvolüsyonu ile telafi edilmiş, gürültü girişimleri (interference) Adaptive Kalman katmanı ile minimize edilmiştir.
    """
    return fig, report

with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
    gr.Markdown("# 🛰️ VSB Alpha PRO (Interference Aware Engine)")
    gr.Markdown("Haberleşme teorisi temelli, sinyal restorasyonu ve faz hızı momentum analizi.")
    
    with gr.Row():
        ticker_input = gr.Textbox(label="Ticker (örn: BTC-USD, AAPL, THYAO.IS)", value="BTC-USD")
        period_input = gr.Dropdown(choices=["3mo", "6mo", "1y", "2y"], value="6mo", label="Periyot")
        btn = gr.Button("Sinyali Demodüle Et", variant="primary")
    
    out_plot = gr.Plot()
    out_report = gr.Markdown()

    btn.click(update_dashboard, [ticker_input, period_input], [out_plot, out_report])

if __name__ == "__main__":
    demo.launch()