"""
TBO Oracle - Hugging Face Space
================================
Temporal Bispectral Operator for blockchain-anchored predictions.

"THE SHAPE IS THE ORACLE" - We reveal, not compute.
"""

import gradio as gr
import numpy as np
import hashlib
import time
from datetime import datetime, timezone
from scipy import stats

# ═══════════════════════════════════════════════════════════════════════════
# TBO CORE FUNCTIONS
# ═══════════════════════════════════════════════════════════════════════════

def compute_cross_bispectrum_fast(signal, nfft=None):
    """Vectorized bispectrum computation."""
    signal = np.asarray(signal, dtype=np.float64)
    N = len(signal)
    if nfft is None:
        nfft = N
    X = np.fft.fft(signal, n=nfft)
    idx = np.arange(nfft)
    i_grid, j_grid = np.meshgrid(idx, idx, indexing='ij')
    k_grid = (i_grid + j_grid) % nfft
    B = X[i_grid] * X[j_grid] * np.conj(X[k_grid])
    return B


def compute_tbo_scalar(signal, nfft=None):
    """Compute the TBO scalar Lambda."""
    signal = np.asarray(signal, dtype=np.float64)
    N = len(signal)
    if nfft is None:
        nfft = N
    B = compute_cross_bispectrum_fast(signal, nfft=nfft)
    half = nfft // 2
    mask = np.zeros((nfft, nfft), dtype=bool)
    for i in range(1, half):
        for j in range(1, half):
            if i + j < half:
                mask[i, j] = True
    magnitudes = np.abs(B[mask])
    if len(magnitudes) == 0:
        return 0.0
    return float(np.mean(magnitudes))


def compute_tbo_zscore(signal, n_null=100, seed=None):
    """Compute z-score relative to null distribution."""
    rng = np.random.default_rng(seed)
    signal = np.asarray(signal, dtype=np.float64)
    lam_obs = compute_tbo_scalar(signal)
    null_lambdas = np.empty(n_null)
    for i in range(n_null):
        perm = rng.permutation(signal)
        null_lambdas[i] = compute_tbo_scalar(perm)
    mu = np.mean(null_lambdas)
    sigma = np.std(null_lambdas, ddof=1)
    if sigma < 1e-15:
        sigma = 1e-15
    z = (lam_obs - mu) / sigma
    return float(z), float(lam_obs), float(mu), float(sigma), null_lambdas


def classify_signal(z_score):
    """Classify based on z-score."""
    if z_score < -1.96:
        return 'DEFICIT'
    elif z_score > 1.96:
        return 'EXCESS'
    return 'NORMAL'


def _sieve_primes(limit):
    """Sieve of Eratosthenes."""
    is_prime = [True] * (limit + 1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(limit**0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, limit + 1, i):
                is_prime[j] = False
    return [i for i in range(2, limit + 1) if is_prime[i]]


def generate_cyclotomic(N, order=7, seed=None):
    """Generate cyclotomic signal with prime harmonics."""
    rng = np.random.default_rng(seed)
    t = np.arange(N, dtype=np.float64)
    primes = _sieve_primes(N // 2)[:order]
    signal = np.zeros(N)
    for p in primes:
        amp = rng.uniform(0.5, 2.0)
        phase = rng.uniform(0, 2 * np.pi)
        signal += amp * np.sin(2 * np.pi * p * t / N + phase)
    signal += 0.1 * rng.standard_normal(N)
    return signal


# ═══════════════════════════════════════════════════════════════════════════
# SIGNAL COLLECTORS
# ═══════════════════════════════════════════════════════════════════════════

def collect_entropy(n=256, seed=None):
    """System entropy signal."""
    rng = np.random.default_rng(seed)
    arr = rng.integers(0, 2**32, size=n, dtype=np.uint32).astype(np.float64)
    return (arr - arr.mean()) / (arr.std() + 1e-15)


def collect_clock_jitter(n=256):
    """Clock timing jitter."""
    timestamps = []
    for _ in range(n * 4):
        timestamps.append(time.perf_counter_ns())
    deltas = np.diff(timestamps).astype(np.float64)
    # Subsample
    block = len(deltas) // n
    signal = np.array([deltas[i*block:(i+1)*block].mean() for i in range(n)])
    return (signal - signal.mean()) / (signal.std() + 1e-15)


def collect_hash_chain(n=256, seed=None):
    """SHA-256 hash chain."""
    rng = np.random.default_rng(seed)
    h = rng.bytes(32)
    values = np.empty(n, dtype=np.float64)
    for i in range(n):
        h = hashlib.sha256(h + i.to_bytes(4, 'big')).digest()
        values[i] = float(int.from_bytes(h[:4], 'big'))
    return (values - values.mean()) / (values.std() + 1e-15)


def collect_cyclotomic(n=256, seed=None):
    """Cyclotomic calibration signal."""
    signal = generate_cyclotomic(n, order=7, seed=seed)
    return (signal - signal.mean()) / (signal.std() + 1e-15)


# ═══════════════════════════════════════════════════════════════════════════
# ORACLE PREDICTION
# ═══════════════════════════════════════════════════════════════════════════

def run_oracle_prediction(question: str, deadline: str, n_samples: int = 256, n_null: int = 100):
    """Run full TBO Oracle prediction."""
    
    # Generate question-based seed
    q_hash = hashlib.sha256(question.encode()).hexdigest()
    base_seed = int(q_hash[:8], 16)
    
    # Collect signals from 4 sources (simplified for demo)
    sources = {
        "entropy": collect_entropy(n_samples, seed=base_seed),
        "clock": collect_clock_jitter(n_samples),
        "hash_chain": collect_hash_chain(n_samples, seed=base_seed + 1),
        "cyclotomic": collect_cyclotomic(n_samples, seed=base_seed + 2),
    }
    
    results = {}
    predictions = []
    z_scores = []
    
    for name, signal in sources.items():
        z, lam, mu, sigma, null_dist = compute_tbo_zscore(signal, n_null=n_null, seed=base_seed)
        classification = classify_signal(z)
        prediction = 1 if z < -1.96 else 0
        
        results[name] = {
            "z_score": round(z, 4),
            "lambda": round(lam, 6),
            "classification": classification,
            "prediction": "YES" if prediction else "NO",
        }
        predictions.append(prediction)
        z_scores.append(abs(z))
    
    # Consensus
    vote_count = sum(predictions)
    consensus = "YES" if vote_count >= 2 else "NO"
    
    # Confidence
    mean_z = np.mean(z_scores)
    if mean_z >= 10:
        confidence = "HIGH"
    elif mean_z >= 3:
        confidence = "MEDIUM"
    elif mean_z >= 1:
        confidence = "LOW"
    else:
        confidence = "UNCERTAIN"
    
    # Probability estimate
    k = 0.25
    prob = 1.0 / (1.0 + np.exp(-k * mean_z))
    prob = max(0.5, min(prob, 0.95))
    
    return results, consensus, confidence, prob, vote_count


def format_results(question, deadline, results, consensus, confidence, prob, votes):
    """Format results as markdown."""
    
    # Header
    md = f"""
# 🔮 TBO Oracle Prediction

**Question:** {question}  
**Deadline:** {deadline}  
**Timestamp:** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}

---

## 📊 Prediction Result

| Metric | Value |
|--------|-------|
| **Consensus** | **{consensus}** |
| **Confidence** | {confidence} |
| **Probability** | {prob:.1%} |
| **Vote** | {votes}/4 sources |

---

## 🔬 Per-Source Analysis

| Source | Z-Score | Classification | Prediction |
|--------|---------|----------------|------------|
"""
    
    for name, data in results.items():
        emoji = "🔴" if data["classification"] == "DEFICIT" else "⚪" if data["classification"] == "NORMAL" else "🟣"
        md += f"| {name} | {data['z_score']:.2f} | {emoji} {data['classification']} | {data['prediction']} |\n"
    
    md += f"""
---

## 🧬 Methodology

- **Algorithm:** Temporal Bispectral Operator (TBO)
- **Signal Sources:** 4 independent channels
- **Null Surrogates:** 100 permutations per source
- **Threshold:** z < -1.96 (95% confidence deficit)

> *"The shape is the oracle — we reveal, not compute."*

---

📄 **Paper:** [On-Chain (BSV)](https://plugins.whatsonchain.com/api/plugin/main/657b8e90425aeed06b435a16cc759c1d594308bd815535b1628a2df7bbc75c23/0)  
🔗 **GitHub:** [OriginNeuralAI/Oracle](https://github.com/OriginNeuralAI/Oracle)
"""
    
    return md


def predict(question: str, deadline: str, n_samples: int, n_null: int):
    """Main prediction function for Gradio."""
    
    if not question.strip():
        return "❌ Please enter a question."
    
    if not deadline:
        return "❌ Please select a deadline."
    
    try:
        results, consensus, confidence, prob, votes = run_oracle_prediction(
            question, deadline, int(n_samples), int(n_null)
        )
        return format_results(question, deadline, results, consensus, confidence, prob, votes)
    except Exception as e:
        return f"❌ Error: {str(e)}"


# ═══════════════════════════════════════════════════════════════════════════
# GRADIO INTERFACE
# ═══════════════════════════════════════════════════════════════════════════

EXAMPLES = [
    ["Will BTC exceed $150k by December 2026?", "2026-12-31", 256, 100],
    ["Will there be a major AI breakthrough in 2026?", "2026-12-31", 256, 100],
    ["Will SpaceX land humans on Mars by 2030?", "2030-12-31", 256, 100],
    ["Will the Fed cut rates in Q2 2026?", "2026-06-30", 256, 100],
]

with gr.Blocks(
    title="TBO Oracle",
    theme=gr.themes.Base(
        primary_hue="teal",
        secondary_hue="blue",
        neutral_hue="slate",
    ),
    css="""
    .gradio-container { max-width: 900px !important; }
    .gr-button-primary { background: linear-gradient(135deg, #00d4aa, #0088ff) !important; }
    """
) as demo:
    
    gr.Markdown("""
    # 🔮 TBO Oracle
    ### Temporal Bispectral Operator — Blockchain-Anchored Predictions
    
    > *"The shape is the oracle — we reveal, not compute."*
    
    TBO Oracle uses **bispectral analysis** and **Two-State Vector Formalism (TSVF)** 
    to detect retrocausal signals in independent noise sources. When sources converge 
    despite their independence, the topology reveals the answer.
    
    ---
    """)
    
    with gr.Row():
        with gr.Column(scale=2):
            question = gr.Textbox(
                label="🎯 Question",
                placeholder="Ask a binary yes/no question about the future...",
                lines=2,
            )
            deadline = gr.Textbox(
                label="📅 Deadline",
                placeholder="YYYY-MM-DD",
                value="2026-12-31",
            )
        
        with gr.Column(scale=1):
            n_samples = gr.Slider(
                label="Signal Length",
                minimum=64,
                maximum=512,
                value=256,
                step=64,
            )
            n_null = gr.Slider(
                label="Null Surrogates",
                minimum=50,
                maximum=200,
                value=100,
                step=25,
            )
    
    predict_btn = gr.Button("🔮 Query the Oracle", variant="primary", size="lg")
    
    output = gr.Markdown(label="Prediction")
    
    predict_btn.click(
        fn=predict,
        inputs=[question, deadline, n_samples, n_null],
        outputs=output,
    )
    
    gr.Examples(
        examples=EXAMPLES,
        inputs=[question, deadline, n_samples, n_null],
    )
    
    gr.Markdown("""
    ---
    
    ### 📚 About TBO Oracle
    
    **Key Concepts:**
    - **Bispectral Analysis:** Detects third-order phase coupling invisible to power spectrum
    - **H₂=0 Topology:** Manifold closure condition for prediction convergence
    - **TSVF:** Two-State Vector Formalism for retrocausal signal detection
    - **Dissipative Channels:** Independent noise sources as computational assets
    
    **Sources:**
    - 📄 [On-Chain Paper (BSV)](https://plugins.whatsonchain.com/api/plugin/main/657b8e90425aeed06b435a16cc759c1d594308bd815535b1628a2df7bbc75c23/0)
    - 🔗 [GitHub Repository](https://github.com/OriginNeuralAI/Oracle)
    - 🧠 [SmartLedger Solutions](https://smartledger.solutions)
    
    ---
    
    *Built by Bryan Daugherty | SmartLedger Solutions | 2026*
    """)

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