# -*- coding: utf-8 -*-
# entropic_sensor_v6_hardware.py
# Copyright RomanAILabs - Daniel Harding

import os
import sys
import time
import math
import random
import threading
import datetime
from pathlib import Path

try:
    import customtkinter as ctk
    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
except ImportError as e:
    print(f"Missing core dependency: {e}")
    sys.exit(1)

try:
    import pyttsx3
except ImportError:
    pyttsx3 = None

# ================================================
# THEME & CONFIGURATION
# ================================================
ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")

THEME = {
    'bg':           '#05080f',
    'frame':        '#0b111c',
    'text':         '#00ffea',
    'accent':       '#ff1a8c',
    'point_cmap':   plt.cm.cool,
    'log_sys':      '#ffcc66',
    'log_data':     '#66ffff'
}

# ================================================
# TTS - System Announcer
# ================================================
voice_engine = None
if pyttsx3:
    try:
        voice_engine = pyttsx3.init()
        for v in voice_engine.getProperty('voices'):
            if any(x in v.name.lower() for x in ['david','zira','robotic','monotone']):
                voice_engine.setProperty('voice', v.id)
                break
    except:
        voice_engine = None

def speak(text, rate=150, vol=0.8):
    if not voice_engine: return
    def _run():
        try:
            voice_engine.setProperty('rate', rate)
            voice_engine.setProperty('volume', vol)
            voice_engine.say(text)
            voice_engine.runAndWait()
        except: pass
    threading.Thread(target=_run, daemon=True).start()

# ================================================
# GEOMETRY GENERATORS (800 Points)
# ================================================
NUM_POINTS = 800

def get_sphere_coords():
    phi = np.random.uniform(0, np.pi, NUM_POINTS)
    theta = np.random.uniform(0, 2 * np.pi, NUM_POINTS)
    r = 3.0
    x = r * np.sin(phi) * np.cos(theta)
    y = r * np.sin(phi) * np.sin(theta)
    z = r * np.cos(phi)
    return np.column_stack((x, y, z))

def get_torus_coords():
    theta = np.random.uniform(0, 2 * np.pi, NUM_POINTS)
    phi = np.random.uniform(0, 2 * np.pi, NUM_POINTS)
    R, r = 3.0, 1.0
    x = (R + r * np.cos(theta)) * np.cos(phi)
    y = (R + r * np.cos(theta)) * np.sin(phi)
    z = r * np.sin(theta)
    return np.column_stack((x, y, z))

def get_chaos_coords():
    x = np.random.uniform(-5, 5, NUM_POINTS)
    y = np.random.uniform(-5, 5, NUM_POINTS)
    z = np.random.uniform(-5, 5, NUM_POINTS)
    return np.column_stack((x, y, z))

# ================================================
# VIVOBOOK HARDWARE SENSOR UI
# ================================================
class HardwareEntropySensorApp(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.title("RomanAILabs - Dimensional Hardware Sensor")
        self.geometry("1400x900")
        self.configure(fg_color=THEME['bg'])
        
        self.azim_angle = 140
        
        # 3D Data Arrays
        self.current_coords = get_sphere_coords()
        self.target_coords = self.current_coords.copy()
        self.colors = [THEME['point_cmap'](np.random.rand()) for _ in range(NUM_POINTS)]
        
        # Sensor State
        self.is_monitoring = False
        self.entropy_history = []
        self.current_state_name = "STABLE"
        
        self._build_ui()
        self._init_3d_cloud()
        
        self._log("Hardware OS hooks established.", "System")
        self._log("Bypassing LLM. Reading raw CPU jitter and kernel noise.", "System")
        
        # Start smooth visual loops
        self.after(50, self._animate_cloud)
        self.after(30, self._morph_shape)

    def _build_ui(self):
        self.title_lbl = ctk.CTkLabel(self, text="PHYSICAL ENTROPY SENSOR : BULK MONITOR", 
                                      font=("Consolas", 24, "bold"), text_color=THEME['accent'])
        self.title_lbl.pack(pady=15)

        self.main_frame = ctk.CTkFrame(self, fg_color="transparent")
        self.main_frame.pack(fill="both", expand=True, padx=20, pady=10)

        # Left 3D Panel
        self.cloud_frame = ctk.CTkFrame(self.main_frame, fg_color=THEME['frame'], corner_radius=15)
        self.cloud_frame.pack(side="left", fill="both", expand=True, padx=(0, 10))

        # Right Data Panel
        self.data_frame = ctk.CTkFrame(self.main_frame, fg_color=THEME['frame'], corner_radius=15, width=450)
        self.data_frame.pack(side="right", fill="both", expand=False)
        self.data_frame.pack_propagate(False)

        # Telemetry Display
        self.telemetry_lbl = ctk.CTkLabel(self.data_frame, text="SYSTEM STATUS: OFFLINE", 
                                          font=("Consolas", 18, "bold"), text_color="#555555")
        self.telemetry_lbl.pack(pady=20)
        
        self.entropy_val_lbl = ctk.CTkLabel(self.data_frame, text="0.000000 bits", 
                                            font=("Consolas", 36, "bold"), text_color=THEME['text'])
        self.entropy_val_lbl.pack(pady=5)

        # Log Textbox
        self.log_box = ctk.CTkTextbox(self.data_frame, font=("Consolas", 12), wrap="word", 
                                       fg_color="#05080f", text_color=THEME['log_data'])
        self.log_box.pack(fill="both", expand=True, padx=15, pady=15)
        self.log_box.configure(state="disabled")

        # Controls
        self.control_frame = ctk.CTkFrame(self, fg_color="transparent")
        self.control_frame.pack(fill="x", padx=20, pady=20)

        self.btn_toggle = ctk.CTkButton(self.control_frame, text="INITIATE SENSOR SWEEP", font=("Consolas", 16, "bold"),
                                      height=50, fg_color="#008080", hover_color=THEME['accent'],
                                      command=self._toggle_monitoring)
        self.btn_toggle.pack(side="left", fill="x", expand=True, padx=(0, 10))
        
        self.btn_spike = ctk.CTkButton(self.control_frame, text="INDUCE CPU JITTER", font=("Consolas", 16, "bold"),
                                      height=50, fg_color="#800000", hover_color="#ff0000",
                                      command=self._induce_jitter)
        self.btn_spike.pack(side="right", fill="x", expand=True, padx=(10, 0))

    def _init_3d_cloud(self):
        self.fig = plt.Figure(figsize=(8, 8), dpi=100, facecolor=THEME['frame'])
        self.ax = self.fig.add_subplot(111, projection='3d')
        self.ax.set_facecolor(THEME['frame'])
        self.ax.grid(False)
        self.ax.axis('off')

        self.canvas = FigureCanvasTkAgg(self.fig, master=self.cloud_frame)
        self.canvas.draw()
        self.canvas.get_tk_widget().pack(fill="both", expand=True, padx=10, pady=10)

        self.scatter = self.ax.scatter(self.current_coords[:,0], self.current_coords[:,1], self.current_coords[:,2], 
                                       c=self.colors, s=30, alpha=0.8, edgecolor='none')
        
        self.ax.set_xlim([-6, 6])
        self.ax.set_ylim([-6, 6])
        self.ax.set_zlim([-6, 6])
        self.ax.view_init(elev=20, azim=self.azim_angle)

    def _animate_cloud(self):
        self.azim_angle = (self.azim_angle + 0.5) % 360
        self.ax.view_init(elev=20, azim=self.azim_angle)
        self.canvas.draw_idle()
        self.after(40, self._animate_cloud)

    def _morph_shape(self):
        # Linear interpolation (Lerp) towards the target shape
        lerp_speed = 0.05
        self.current_coords += (self.target_coords - self.current_coords) * lerp_speed
        
        # Update plot
        self.scatter._offsets3d = (self.current_coords[:,0], self.current_coords[:,1], self.current_coords[:,2])
        self.after(30, self._morph_shape)

    def _log(self, msg: str, who: str):
        self.log_box.configure(state="normal")
        ts = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3]
        line = f"[{ts}] {who}: {msg}\n"
        self.log_box.insert("end", line)
        self.log_box.see("end")
        self.log_box.configure(state="disabled")

    def _toggle_monitoring(self):
        if not self.is_monitoring:
            self.is_monitoring = True
            self.btn_toggle.configure(text="HALT SENSOR", fg_color="#800000")
            self.telemetry_lbl.configure(text="SYSTEM STATUS: SWEEPING", text_color=THEME['accent'])
            speak("Hardware sensor array online. Monitoring for dimensional leakage.", rate=170)
            self._harvest_loop()
        else:
            self.is_monitoring = False
            self.btn_toggle.configure(text="INITIATE SENSOR SWEEP", fg_color="#008080")
            self.telemetry_lbl.configure(text="SYSTEM STATUS: OFFLINE", text_color="#555555")
            speak("Sensor array deactivated.")

    def _induce_jitter(self):
        # Create a tiny artificial mathematical load to spike CPU nano-timing
        self._log("Artificial CPU jitter induced.", "System")
        threading.Thread(target=lambda: [math.factorial(i) for i in range(5000)], daemon=True).start()

    def _harvest_loop(self):
        if not self.is_monitoring: return
        
        # 1. Harvest environmental OS noise
        raw_noise = os.urandom(256)
        
        # 2. Harvest CPU nanosecond jitter
        t1 = time.perf_counter_ns()
        _ = sum(math.sin(i) for i in range(100)) # micro-load
        t2 = time.perf_counter_ns()
        jitter_val = (t2 - t1) % 255
        
        # Calculate Shannon Entropy of the hardware state
        data_bytes = list(raw_noise) + [jitter_val for _ in range(50)] # Weight the jitter heavily
        counts = np.bincount(data_bytes, minlength=256)
        probs = counts[counts > 0] / counts.sum()
        entropy = -np.sum(probs * np.log2(probs))
        
        self.entropy_val_lbl.configure(text=f"{entropy:.6f} bits")
        
        # Determine Geometry based on Hardware Entropy
        # Typically os.urandom + jitter hovers around 7.8 - 7.9. 
        # Drops in entropy indicate ORDER (Anomalous). Spikes indicate CHAOS.
        
        new_state = "STABLE"
        if entropy < 7.5:
            new_state = "ORDER_ANOMALY"
            self.target_coords = get_sphere_coords()
            self.telemetry_lbl.configure(text="STATE: SPHERE (UNNATURAL ORDER)", text_color="#00ff00")
        elif entropy > 7.9:
            new_state = "CHAOS_ANOMALY"
            self.target_coords = get_chaos_coords()
            self.telemetry_lbl.configure(text="STATE: CHAOS (DIMENSIONAL LEAK)", text_color="#ff0000")
        else:
            new_state = "RESONANCE"
            self.target_coords = get_torus_coords()
            self.telemetry_lbl.configure(text="STATE: TORUS (BACKGROUND NOISE)", text_color=THEME['text'])

        if new_state != self.current_state_name:
            self._log(f"Phase shift detected. Entropy: {entropy:.4f} -> {new_state}", "Sensor")
            self.current_state_name = new_state
            
            if new_state == "CHAOS_ANOMALY":
                speak("Warning. High entropic chaos detected in hardware timing.")
            elif new_state == "ORDER_ANOMALY":
                speak("Anomaly. Unnatural hardware synchronization.")

        # Loop
        self.after(500, self._harvest_loop)

if __name__ == "__main__":
    app = HardwareEntropySensorApp()
    app.mainloop()