import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation
from scipy.linalg import expm
import random
import math
import tkinter as tk
from tkinter import messagebox

# === Core Math Functions for 12D Spacetime/Lattice Demo ===

# SO(n) generator for plane ij (antisymmetric matrix)
def so_generator(n, i, j):
    gen = np.zeros((n, n))
    gen[i, j] = 1
    gen[j, i] = -1
    return gen

# Random SO(n) base matrix via QR decomposition
def random_so_matrix(n):
    A = np.random.randn(n, n)
    Q, R = np.linalg.qr(A)
    signs = np.sign(np.diag(R))
    Q *= signs
    if np.linalg.det(Q) < 0:
        Q[:, 0] = -Q[:, 0]
    return Q

# Plane rotation via matrix exponential
def plane_rotation_exp(n, i, j, theta):
    gen = so_generator(n, i, j)
    return expm(theta * gen)

# Generate random 12D lattice basis (full-rank, perturbed for realism)
def generate_12d_lattice_basis():
    n = 12
    basis = np.eye(n) + 0.1 * np.random.randn(n, n)  # Perturb identity
    return basis

# Generate lattice points in 12D (integer combinations within bound)
def generate_lattice_points(basis, bound=2):
    n = basis.shape[0]
    coords = np.array(np.meshgrid(*[range(-bound, bound+1)] * n)).T.reshape(-1, n)
    points = np.dot(coords, basis.T)  # Lattice points
    return points

# Naive shortest vector approximation (brute-force; demo of hardness)
def approximate_shortest_vector(lattice_points):
    norms = np.linalg.norm(lattice_points, axis=1)
    non_zero = norms > 1e-6  # Exclude origin
    if np.any(non_zero):
        sv_idx = np.argmin(norms[non_zero])
        return lattice_points[non_zero][sv_idx], norms[non_zero][sv_idx]
    return None, float('inf')

# Project 12D to 3D for visualization
def project_to_3d(points, proj_matrix=None):
    n = points.shape[1]
    if proj_matrix is None:
        proj_matrix = random_so_matrix(n)[:, :3]
    return np.dot(points, proj_matrix)

# Simulate a local "hit" IP for demo (harmless, random generation)
def simulate_hit_ip():
    # Strictly local: No real network, just random fake IP
    return f"192.168.{random.randint(0, 255)}.{random.randint(0, 255)}"

# === Advanced Rotation Equation: 12 Bases x 12 Variations = 144 Compositions ===
# R_total^{b,v} = (∏_{k=1}^{12} R_{i_k j_k}(θ_k)) ∘ R_base^b
# Harmless local simulation only
def simulate_144_12d_rotations(lattice_basis, num_points=500):
    n = 12
    num_bases = 12
    num_vars = 12
    total = num_bases * num_vars

    np.random.seed(42)
    random.seed(42)

    # Generate base lattice points (before rotations)
    base_points = generate_lattice_points(lattice_basis, bound=1)  # Small for demo

    all_rotated_bases = []  # Rotated lattice bases
    all_projections = []    # 3D projections of points
    all_sv_lengths = []     # Shortest vector lengths for demo

    print(f"Lab Demo: Generating {total} advanced 12D spacetime rotations (strictly local simulation)...")

    for b in range(num_bases):
        # Base rotation for this configuration
        R_base = random_so_matrix(n)

        vars_rotated = []
        vars_projs = []
        vars_sv = []

        # Random projection matrix per base (for consistent visualization)
        proj_mat = random_so_matrix(n)[:, :3]

        for v in range(num_vars):
            R_total = R_base.copy()

            # Compose with 12 plane rotations (integrating 1-12 dimensions)
            for k in range(12):  # Self-multiplication: 12 layers
                i, j = random.sample(range(n), 2)
                theta = random.uniform(0, 2 * math.pi)
                R_inc = plane_rotation_exp(n, i, j, theta)
                R_total = np.dot(R_inc, R_total)  # Advanced composition

            # Rotate the lattice basis (simulate "math working" in space)
            rotated_basis = np.dot(lattice_basis, R_total.T)

            # Generate points from rotated basis
            rotated_points = generate_lattice_points(rotated_basis, bound=1)

            # Project to 3D
            proj_3d = project_to_3d(rotated_points, proj_mat)

            # Demo "safety feature": Simulate hit from local math computation
            fake_ip = simulate_hit_ip()
            print(f"Math Hit Alert (Local Sim): The Math Worked from {fake_ip}")

            # Compute approximate shortest vector (demo hardness)
            _, sv_length = approximate_shortest_vector(rotated_points)

            vars_rotated.append(rotated_basis)
            vars_projs.append(proj_3d)
            vars_sv.append(sv_length)

            det = np.linalg.det(R_total)
            print(f"Base {b+1} (Dim Config {b+1}), Var {v+1}: Det={det:.2f}, SV Len={sv_length:.2f}")

        all_rotated_bases.append(vars_rotated)
        all_projections.append(vars_projs)
        all_sv_lengths.append(vars_sv)

    print("\nDemo Complete: This is a harmless, local math simulation. No real network activity.")
    return all_rotated_bases, all_projections, all_sv_lengths

# === GUI for Lab Demo (Harmless, Local Only) ===
class LabDemoGUI:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("12D Math Lab Demo (Strictly Local)")
        self.root.geometry("800x600")

        # Info label
        self.info_label = tk.Label(self.root, text="Harmless 12D Math Simulation for Classroom\nClick 'Run Demo' to Start (Local Only)", font=("Arial", 14))
        self.info_label.pack(pady=20)

        # Run button
        self.run_button = tk.Button(self.root, text="Run Demo", command=self.run_simulation, font=("Arial", 12))
        self.run_button.pack(pady=10)

        # Safety log text area
        self.log_text = tk.Text(self.root, height=15, width=80, font=("Arial", 10))
        self.log_text.pack(pady=10)
        self.log_text.insert(tk.END, "Safety Log: All operations are local. No network access.\n")

        # Animate button (enabled after sim)
        self.animate_button = tk.Button(self.root, text="Animate First Config", command=self.animate_demo, state=tk.DISABLED, font=("Arial", 12))
        self.animate_button.pack(pady=10)

        self.projections = None
        self.sv_lengths = None

        self.root.mainloop()

    def log(self, message):
        self.log_text.insert(tk.END, message + "\n")
        self.log_text.see(tk.END)

    def run_simulation(self):
        self.log("Starting local simulation...")
        lattice_basis = generate_12d_lattice_basis()
        _, self.projections, self.sv_lengths = simulate_144_12d_rotations(lattice_basis)
        self.log("Simulation complete. Ready to animate.")
        self.animate_button.config(state=tk.NORMAL)
        messagebox.showinfo("Safety Notice", "Demo ran locally. Simulated 'math hits' are fake and harmless.")

    def animate_demo(self):
        if self.projections is None or not self.projections:
            messagebox.showerror("Error", "Run simulation first!")
            return

        # Animate the first base config
        fig = plt.figure(figsize=(10, 8))
        ax = fig.add_subplot(111, projection='3d')
        ax.set_title("12D Lattice Rotation Demo (Local Sim)")

        all_pts = np.vstack(self.projections[0])
        ax.set_xlim(all_pts[:,0].min(), all_pts[:,0].max())
        ax.set_ylim(all_pts[:,1].min(), all_pts[:,1].max())
        ax.set_zlim(all_pts[:,2].min(), all_pts[:,2].max())

        scat = ax.scatter([], [], [], c='green', s=5, alpha=0.7)
        text = ax.text2D(0.05, 0.95, "", transform=ax.transAxes)

        def update(frame):
            var = frame // 30 % len(self.projections[0])  # Cycle variations
            azim = frame % 360
            proj = self.projections[0][var]
            scat._offsets3d = (proj[:,0], proj[:,1], proj[:,2])
            ax.view_init(elev=30 + 10*math.sin(frame/60), azim=azim)
            text.set_text(f'Variation {var+1}\nSV Length: {self.sv_lengths[0][var]:.2f}\n(Local Math Only)')
            return scat, text

        ani = FuncAnimation(fig, update, frames=360*2, interval=30, blit=False)
        plt.show()

# === Run the GUI ===
if __name__ == "__main__":
    LabDemoGUI()