#!/usr/bin/env python3
"""
TESSERACT-NODE v1.0 — 4D Offline Quantum Server

A high-performance quantum computing server implementing 4D spacetime coordinates,
quantum entanglement operations, GHZ states, and Grover's search algorithm.

Copyright Daniel Harding - RomanAILabs
Fixed for Qiskit 1.0+ | Offline | Linux
Modified: Added Grover's search in 4D memory

Features:
    - 4D Spacetime coordinate system with relativistic calculations
    - Quantum entanglement and Bell pair generation
    - GHZ state creation for multi-qubit systems
    - Grover's quantum search algorithm
    - HyperMemory 4D data storage system
    - RESTful API with comprehensive error handling
    - Background spacetime drift simulation
"""

import logging
import threading
import time
from dataclasses import dataclass
from datetime import datetime
from typing import Dict, Optional, Tuple, Any

import numpy as np
from flask import Flask, jsonify, request, Response
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.backends import AerSimulator as AerSimulatorType

# ============================================================================
# CONFIGURATION
# ============================================================================

@dataclass
class Config:
    """Application configuration settings."""
    host: str = '127.0.0.1'
    port: int = 8888
    debug: bool = False
    log_level: str = 'INFO'
    drift_interval: float = 10.0  # seconds
    default_shots: int = 1024
    max_qubits: int = 16
    speed_of_light: float = 299792458.0  # m/s


# ============================================================================
# LOGGING SETUP
# ============================================================================

def setup_logging(level: str = 'INFO') -> None:
    """Configure application logging.
    
    Args:
        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
    """
    logging.basicConfig(
        level=getattr(logging, level.upper()),
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )


logger = logging.getLogger(__name__)
config = Config()


# ============================================================================
# 4D SPACETIME COORDINATES
# ============================================================================

class Spacetime4D:
    """
    Represents a 4D spacetime coordinate system with relativistic calculations.
    
    Coordinates are stored as (t, x, y, z) where t is time and (x, y, z) are
    spatial coordinates. The time coordinate is converted to spatial units
    using the speed of light for relativistic calculations.
    
    Attributes:
        c: Speed of light in m/s (default: 299792458.0)
        t: Time coordinate
        x: X spatial coordinate
        y: Y spatial coordinate
        z: Z spatial coordinate
    """
    
    def __init__(self, c: float = config.speed_of_light) -> None:
        """Initialize 4D spacetime coordinates.
        
        Args:
            c: Speed of light constant (default: 299792458.0 m/s)
        """
        self.c: float = c
        self.t: float = 0.0
        self.x: float = 0.0
        self.y: float = 0.0
        self.z: float = 0.0
        logger.debug(f"Initialized Spacetime4D at origin with c={c}")
    
    def move(self, dt: float, dx: float, dy: float, dz: float) -> Tuple[float, float, float, float]:
        """
        Move through 4D spacetime by specified increments.
        
        Args:
            dt: Time increment
            dx: X spatial increment
            dy: Y spatial increment
            dz: Z spatial increment
        
        Returns:
            Tuple of (c*t, x, y, z) representing the new position in spacetime
        """
        self.t += dt
        self.x += dx
        self.y += dy
        self.z += dz
        position = (self.c * self.t, self.x, self.y, self.z)
        logger.debug(f"Moved to position: {position}")
        return position
    
    def get_position(self) -> Tuple[float, float, float, float]:
        """
        Get current 4D spacetime position.
        
        Returns:
            Tuple of (c*t, x, y, z) representing current position
        """
        return (self.c * self.t, self.x, self.y, self.z)
    
    def reset(self) -> None:
        """Reset all coordinates to origin."""
        self.t = self.x = self.y = self.z = 0.0
        logger.debug("Reset Spacetime4D to origin")


# ============================================================================
# QUANTUM ENGINE
# ============================================================================

class QuantumCore:
    """
    Quantum computing core using Qiskit AerSimulator.
    
    Provides methods for creating entangled pairs, GHZ states, and
    performing Grover's search algorithm.
    
    Attributes:
        backend: Qiskit AerSimulator backend instance
    """
    
    def __init__(self, backend: Optional[AerSimulatorType] = None) -> None:
        """Initialize quantum computing backend.
        
        Args:
            backend: Optional custom backend (default: AerSimulator)
        """
        try:
            self.backend: AerSimulatorType = backend or AerSimulator()
            logger.info("QuantumCore initialized successfully")
        except Exception as e:
            logger.error(f"Failed to initialize QuantumCore: {e}")
            raise
    
    def create_entangled_pair(self, shots: int = config.default_shots) -> str:
        """
        Create a Bell pair (maximally entangled qubit pair).
        
        Creates a Bell state |Φ+⟩ = (|00⟩ + |11⟩) / √2 using Hadamard
        and CNOT gates.
        
        Args:
            shots: Number of measurement shots (default: 1024)
        
        Returns:
            Binary string representing the measurement result
        
        Raises:
            RuntimeError: If quantum circuit execution fails
        """
        try:
            qc = QuantumCircuit(2, 2)
            qc.h(0)  # Create superposition
            qc.cx(0, 1)  # Entangle qubits
            qc.measure([0, 1], [0, 1])
            
            job = self.backend.run(transpile(qc, self.backend), shots=shots)
            result = job.result()
            counts = result.get_counts()
            
            # Return most probable result
            result_str = max(counts, key=counts.get) if counts else "00"
            logger.debug(f"Created entangled pair: {result_str}")
            return result_str
        except Exception as e:
            logger.error(f"Failed to create entangled pair: {e}")
            raise RuntimeError(f"Quantum entanglement failed: {e}") from e
    
    def ghz_state(self, n: int = 4, shots: int = config.default_shots) -> Dict[str, int]:
        """
        Create a Greenberger-Horne-Zeilinger (GHZ) state.
        
        GHZ states are maximally entangled states of n qubits:
        |GHZ⟩ = (|0...0⟩ + |1...1⟩) / √2
        
        Args:
            n: Number of qubits (default: 4)
            shots: Number of measurement shots (default: 1024)
        
        Returns:
            Dictionary mapping measurement outcomes to counts
        
        Raises:
            ValueError: If n is less than 2 or exceeds max_qubits
            RuntimeError: If quantum circuit execution fails
        """
        if n < 2:
            raise ValueError(f"Number of qubits must be at least 2, got {n}")
        if n > config.max_qubits:
            raise ValueError(f"Number of qubits exceeds maximum of {config.max_qubits}")
        
        try:
            qc = QuantumCircuit(n, n)
            qc.h(0)  # Create superposition on first qubit
            for i in range(n - 1):
                qc.cx(i, i + 1)  # Entangle with next qubit
            qc.measure_all()
            
            job = self.backend.run(transpile(qc, self.backend), shots=shots)
            result = job.result()
            counts = result.get_counts()
            
            logger.debug(f"Created GHZ state with {n} qubits: {counts}")
            return counts
        except Exception as e:
            logger.error(f"Failed to create GHZ state: {e}")
            raise RuntimeError(f"GHZ state creation failed: {e}") from e
    
    def grover_search(
        self,
        n_qubits: int = 2,
        target: str = '11',
        iterations: Optional[int] = None,
        shots: int = config.default_shots
    ) -> str:
        """
        Perform Grover's quantum search algorithm.
        
        Grover's algorithm provides a quadratic speedup for unstructured search.
        This implementation performs the optimal number of iterations based on
        the search space size.
        
        Args:
            n_qubits: Number of qubits (search space size = 2^n_qubits)
            target: Target binary string to search for (default: '11')
            iterations: Optional number of Grover iterations (auto-calculated if None)
            shots: Number of measurement shots (default: 1024)
        
        Returns:
            Binary string representing the measurement result
        
        Raises:
            ValueError: If target length doesn't match n_qubits or invalid target
            RuntimeError: If quantum circuit execution fails
        """
        if len(target) != n_qubits:
            raise ValueError(f"Target length {len(target)} must match n_qubits {n_qubits}")
        if not all(bit in '01' for bit in target):
            raise ValueError(f"Target must be a binary string, got {target}")
        if n_qubits > config.max_qubits:
            raise ValueError(f"Number of qubits exceeds maximum of {config.max_qubits}")
        
        try:
            # Calculate optimal number of iterations
            if iterations is None:
                N = 2 ** n_qubits
                optimal_iterations = int(np.pi / 4 * np.sqrt(N))
                iterations = max(1, optimal_iterations)
            
            qc = QuantumCircuit(n_qubits, n_qubits)
            
            # Initialize superposition
            for i in range(n_qubits):
                qc.h(i)
            
            # Grover iterations
            for _ in range(iterations):
                # Oracle: mark the target state
                self._apply_grover_oracle(qc, n_qubits, target)
                
                # Diffusion operator: amplify the marked state
                self._apply_grover_diffusion(qc, n_qubits)
            
            # Measure
            qc.measure(range(n_qubits), range(n_qubits))
            
            job = self.backend.run(transpile(qc, self.backend), shots=shots)
            result = job.result()
            counts = result.get_counts()
            
            # Return most probable result
            result_str = max(counts, key=counts.get) if counts else target
            logger.debug(f"Grover search completed: {result_str} (target: {target})")
            return result_str
        except Exception as e:
            logger.error(f"Grover search failed: {e}")
            raise RuntimeError(f"Grover search failed: {e}") from e
    
    def _apply_grover_oracle(self, qc: QuantumCircuit, n_qubits: int, target: str) -> None:
        """
        Apply Grover oracle to mark the target state.
        
        Args:
            qc: Quantum circuit to modify
            n_qubits: Number of qubits
            target: Target binary string to mark
        """
        # Flip qubits that should be |1⟩ in target
        for i, bit in enumerate(target):
            if bit == '0':
                qc.x(i)
        
        # Apply multi-controlled Z gate (marks target state)
        if n_qubits == 1:
            qc.z(0)
        elif n_qubits == 2:
            qc.cz(0, 1)
        else:
            qc.h(n_qubits - 1)
            qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
            qc.h(n_qubits - 1)
        
        # Flip back
        for i, bit in enumerate(target):
            if bit == '0':
                qc.x(i)
    
    def _apply_grover_diffusion(self, qc: QuantumCircuit, n_qubits: int) -> None:
        """
        Apply Grover diffusion operator to amplify marked state.
        
        Args:
            qc: Quantum circuit to modify
            n_qubits: Number of qubits
        """
        # Apply H, X to all qubits
        for i in range(n_qubits):
            qc.h(i)
            qc.x(i)
        
        # Multi-controlled Z
        if n_qubits == 1:
            qc.z(0)
        else:
            qc.h(n_qubits - 1)
            qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
            qc.h(n_qubits - 1)
        
        # Apply X, H to all qubits
        for i in range(n_qubits):
            qc.x(i)
            qc.h(i)


# ============================================================================
# 4D DATA STORAGE
# ============================================================================

class HyperMemory:
    """
    HyperMemory: 4D coordinate-based data storage system.
    
    Stores data at specific 4D spacetime coordinates, enabling
    quantum-enhanced search operations.
    
    Attributes:
        data: Dictionary mapping 4D coordinates to stored values
    """
    
    def __init__(self) -> None:
        """Initialize empty HyperMemory storage."""
        self.data: Dict[Tuple[float, ...], Any] = {}
        logger.debug("HyperMemory initialized")
    
    def store(self, coord: Tuple[float, ...], value: Any) -> None:
        """
        Store a value at a specific 4D coordinate.
        
        Args:
            coord: 4D spacetime coordinate tuple (c*t, x, y, z)
            value: Value to store (any type)
        """
        if not isinstance(coord, tuple) or len(coord) != 4:
            raise ValueError(f"Coordinate must be a 4-tuple, got {coord}")
        
        self.data[coord] = value
        logger.debug(f"Stored value at coordinate {coord}")
    
    def retrieve(self, coord: Tuple[float, ...]) -> Optional[Any]:
        """
        Retrieve a value from a specific 4D coordinate.
        
        Args:
            coord: 4D spacetime coordinate tuple (c*t, x, y, z)
        
        Returns:
            Stored value if found, None otherwise
        """
        if not isinstance(coord, tuple) or len(coord) != 4:
            raise ValueError(f"Coordinate must be a 4-tuple, got {coord}")
        
        value = self.data.get(coord, None)
        logger.debug(f"Retrieved value from coordinate {coord}: {value}")
        return value
    
    def search_nearby(
        self,
        center: Tuple[float, ...],
        radius: float = 1.0
    ) -> Dict[Tuple[float, ...], Any]:
        """
        Search for all stored values within a radius of a center coordinate.
        
        Args:
            center: Center 4D coordinate
            radius: Search radius
        
        Returns:
            Dictionary of coordinates and values within radius
        """
        if not isinstance(center, tuple) or len(center) != 4:
            raise ValueError(f"Center must be a 4-tuple, got {center}")
        
        results = {}
        for coord, value in self.data.items():
            distance = np.sqrt(sum((c - center[i]) ** 2 for i, c in enumerate(coord)))
            if distance <= radius:
                results[coord] = value
        
        logger.debug(f"Found {len(results)} items within radius {radius} of {center}")
        return results
    
    def clear(self) -> None:
        """Clear all stored data."""
        self.data.clear()
        logger.debug("HyperMemory cleared")
    
    def size(self) -> int:
        """
        Get the number of stored items.
        
        Returns:
            Number of items in storage
        """
        return len(self.data)


# ============================================================================
# FLASK APPLICATION
# ============================================================================

app = Flask(__name__)

# Global instances
spacetime = Spacetime4D()
quantum = QuantumCore()
memory = HyperMemory()

# Pre-populate memory with sample data for demonstration
def initialize_memory() -> None:
    """Initialize HyperMemory with sample data."""
    try:
        for i in range(4):
            pos = spacetime.move(0, float(i), 0.0, 0.0)
            memory.store(pos, np.random.randint(0, 100))
        logger.info(f"Initialized HyperMemory with {memory.size()} items")
    except Exception as e:
        logger.warning(f"Failed to initialize memory: {e}")


# ============================================================================
# API ENDPOINTS
# ============================================================================

@app.route('/')
def home() -> str:
    """
    Home endpoint providing API documentation.
    
    Returns:
        HTML page with API documentation
    """
    return """
    <!DOCTYPE html>
    <html>
    <head>
        <title>TESSERACT-NODE v1.0</title>
        <style>
            body { font-family: monospace; background: #0a0a0a; color: #0f0; padding: 20px; }
            h1 { color: #0ff; }
            a { color: #0ff; text-decoration: none; }
            a:hover { color: #fff; }
            .status { color: #0f0; }
        </style>
    </head>
    <body>
        <h1>TESSERACT-NODE v1.0</h1>
        <p><b>4D Offline Quantum Server</b> — <span class="status">ONLINE</span></p>
        <h2>API Endpoints:</h2>
        <ul>
            <li><a href="/status">/status</a> - Server status and information</li>
            <li><a href="/entangle">/entangle</a> - Create entangled Bell pair</li>
            <li><a href="/ghz?n=4">/ghz?n=4</a> - Create GHZ state</li>
            <li><a href="/move?dt=1&dx=10&dy=0&dz=0">/move?dt=1&dx=10&dy=0&dz=0</a> - Move in 4D spacetime</li>
            <li><a href="/grover?n_qubits=2&target=11">/grover?n_qubits=2&target=11</a> - Perform Grover search</li>
            <li><a href="/memory/search?x=0&y=0&z=0&radius=10">/memory/search</a> - Search HyperMemory</li>
        </ul>
    </body>
    </html>
    """


@app.route('/status')
def status() -> Response:
    """
    Get server status and current state.
    
    Returns:
        JSON response with server status information
    """
    try:
        return jsonify({
            "node": "Tesseract-Node Ω",
            "status": "4D OPERATIONAL",
            "timestamp": datetime.now().isoformat(),
            "position": spacetime.get_position(),
            "qubits": config.max_qubits,
            "offline": True,
            "memory_items": memory.size()
        }), 200
    except Exception as e:
        logger.error(f"Status endpoint error: {e}")
        return jsonify({"error": "Failed to get status"}), 500


@app.route('/entangle')
def entangle() -> Response:
    """
    Create an entangled Bell pair.
    
    Query Parameters:
        shots (optional): Number of measurement shots (default: 1024)
    
    Returns:
        JSON response with entanglement result
    """
    try:
        shots = int(request.args.get('shots', config.default_shots))
        if shots < 1 or shots > 100000:
            return jsonify({"error": "Shots must be between 1 and 100000"}), 400
        
        result = quantum.create_entangled_pair(shots=shots)
        return jsonify({
            "bell_pair": result,
            "entanglement": "ACHIEVED",
            "shots": shots
        }), 200
    except ValueError as e:
        logger.warning(f"Invalid parameter in entangle: {e}")
        return jsonify({"error": str(e)}), 400
    except Exception as e:
        logger.error(f"Entangle endpoint error: {e}")
        return jsonify({"error": "Failed to create entangled pair"}), 500


@app.route('/ghz')
def ghz() -> Response:
    """
    Create a GHZ state.
    
    Query Parameters:
        n (optional): Number of qubits (default: 4, max: 16)
        shots (optional): Number of measurement shots (default: 1024)
    
    Returns:
        JSON response with GHZ state result
    """
    try:
        n = int(request.args.get('n', 4))
        shots = int(request.args.get('shots', config.default_shots))
        
        if n < 2 or n > config.max_qubits:
            return jsonify({
                "error": f"Number of qubits must be between 2 and {config.max_qubits}"
            }), 400
        
        result = quantum.ghz_state(n=n, shots=shots)
        most_probable = max(result, key=result.get) if result else "0" * n
        
        return jsonify({
            "ghz_state": most_probable,
            "qubits": n,
            "all_results": result,
            "shots": shots
        }), 200
    except ValueError as e:
        logger.warning(f"Invalid parameter in ghz: {e}")
        return jsonify({"error": str(e)}), 400
    except Exception as e:
        logger.error(f"GHZ endpoint error: {e}")
        return jsonify({"error": "Failed to create GHZ state"}), 500


@app.route('/move')
def move() -> Response:
    """
    Move through 4D spacetime.
    
    Query Parameters:
        dt: Time increment (required)
        dx: X spatial increment (default: 0)
        dy: Y spatial increment (default: 0)
        dz: Z spatial increment (default: 0)
    
    Returns:
        JSON response with new position
    """
    try:
        dt = float(request.args.get('dt', 0))
        dx = float(request.args.get('dx', 0))
        dy = float(request.args.get('dy', 0))
        dz = float(request.args.get('dz', 0))
        
        pos = spacetime.move(dt, dx, dy, dz)
        return jsonify({
            "new_position": pos,
            "coordinates": {
                "t": spacetime.t,
                "x": spacetime.x,
                "y": spacetime.y,
                "z": spacetime.z
            }
        }), 200
    except ValueError as e:
        logger.warning(f"Invalid parameter in move: {e}")
        return jsonify({"error": "Invalid coordinate values"}), 400
    except Exception as e:
        logger.error(f"Move endpoint error: {e}")
        return jsonify({"error": "Failed to move"}), 500


@app.route('/grover')
def grover() -> Response:
    """
    Perform Grover's quantum search algorithm.
    
    Query Parameters:
        n_qubits (optional): Number of qubits (default: 2, max: 16)
        target (optional): Target binary string (default: '11')
        shots (optional): Number of measurement shots (default: 1024)
    
    Returns:
        JSON response with search result
    """
    try:
        n_qubits = int(request.args.get('n_qubits', 2))
        target = request.args.get('target', '11')
        shots = int(request.args.get('shots', config.default_shots))
        
        if n_qubits < 1 or n_qubits > config.max_qubits:
            return jsonify({
                "error": f"Number of qubits must be between 1 and {config.max_qubits}"
            }), 400
        
        result = quantum.grover_search(n_qubits=n_qubits, target=target, shots=shots)
        
        # Map result to memory coordinate (simplified mapping)
        index = int(result, 2) if result else 0
        search_results = memory.search_nearby(
            center=(0.0, float(index), 0.0, 0.0),
            radius=10.0
        )
        
        return jsonify({
            "search_result": result,
            "target": target,
            "n_qubits": n_qubits,
            "quantum_speedup": "ACHIEVED",
            "memory_results": search_results,
            "shots": shots
        }), 200
    except ValueError as e:
        logger.warning(f"Invalid parameter in grover: {e}")
        return jsonify({"error": str(e)}), 400
    except Exception as e:
        logger.error(f"Grover endpoint error: {e}")
        return jsonify({"error": "Failed to perform Grover search"}), 500


@app.route('/memory/search')
def memory_search() -> Response:
    """
    Search HyperMemory for items near a coordinate.
    
    Query Parameters:
        x: X coordinate (default: 0)
        y: Y coordinate (default: 0)
        z: Z coordinate (default: 0)
        t: Time coordinate (default: 0)
        radius: Search radius (default: 10.0)
    
    Returns:
        JSON response with search results
    """
    try:
        x = float(request.args.get('x', 0))
        y = float(request.args.get('y', 0))
        z = float(request.args.get('z', 0))
        t = float(request.args.get('t', 0))
        radius = float(request.args.get('radius', 10.0))
        
        center = (config.speed_of_light * t, x, y, z)
        results = memory.search_nearby(center, radius)
        
        return jsonify({
            "center": center,
            "radius": radius,
            "results": {str(k): v for k, v in results.items()},
            "count": len(results)
        }), 200
    except ValueError as e:
        logger.warning(f"Invalid parameter in memory_search: {e}")
        return jsonify({"error": "Invalid coordinate values"}), 400
    except Exception as e:
        logger.error(f"Memory search endpoint error: {e}")
        return jsonify({"error": "Failed to search memory"}), 500


@app.errorhandler(404)
def not_found(error: Any) -> Response:
    """Handle 404 errors."""
    return jsonify({"error": "Endpoint not found"}), 404


@app.errorhandler(500)
def internal_error(error: Any) -> Response:
    """Handle 500 errors."""
    logger.error(f"Internal server error: {error}")
    return jsonify({"error": "Internal server error"}), 500


# ============================================================================
# BACKGROUND DRIFT
# ============================================================================

def drift() -> None:
    """
    Background thread that simulates continuous spacetime drift.
    
    Periodically moves the spacetime coordinates by small random amounts
    to simulate natural drift in 4D space.
    """
    while True:
        try:
            time.sleep(config.drift_interval)
            dt = 1.0
            dx = float(np.random.randn() * 0.1)
            dy = float(np.random.randn() * 0.1)
            dz = float(np.random.randn() * 0.1)
            spacetime.move(dt, dx, dy, dz)
            logger.debug(f"[4D DRIFT] Position: {spacetime.get_position()}")
        except Exception as e:
            logger.error(f"Drift thread error: {e}")
            time.sleep(config.drift_interval)


# ============================================================================
# MAIN ENTRY POINT
# ============================================================================

def main() -> None:
    """Main entry point for the Tesseract Node server."""
    setup_logging(config.log_level)
    logger.info("=" * 60)
    logger.info("TESSERACT-NODE v1.0 — 4D CORE INITIALIZING")
    logger.info("=" * 60)
    
    # Initialize memory
    initialize_memory()
    
    # Start background drift thread
    drift_thread = threading.Thread(target=drift, daemon=True, name="DriftThread")
    drift_thread.start()
    logger.info("Background drift thread started")
    
    # Start Flask server
    logger.info(f"Starting server on http://{config.host}:{config.port}")
    logger.info("=" * 60)
    
    try:
        app.run(
            host=config.host,
            port=config.port,
            debug=config.debug,
            threaded=True
        )
    except KeyboardInterrupt:
        logger.info("\nShutting down TESSERACT-NODE...")
    except Exception as e:
        logger.error(f"Server error: {e}")
        raise


if __name__ == '__main__':
    main()