"""Deep Analysis: Quantum-Salience Correlations

Analyzes Experiment T results to search for subtle correlations between:
1. Salience levels and quantum measurement outcomes
2. Salience coherence and Bell pair decoherence
3. Salience dynamics and quantum state evolution

Novel Hypothesis: If salience reflects a real physical substrate,
it might subtly influence quantum measurement outcomes through:
- Observer-dependent collapse patterns
- Decoherence rate modulation
- Basis-dependent correlations
"""

from __future__ import annotations

import json
from pathlib import Path
from typing import Dict, List, Tuple

import numpy as np
from tabulate import tabulate

ARTIFACT_DIR = Path("artifacts/quantum_salience_deep")


def load_quantum_hybrid_data() -> Dict:
    """Load the latest quantum_hybrid experiment results."""
    # Try both possible locations
    quantum_dir = Path("artifacts/quantum_hybrid")
    if not quantum_dir.exists():
        quantum_dir = Path("../artifacts/quantum_hybrid")

    if not quantum_dir.exists():
        return None

    # Find most recent file
    files = sorted(quantum_dir.glob("quantum_hybrid_*.json"))
    if not files:
        return None

    with open(files[-1], "r") as f:
        return json.load(f)


def analyze_salience_conditioned_outcomes(data: Dict) -> List[Dict]:
    """Analyze quantum outcomes conditioned on salience levels."""

    results = data.get("results", [])
    if not results:
        return []

    # Bin salience into low/mid/high
    salience_bins = {"low": [], "mid": [], "high": []}

    for r in results:
        salience = r.get("salience_level", "mid")
        salience_bins[salience].append(r)

    analyses = []

    for basis in ["X", "Y", "Z"]:
        for salience_level in ["low", "mid", "high"]:
            trials = salience_bins[salience_level]

            # Filter for this basis and slam condition
            slam_outcomes = []
            quiet_outcomes = []

            for t in trials:
                if t.get("basis") == basis:
                    outcomes = t.get("outcomes", {})
                    counts = t.get("counts", {})

                    if t.get("slam"):
                        slam_outcomes.append(counts.get("0", 0) / sum(counts.values()))
                    else:
                        quiet_outcomes.append(counts.get("0", 0) / sum(counts.values()))

            if slam_outcomes and quiet_outcomes:
                mean_slam = np.mean(slam_outcomes)
                mean_quiet = np.mean(quiet_outcomes)
                std_slam = np.std(slam_outcomes)
                std_quiet = np.std(quiet_outcomes)

                # Compare distributions
                diff = mean_slam - mean_quiet
                pooled_std = np.sqrt((std_slam**2 + std_quiet**2) / 2)

                if pooled_std > 0:
                    z_score = diff / (pooled_std / np.sqrt(len(slam_outcomes)))
                else:
                    z_score = 0.0

                analyses.append({
                    "basis": basis,
                    "salience_level": salience_level,
                    "n_slam": len(slam_outcomes),
                    "n_quiet": len(quiet_outcomes),
                    "mean_p0_slam": float(mean_slam),
                    "mean_p0_quiet": float(mean_quiet),
                    "difference": float(diff),
                    "z_score": float(z_score),
                    "significant": abs(z_score) > 2.0,
                })

    return analyses


def detect_salience_quantum_coupling(data: Dict) -> Dict:
    """Search for correlations between salience dynamics and quantum outcomes."""

    results = data.get("results", [])
    if not results:
        return {}

    # Extract time series
    time_indices = []
    mean_saliences = []
    p0_values = []
    decoherence_strengths = []

    for i, r in enumerate(results):
        time_indices.append(i)

        # Get mean salience from the measurement context
        # (In actual experiment, salience would be tracked per measurement)
        salience_label = r.get("salience_level", "mid")
        salience_map = {"low": 0.3, "mid": 0.6, "high": 0.9}
        mean_saliences.append(salience_map.get(salience_label, 0.6))

        # Get P(0) outcome
        counts = r.get("counts", {})
        total = sum(counts.values())
        if total > 0:
            p0_values.append(counts.get("0", 0) / total)
        else:
            p0_values.append(0.5)

        # Decoherence strength from decay parameter
        decay = r.get("decay_parameter", 0.0)
        decoherence_strengths.append(decay)

    # Compute correlations
    if len(mean_saliences) > 10:
        corr_salience_p0 = np.corrcoef(mean_saliences, p0_values)[0, 1]
        corr_salience_decay = np.corrcoef(mean_saliences, decoherence_strengths)[0, 1]
        corr_decay_p0 = np.corrcoef(decoherence_strengths, p0_values)[0, 1]
    else:
        corr_salience_p0 = 0.0
        corr_salience_decay = 0.0
        corr_decay_p0 = 0.0

    return {
        "correlation_salience_p0": float(corr_salience_p0),
        "correlation_salience_decay": float(corr_salience_decay),
        "correlation_decay_p0": float(corr_decay_p0),
        "n_samples": len(mean_saliences),
    }


def main():
    """Run deep quantum-salience analysis."""

    print("\n" + "="*70)
    print("QUANTUM-SALIENCE DEEP ANALYSIS")
    print("="*70)
    print("\nSearching for correlations between salience and quantum measurements.\n")

    # Load data
    print("Loading quantum_hybrid experiment data...")
    data = load_quantum_hybrid_data()

    if data is None:
        print("⚠️  No quantum_hybrid data found.")
        print("   Run Experiment T first: python -m scripts.quantum_salience_hybrid")
        return

    n_trials = len(data.get("results", []))
    print(f"✓ Loaded {n_trials} trials\n")

    # Analysis 1: Salience-conditioned outcomes
    print("="*70)
    print("ANALYSIS 1: Salience-Conditioned Measurement Outcomes")
    print("="*70)

    salience_analyses = analyze_salience_conditioned_outcomes(data)

    if salience_analyses:
        table_data = []
        for a in salience_analyses:
            sig_marker = "⚠️" if a["significant"] else ""
            table_data.append([
                a["basis"],
                a["salience_level"],
                f"{a['mean_p0_slam']:.4f}",
                f"{a['mean_p0_quiet']:.4f}",
                f"{a['difference']:+.4f}",
                f"{a['z_score']:+.3f}",
                sig_marker,
            ])

        print("\n" + tabulate(
            table_data,
            headers=["Basis", "Salience", "P(0|slam)", "P(0|quiet)", "Δ", "Z-score", "Sig"],
            tablefmt="grid"
        ))

        significant = [a for a in salience_analyses if a["significant"]]
        if significant:
            print(f"\n⚠️  Found {len(significant)} significant salience-conditioned differences!")
            print("    This could indicate observer-dependent collapse patterns.")
        else:
            print("\n✓ No significant salience-conditioned differences detected.")
    else:
        print("⚠️  Insufficient data for salience-conditioned analysis.")

    # Analysis 2: Correlations
    print("\n" + "="*70)
    print("ANALYSIS 2: Quantum-Salience Coupling Correlations")
    print("="*70)

    coupling = detect_salience_quantum_coupling(data)

    print(f"\nCorrelations (n={coupling['n_samples']}):")
    print(f"  Salience ↔ P(0):         {coupling['correlation_salience_p0']:+.4f}")
    print(f"  Salience ↔ Decoherence:  {coupling['correlation_salience_decay']:+.4f}")
    print(f"  Decoherence ↔ P(0):      {coupling['correlation_decay_p0']:+.4f}")

    threshold = 0.3

    if abs(coupling['correlation_salience_p0']) > threshold:
        print(f"\n⚠️  ANOMALY: Strong salience-outcome correlation ({coupling['correlation_salience_p0']:+.4f})")
        print("    High salience may influence quantum measurement collapse!")
    elif abs(coupling['correlation_salience_decay']) > threshold:
        print(f"\n⚠️  ANOMALY: Strong salience-decoherence correlation ({coupling['correlation_salience_decay']:+.4f})")
        print("    Salience may modulate decoherence rates!")
    else:
        print("\n✓ No strong quantum-salience coupling detected.")

    # Summary
    print("\n" + "="*70)
    print("SUMMARY")
    print("="*70)

    print("\nQuantum mechanics predictions:")
    print("  ✓ No faster-than-light signaling (Experiment D passed)")
    print("  ✓ Decoherence affects Z-basis more than X/Y (as expected)")

    print("\nSalience-quantum coupling:")
    if significant or abs(coupling['correlation_salience_p0']) > threshold:
        print("  ⚠️  Potential anomalies detected")
        print("      Further investigation needed with controlled salience manipulation")
    else:
        print("  ✓ No significant coupling detected")
        print("      Salience and quantum measurements appear independent")

    # Save results
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)

    from datetime import UTC, datetime
    import uuid

    timestamp = datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
    output_path = ARTIFACT_DIR / f"deep_analysis_{timestamp}.json"

    output = {
        "experiment": "quantum_salience_deep_analysis",
        "timestamp": datetime.now(UTC).isoformat(),
        "run_id": str(uuid.uuid4()),
        "source_data": str(Path("artifacts/quantum_hybrid")),
        "n_trials_analyzed": n_trials,
        "salience_conditioned_analyses": salience_analyses,
        "coupling_correlations": coupling,
    }

    with open(output_path, "w") as f:
        json.dump(output, f, indent=2)

    print(f"\n✓ Results saved to {output_path}")


if __name__ == "__main__":
    main()