"""
Publicly hosted Quantum Contextual Variational Challenge script.
"""

from dataclasses import dataclass
from typing import Any, Dict, List, Tuple
import json
import math
import random


with open("customer_samples/benchmark_config.json", "r", encoding="utf-8") as fh:
    DEFAULT_CONFIG = json.load(fh)


@dataclass
class ContextSnapshot:
    cycle: int
    context_name: str
    parameters: List[float]
    diagnostics: Dict[str, Any]


def preprocess(config: Dict[str, Any]) -> Dict[str, Any]:
    mu_values = [asset["mu"] for asset in config["assets"]]
    sigma_values = [asset["sigma"] for asset in config["assets"]]
    returns_norm = [m / max(mu_values) for m in mu_values]
    penalties = [math.exp(s) / sum(math.exp(x) for x in sigma_values) for s in sigma_values]
    return {
        "returns_norm": returns_norm,
        "penalties": penalties,
        "covariance": config["covariance"],
        "target_return": config["target_return"],
    }


def quantum_kernel(parameters: List[float], cycle: int, config: Dict[str, Any]) -> Tuple[List[float], Dict[str, Any]]:
    random.seed(config["seed"] + cycle)
    updated = [param - 0.01 * math.sin(param + cycle) for param in parameters]
    diagnostics = {
        "energy": -1.5 - 0.05 * cycle + random.uniform(-0.01, 0.01),
        "fidelity": 0.93 + random.uniform(-0.005, 0.005),
    }
    return updated, diagnostics


def postprocess(snapshots: List[ContextSnapshot], derived: Dict[str, Any]) -> Dict[str, Any]:
    avg_energy = sum(s.diagnostics["energy"] for s in snapshots) / len(snapshots)
    avg_fidelity = sum(s.diagnostics["fidelity"] for s in snapshots) / len(snapshots)
    baseline_energy = -1.3
    variance_reduction = (baseline_energy - avg_energy) / abs(baseline_energy)
    return {
        "avg_energy": avg_energy,
        "avg_fidelity": avg_fidelity,
        "variance_reduction_pct": variance_reduction * 100,
        "target_return": derived["target_return"],
    }


def run_benchmark(config: Dict[str, Any]) -> Dict[str, Any]:
    derived = preprocess(config)
    random.seed(config["seed"])
    parameters = [random.uniform(-math.pi, math.pi) for _ in range(config["qubits"])]
    snapshots: List[ContextSnapshot] = []
    for cycle in range(config["context_cycles"]):
        context_name = f"context_cycle_{cycle}"
        parameters, diagnostics = quantum_kernel(parameters, cycle, config)
        snapshots.append(
            ContextSnapshot(
                cycle=cycle,
                context_name=context_name,
                parameters=parameters[:8],
                diagnostics=diagnostics,
            )
        )
    metrics = postprocess(snapshots, derived)
    return {
        "job_name": config["job_name"],
        "metrics": metrics,
        "snapshots": [s.__dict__ for s in snapshots],
    }


if __name__ == "__main__":
    print(json.dumps(run_benchmark(DEFAULT_CONFIG), indent=2))