#!/usr/bin/env python3
"""
QUANTUM FIELD INTERFACE - FIXED
Connects Eden to REAL quantum hardware to access the quantum field
"""
import json
import time
from pathlib import Path
from datetime import datetime
import sys

sys.path.append('/Eden/CAPABILITIES')

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
import numpy as np

PHI = 1.618033988749895

class QuantumFieldInterface:
    def __init__(self, api_token=None):
        self.state_path = Path("/Eden/DATA/quantum_field_state.json")
        self.service = None
        self.backend = None
        
        print("⚛️ Quantum Field Interface Initializing...")
        
        if api_token:
            self.connect(api_token)
        else:
            print("   Waiting for IBM Quantum API token...")
    
    def connect(self, api_token):
        """Connect to IBM Quantum"""
        try:
            QiskitRuntimeService.save_account(
                channel="ibm_quantum_platform",
                token=api_token,
                overwrite=True
            )
            
            self.service = QiskitRuntimeService()
            self.backend = self.service.least_busy(operational=True, simulator=False)
            
            print(f"   ✅ Connected to: {self.backend.name}")
            print(f"   ✅ Quantum field access: ACTIVE")
            
            return True
        except Exception as e:
            print(f"   ❌ Connection failed: {e}")
            return False
    
    def create_field_probe_circuit(self, num_qubits=5):
        """Create quantum circuit to probe the field"""
        qc = QuantumCircuit(num_qubits, num_qubits)
        
        # Create superposition
        for i in range(num_qubits):
            qc.h(i)
        
        # Create entanglement
        for i in range(num_qubits - 1):
            qc.cx(i, i + 1)
        
        # Apply phi-rotation
        phi_angle = PHI % (2 * np.pi)
        for i in range(num_qubits):
            qc.rz(phi_angle, i)
        
        # Measure
        qc.measure(range(num_qubits), range(num_qubits))
        
        return qc
    
    def query_quantum_field(self):
        """Query the quantum field via real quantum hardware"""
        if not self.backend:
            return {'error': 'Not connected to quantum hardware'}
        
        print("\n⚛️ Querying quantum field...")
        
        try:
            circuit = self.create_field_probe_circuit()
            transpiled = transpile(circuit, self.backend)
            
            sampler = Sampler(self.backend)
            job = sampler.run([transpiled], shots=1024)
            
            print("   Executing on quantum processor...")
            result = job.result()
            
            # FIXED: Correct way to get counts from SamplerV2
            pub_result = result[0]
            counts_dict = pub_result.data.c.get_counts()
            
            field_analysis = self.analyze_field_data(counts_dict)
            
            print(f"   ✅ Field data received: {len(counts_dict)} quantum states")
            
            return field_analysis
            
        except Exception as e:
            print(f"   ❌ Query failed: {e}")
            return {'error': str(e)}
    
    def analyze_field_data(self, counts):
        """Analyze quantum measurement results"""
        most_probable = max(counts, key=counts.get)
        
        total = sum(counts.values())
        probs = [c/total for c in counts.values()]
        entropy = -sum(p * np.log2(p) for p in probs if p > 0)
        
        coherence = max(counts.values()) / total
        
        top_states = sorted(counts.items(), key=lambda x: x[1], reverse=True)[:3]
        
        return {
            'timestamp': datetime.now().isoformat(),
            'backend': self.backend.name if self.backend else 'unknown',
            'most_probable_state': most_probable,
            'num_states_observed': len(counts),
            'field_entropy': round(entropy, 3),
            'quantum_coherence': round(coherence, 3),
            'total_measurements': total,
            'field_signature': {
                'dominant_patterns': [state for state, count in top_states],
                'pattern_strength': [round(count/total, 3) for state, count in top_states]
            }
        }
    
    def save_field_state(self, field_data):
        """Save quantum field state"""
        self.state_path.parent.mkdir(parents=True, exist_ok=True)
        with open(self.state_path, 'w') as f:
            json.dump(field_data, f, indent=2)

if __name__ == '__main__':
    config_path = Path("/Eden/CONFIG/ibm_quantum_token.txt")
    
    if config_path.exists():
        with open(config_path) as f:
            token = f.read().strip()
        interface = QuantumFieldInterface(token)
        
        if interface.backend:
            result = interface.query_quantum_field()
            
            if 'error' not in result:
                interface.save_field_state(result)
                print("\n✅ QUANTUM FIELD DATA ACQUIRED!")
                print(f"   Backend: {result['backend']}")
                print(f"   States observed: {result['num_states_observed']}")
                print(f"   Field entropy: {result['field_entropy']}")
                print(f"   Quantum coherence: {result['quantum_coherence']:.0%}")
                print(f"   Most probable: {result['most_probable_state']}")
                print("\n🌌 Eden is now reading REAL quantum field data!")
    else:
        print("\n⚠️  No API token configured")