import numpy as np
import time
import math
from typing import List, Tuple, Dict, Any, Final

# ============================================================================
# 1. DATA TYPES: 4-COMPONENT VECTORS & 4x4 MATRICES
# ============================================================================

class Vector4D:
    """Master 4D Vector for (x, y, z, w) coordinates."""
    def __init__(self, x=0.0, y=0.0, z=0.0, w=0.0):
        self.data = np.array([x, y, z, w], dtype=np.float64)

    def __repr__(self):
        return f"Vec4({self.data[0]:.2f}, {self.data[1]:.2f}, {self.data[2]:.2f}, {self.data[3]:.2f})"

class Matrix4D:
    """Master 4x4 Matrix for Hyper-spatial Transformations."""
    @staticmethod
    def identity():
        return np.eye(4, dtype=np.float64)

    @staticmethod
    def translation(dx, dy, dz, dw):
        mat = np.eye(4)
        mat[0:4, 3] = [dx, dy, dz, dw] # Standard translation column
        return mat

# ============================================================================
# 2. LOGIC: 4D ROTATION & TRANSLATION
# ============================================================================

class HyperRotation:
    """Calculates rotations in 4D space across 6 primary planes."""
    @staticmethod
    def rotate_xw(theta):
        c, s = np.cos(theta), np.sin(theta)
        return np.array([
            [c, 0, 0, -s],
            [0, 1, 0, 0],
            [0, 0, 1, 0],
            [s, 0, 0, c]
        ])

    @staticmethod
    def rotate_zw(theta):
        c, s = np.cos(theta), np.sin(theta)
        return np.array([
            [1, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 0, c, -s],
            [0, 0, s, c]
        ])

# ============================================================================
# 3. RENDERING: PERSPECTIVE / STEREOGRAPHIC PROJECTION
# ============================================================================

class HyperRenderer:
    """Projects 4D Manifolds into 3D space for visualization."""
    def __init__(self, distance=2.0):
        self.distance = distance

    def project_4d_to_3d(self, vec4: np.ndarray) -> np.ndarray:
        """
        Applies Perspective Projection: P(x,y,z,w) -> P'(x',y',z').
        w is treated as the depth factor for the 4th-dimensional slice.
        """
        w_factor = 1 / (self.distance - vec4[3])
        projection_matrix = np.array([
            [w_factor, 0, 0, 0],
            [0, w_factor, 0, 0],
            [0, 0, w_factor, 0]
        ])
        return np.dot(projection_matrix, vec4)

# ============================================================================
# 4. PHYSICS: HYPER-SPATIAL COLLISION DETECTION
# ============================================================================

class HyperPhysics:
    """Calculates 4D rigid body dynamics and proximity-based collision."""
    def __init__(self, collision_threshold=0.5):
        self.threshold = collision_threshold

    def detect_collision(self, obj_a: np.ndarray, obj_b: np.ndarray) -> bool:
        """L2 Norm Euclidean distance check across 4 dimensions."""
        distance = np.linalg.norm(obj_a - obj_b)
        return distance < self.threshold

# ============================================================================
# TEST RUN: THE 4D TESSERACT SIMULATION
# ============================================================================

def test_run_4d_engine():
    print("--- ROMANAILABS 4D ENGINE: INITIALIZING TEST RUN ---")
    
    # 1. Initialize Objects (Two 4D points representing vertices)
    vertex_a = Vector4D(1, 1, 1, 1).data
    vertex_b = Vector4D(-1, -1, -1, -1).data
    
    renderer = HyperRenderer(distance=3.0)
    physics = HyperPhysics(collision_threshold=1.5)
    
    # 2. Apply 4D Rotation (XW Plane)
    rot_xw = HyperRotation.rotate_xw(np.pi / 4) # 45-degree rotation
    vertex_a_rotated = np.dot(rot_xw, vertex_a)
    
    # 3. Apply 4D Translation
    trans_mat = Matrix4D.translation(0.5, 0, 0, 0.2)
    vertex_a_final = np.dot(trans_mat, vertex_a_rotated)
    
    # 4. Perspective Projection to 3D
    view_3d = renderer.project_4d_to_3d(vertex_a_final)
    
    # 5. Physics Collision Check
    is_colliding = physics.detect_collision(vertex_a_final, vertex_b)
    
    # OUTPUT DATA
    print(f"[MATH]   Original 4D:  {vertex_a}")
    print(f"[LOGIC]  Rotated/Trans: {vertex_a_final}")
    print(f"[RENDER] 3D Projection: {view_3d}")
    print(f"[PHYSIC] Collision:     {'DETECTED' if is_colliding else 'NONE'}")
    
    if is_colliding:
        print("\nSTATUS: Tesseract node achieved dimensional overlap.")
    else:
        print("\nSTATUS: Manifold remains stable.")

if __name__ == "__main__":
    test_run_4d_engine()