# ===== PROTOCOL DE COMUNICARE CUANTICĂ: MARIUS → ALICE+BOB =====
!pip install -q qiskit qiskit-ibm-runtime matplotlib

import getpass
import numpy as np
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

print("="*70)
print("📡 PROTOCOL COMUNICARE CUANTICĂ")
print("="*70)
print("\n🎛️  MARIUS = Transmițător (controlează switch E/S)")
print("👥 ALICE + BOB = Receptori (colaborează pentru decodare)")
print("\n📨 PROTOCOL:")
print("   • Marius trimite bit '0' → creează perechi SEPARABILE (S)")
print("   • Marius trimite bit '1' → creează perechi ENTANGLED (E)")
print("   • Alice și Bob măsoară fiecare qubit-ul lor")
print("   • Alice și Bob compară rezultate → calculează S (CHSH)")
print("   • S ≤ 2 → decodifică '0' | S > 2 → decodifică '1'")
print("="*70 + "\n")

# ===== Setup IBM Quantum =====
token = getpass.getpass("🔑 IBM Quantum API token: ").strip()
service = QiskitRuntimeService(channel="ibm_quantum_platform", token=token)
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=2)
print(f"✓ Backend selectat: {backend.name}\n")

pm = generate_preset_pass_manager(target=backend.target, optimization_level=3)
sampler = Sampler(mode=backend)

# ===== Funcții pentru circuite =====
def marius_creates_separable():
    """Marius creează pereche SEPARABILĂ → bit '0'"""
    qc = QuantumCircuit(2, 2, name="SEPARABLE")
    qc.h(0)  # Qubit pentru Alice
    qc.h(1)  # Qubit pentru Bob (INDEPENDENT!)
    qc.measure([0, 1], [0, 1])
    return qc

def marius_creates_entangled():
    """Marius creează pereche ENTANGLED → bit '1'"""
    qc = QuantumCircuit(2, 2, name="ENTANGLED")
    qc.h(0)      # Superpoziție
    qc.cx(0, 1)  # ENTANGLEMENT!
    qc.measure([0, 1], [0, 1])
    return qc

def alice_bob_calculate_correlation(counts):
    """Alice și Bob calculează corelația E din măsurătorile lor"""
    shots = sum(counts.values())
    p00 = counts.get("00", 0) / shots
    p01 = counts.get("01", 0) / shots
    p10 = counts.get("10", 0) / shots
    p11 = counts.get("11", 0) / shots
    E = (p00 + p11) - (p01 + p10)
    return E

def alice_bob_decode_message(all_counts):
    """
    Alice și Bob decodifică mesajul calculând 'S-like' măsură simplificată.
    Pentru simplitate, folosim |E| direct în loc de S complet cu 4 baze.
    """
    correlations = [alice_bob_calculate_correlation(c) for c in all_counts]
    avg_corr = np.mean([abs(e) for e in correlations])
    
    # Decizie: 
    # Separabil → corelații slabe (|E| ~ 0-0.3)
    # Entangled → corelații puternice (|E| ~ 0.7-1.0)
    threshold = 0.5
    
    return 1 if avg_corr > threshold else 0, avg_corr

# ===== MARIUS transmite mesaj =====
print("📝 Marius alege un mesaj de transmis...")
message_to_send = [1, 0, 1, 1, 0, 0, 1, 0]  # Exemplu: poate fi orice secvență
print(f"📤 Mesaj original (Marius): {message_to_send}\n")

decoded_message = []
SHOTS = 2000
REPEATS = 3  # Repetări pentru fiecare bit (reduce zgomotul)

print("🔄 Transmisie în curs...\n")

for bit_index, bit in enumerate(message_to_send):
    print(f"📡 Bit {bit_index+1}/{len(message_to_send)}: Marius trimite '{bit}'")
    
    # Marius selectează circuitul
    if bit == 0:
        circuit = marius_creates_separable()
        print("   → Marius: Switch pe SEPARABIL (S)")
    else:
        circuit = marius_creates_entangled()
        print("   → Marius: Switch pe ENTANGLED (E)")
    
    # Marius rulează circuitul de mai multe ori pentru statistici mai bune
    circuit_t = pm.run(circuit)
    
    all_counts = []
    for repeat in range(REPEATS):
        job = sampler.run([circuit_t], shots=SHOTS)
        result = job.result()
        counts = result[0].join_data().get_counts()
        all_counts.append(counts)
    
    # Alice și Bob primesc rezultatele și decodifică
    decoded_bit, correlation = alice_bob_decode_message(all_counts)
    decoded_message.append(decoded_bit)
    
    match = "✅" if decoded_bit == bit else "❌"
    print(f"   → Alice+Bob decodifică: '{decoded_bit}' {match} (|E|={correlation:.3f})")
    print()

# ===== Rezultate finale =====
accuracy = sum(1 for i in range(len(message_to_send)) if message_to_send[i] == decoded_message[i])
accuracy_percent = (accuracy / len(message_to_send)) * 100

print("="*70)
print("📊 REZULTATE FINALE")
print("="*70)
print(f"📤 Mesaj trimis (Marius):     {message_to_send}")
print(f"📥 Mesaj decodat (Alice+Bob): {decoded_message}")
print(f"\n🎯 Acuratețe: {accuracy}/{len(message_to_send)} biți corecți ({accuracy_percent:.0f}%)")
print("="*70)

if accuracy_percent >= 75:
    print("\n✅ SUCCES! Protocolul funcționează!")
    print("   → Alice și Bob pot decodifica corect ce transmite Marius")
    print("   → Comunicarea cuantică prin controlul entanglement-ului este validată!")
elif accuracy_percent >= 50:
    print("\n⚠️  PARȚIAL: Funcționează dar cu erori (zgomot hardware)")
    print("   → Creșteți SHOTS sau REPEATS pentru acuratețe mai bună")
else:
    print("\n❌ EȘEC: Prea mult zgomot hardware")
    print("   → Încercați alt backend sau mai multe repetări")

print("\n💡 DE CE FUNCȚIONEAZĂ:")
print("   1. Marius controlează SURSA (E vs S)")
print("   2. Alice și Bob MĂsoară independent fiecare qubit-ul lor")
print("   3. Alice și Bob COLABOREAZĂ după → compară rezultate")
print("   4. Din CORELAȚII detectează tipul de pereche → decodifică bitul!")
print("\n✅ Nu încalcă teorema no-communication (Alice+Bob trebuie să comunice)")
print("✅ Protocol valid de comunicare cuantică!")
print("✅ Aplicații: detectare manipulare canal, autentificare sursă, etc.")