"""Tests for Quantum-AI Hybrid compute backend."""

from __future__ import annotations

import math

from fusionagi.gpu.quantum_backend import QuantumBackend, QuantumCircuit, Qubit


class TestQubit:
    def test_initial_state(self) -> None:
        q = Qubit()
        p0, p1 = q.probabilities()
        assert abs(p0 - 1.0) < 1e-10
        assert abs(p1 - 0.0) < 1e-10

    def test_measure_collapses(self) -> None:
        q = Qubit()
        result = q.measure()
        assert result == 0  # |0> always measures 0
        assert abs(q.alpha) == 1.0

    def test_probabilities_sum_to_one(self) -> None:
        q = Qubit(alpha=1 / math.sqrt(2) + 0j, beta=1 / math.sqrt(2) + 0j)
        p0, p1 = q.probabilities()
        assert abs(p0 + p1 - 1.0) < 1e-10


class TestQuantumCircuit:
    def test_hadamard_creates_superposition(self) -> None:
        circ = QuantumCircuit(num_qubits=1)
        circ.h(0)
        p0, p1 = circ.qubits[0].probabilities()
        assert abs(p0 - 0.5) < 1e-10
        assert abs(p1 - 0.5) < 1e-10

    def test_x_gate_flips(self) -> None:
        circ = QuantumCircuit(num_qubits=1)
        circ.x(0)
        result = circ.qubits[0].measure()
        assert result == 1

    def test_z_gate(self) -> None:
        circ = QuantumCircuit(num_qubits=1)
        circ.z(0)
        p0, p1 = circ.qubits[0].probabilities()
        assert abs(p0 - 1.0) < 1e-10

    def test_ry_rotation(self) -> None:
        circ = QuantumCircuit(num_qubits=1)
        circ.ry(0, math.pi)  # Full rotation: |0> -> |1>
        p0, p1 = circ.qubits[0].probabilities()
        assert p1 > 0.99

    def test_measure_all(self) -> None:
        circ = QuantumCircuit(num_qubits=3)
        results = circ.measure_all()
        assert len(results) == 3
        assert all(r in (0, 1) for r in results)

    def test_reset(self) -> None:
        circ = QuantumCircuit(num_qubits=2)
        circ.h(0)
        circ.x(1)
        circ.reset()
        for q in circ.qubits:
            assert abs(q.alpha - 1.0) < 1e-10


class TestQuantumBackend:
    def test_quantum_sample(self) -> None:
        qb = QuantumBackend(num_qubits=4, num_shots=50)
        samples = qb.quantum_sample([0.5, -0.3, 0.8, 0.1])
        assert len(samples) == 50
        assert all(len(s) == 4 for s in samples)
        assert all(bit in (0, 1) for s in samples for bit in s)

    def test_quantum_sample_custom_shots(self) -> None:
        qb = QuantumBackend(num_qubits=2)
        samples = qb.quantum_sample([0.5, 0.5], num_samples=10)
        assert len(samples) == 10

    def test_quantum_optimize(self) -> None:
        qb = QuantumBackend()

        def cost_fn(params: list[float]) -> float:
            return sum((p - 0.5) ** 2 for p in params)

        result = qb.quantum_optimize(cost_fn, num_params=3, max_iterations=20)
        assert "best_cost" in result
        assert "best_params" in result
        assert result["best_cost"] <= cost_fn([0.0] * 3)

    def test_quantum_similarity_same_vector(self) -> None:
        qb = QuantumBackend()
        sim = qb.quantum_similarity([1.0, 0.0, 0.0], [1.0, 0.0, 0.0])
        assert sim > 0.9

    def test_quantum_similarity_orthogonal(self) -> None:
        qb = QuantumBackend()
        sim = qb.quantum_similarity([1.0, 0.0], [0.0, 1.0])
        assert sim < 0.6

    def test_quantum_similarity_empty(self) -> None:
        qb = QuantumBackend()
        assert qb.quantum_similarity([], []) == 0.0

    def test_get_summary(self) -> None:
        qb = QuantumBackend(num_qubits=6, num_shots=200)
        summary = qb.get_summary()
        assert summary["type"] == "QuantumBackend"
        assert summary["num_qubits"] == 6
        assert summary["backend"] == "simulator"