import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.neural_networks import SamplerQNN
from sklearn.preprocessing import StandardScaler

class QuantumFraudDetector:
    """
    Quantum-enhanced fraud detection using Variational Quantum Classifier (VQC).
    Requires quantum hardware or simulator.
    """
    
    def __init__(self, n_qubits=4, n_layers=2):
        """
        Args:
            n_qubits: Number of qubits (determines feature space dimension)
            n_layers: Number of variational layers (controls model capacity)
        """
        self.n_qubits = n_qubits
        self.n_layers = n_layers
        self.scaler = StandardScaler()
        self.vqc = None
        self.backend = Aer.get_backend('qasm_simulator')  # Use quantum simulator
        
    def prepare_quantum_circuit(self, n_features):
        """
        Create a Variational Quantum Classifier circuit.
        Uses quantum feature map and variational ansatz.
        """
        # Quantum feature map: encodes classical data into quantum state
        # Uses entanglement to capture correlations between features
        feature_map = ZZFeatureMap(
            feature_dimension=n_features,
            reps=2,
            entanglement='full'  # Full entanglement between qubits
        )
        
        # Variational ansatz: parameterized quantum circuit for learning
        ansatz = RealAmplitudes(
            num_qubits=self.n_qubits,
            reps=self.n_layers,
            entanglement='full'
        )
        
        # Create Variational Quantum Classifier
        self.vqc = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=None,  # Will be set during training
            sampler=SamplerQNN(
                circuit=QuantumCircuit(self.n_qubits),
                input_params=feature_map.parameters,
                weight_params=ansatz.parameters
            )
        )
        
        return self.vqc
    
    def encode_transaction_features(self, transaction_data):
        """
        Encode transaction features into quantum state.
        Uses quantum superposition to represent feature combinations.
        """
        # Normalize features
        normalized = self.scaler.fit_transform(transaction_data)
        
        # Map to quantum state using feature map
        # Each feature combination exists in superposition
        quantum_state = self.feature_map.bind_parameters(normalized)
        
        return quantum_state
    
    def quantum_fraud_detection(self, transaction_features):
        """
        Detect fraud using quantum machine learning.
        Leverages quantum superposition and entanglement to explore
        complex fraud patterns.
        """
        # Prepare quantum circuit
        if self.vqc is None:
            self.prepare_quantum_circuit(transaction_features.shape[1])
        
        # Encode features into quantum state
        quantum_features = self.encode_transaction_features(transaction_features)
        
        # Quantum measurement: collapse superposition to get prediction
        predictions = self.vqc.predict(quantum_features)
        
        return predictions
    
    def train_quantum_model(self, X_train, y_train):
        """
        Train the quantum classifier.
        Uses quantum optimization algorithms (e.g., VQE-inspired).
        """
        # Normalize training data
        X_scaled = self.scaler.fit_transform(X_train)
        
        # Prepare quantum circuit
        self.prepare_quantum_circuit(X_scaled.shape[1])
        
        # Train VQC (simplified - in practice uses more sophisticated optimizers)
        # This leverages quantum parallelism during optimization
        self.vqc.fit(X_scaled, y_train)
        
        return self.vqc


# Example: Quantum fraud detection on transaction data
if __name__ == "__main__":
    # Simulated transaction features
    # Features: amount, time_of_day, location_distance, transaction_frequency, etc.
    n_samples = 1000
    n_features = 4  # Must match n_qubits for this example
    
    # Generate synthetic transaction data
    X_train = np.random.randn(n_samples, n_features)
    y_train = np.random.randint(0, 2, n_samples)  # 0 = legitimate, 1 = fraud
    
    # Initialize quantum fraud detector
    detector = QuantumFraudDetector(n_qubits=n_features, n_layers=2)
    
    # Train quantum model
    print("Training quantum fraud detection model...")
    detector.train_quantum_model(X_train, y_train)
    
    # Detect fraud on new transactions
    new_transactions = np.random.randn(10, n_features)
    predictions = detector.quantum_fraud_detection(new_transactions)
    
    print(f"\nFraud predictions: {predictions}")
    print("(0 = legitimate, 1 = fraud)")
    
    print("\nQuantum advantages:")
    print("- Superposition: Explores multiple fraud patterns simultaneously")
    print("- Entanglement: Captures complex correlations between features")
    print("- Quantum interference: Amplifies fraud signals, suppresses noise")