validator.py

import tkinter as tk
from tkinter import ttk
import threading
import time
import os
import hashlib
import math
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

# --- KONFIGURÁCIÓ ÉS STÍLUS ---
COLOR_BG = "#0B0D11"
COLOR_PANEL = "#161B22"
COLOR_ACCENT_CYAN = "#00D1FF"
COLOR_ACCENT_RED = "#FF3131"
COLOR_ACCENT_GREEN = "#00FF94"
COLOR_ACCENT_GOLD = "#FFD700"
COLOR_TEXT_MAIN = "#FFFFFF"
COLOR_TEXT_DIM = "#8B949E"

# PROFESSZIONÁLIS FORMÁTUM ADATBÁZIS
# Bitrate: MB/s (nem Mbps!)
# Complexity: Mennyire nehéz a CPU-nak (1.0 = Standard, >1.0 = Nehéz tömörítés)
VIDEO_FORMATS = {
    "HOLLYWOOD MASTER (8K RAW 12-bit)":    {"bitrate": 2400.0, "complexity": 1.0,  "desc": "Uncompressed Cinema Quality"},
    "CINEMA STANDARD (4K ProRes 4444)":    {"bitrate": 800.0,  "complexity": 1.2,  "desc": "High-End Production Standard"},
    "BROADCAST / YOUTUBE (4K H.265)":      {"bitrate": 80.0,   "complexity": 3.5,  "desc": "High Compression (CPU Heavy)"},
    "SOCIAL / PROXY (1080p H.264)":        {"bitrate": 20.0,   "complexity": 2.0,  "desc": "Lightweight Web Content"}
}

class Gauge(tk.Canvas):
    def __init__(self, parent, title, max_val, color, **kwargs):
        super().__init__(parent, bg=COLOR_PANEL, highlightthickness=0, **kwargs)
        self.title = title
        self.max_val = max_val
        self.color = color
        self.value = 0.0
        self.width = int(kwargs.get('width', 200))
        self.height = int(kwargs.get('height', 150))
        
        self.create_text(self.width/2, 20, text=self.title, fill=COLOR_TEXT_DIM, font=("Consolas", 10, "bold"))
        self.val_text = self.create_text(self.width/2, self.height-20, text="0.0 MB/s", fill=COLOR_TEXT_MAIN, font=("Consolas", 14, "bold"))
        
        self.cx, self.cy = self.width/2, self.height - 30
        self.radius = min(self.width, self.height) * 0.7
        self.create_arc(self.cx-self.radius, self.cy-self.radius, 
                        self.cx+self.radius, self.cy+self.radius, 
                        start=0, extent=180, style="arc", outline="#30363D", width=10)
        self.needle = self.create_line(self.cx, self.cy, self.cx, self.cy-self.radius, 
                                     fill=self.color, width=3, capstyle="round")

    def update_value(self, val, unit="MB/s"):
        self.value = val
        display_val = max(0, min(val, self.max_val))
        self.itemconfigure(self.val_text, text=f"{display_val:.1f} {unit}")
        
        ratio = display_val / self.max_val if self.max_val > 0 else 0
        angle_deg = 180 - (ratio * 180)
        angle_rad = math.radians(angle_deg)
        x = self.cx + self.radius * math.cos(angle_rad)
        y = self.cy - self.radius * math.sin(angle_rad)
        self.coords(self.needle, self.cx, self.cy, x, y)

class MetaSpaceValidatorV4(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("MetaSpace PRODUCTION PLANNER v4.0 (Hollywood Edition)")
        self.geometry("1100x850")
        self.configure(bg=COLOR_BG)
        
        self.temp_file = "metaspace_benchmark.bin"
        self.running = False
        self.cpu_score = 0.0
        self.disk_score = 0.0
        
        self._setup_ui()

    def _setup_ui(self):
        # HEADER
        header = tk.Frame(self, bg=COLOR_PANEL, height=80)
        header.pack(fill="x", pady=(0, 2))
        tk.Label(header, text="METASPACE PRODUCTION VALIDATOR", fg=COLOR_TEXT_MAIN, bg=COLOR_PANEL, font=("Segoe UI", 16, "bold")).pack(side="left", padx=25, pady=20)
        self.status_lbl = tk.Label(header, text="READY TO AUDIT", fg=COLOR_ACCENT_CYAN, bg=COLOR_PANEL, font=("Consolas", 11))
        self.status_lbl.pack(side="right", padx=25)

        # MAIN CONTAINER
        content = tk.Frame(self, bg=COLOR_BG, padx=30, pady=20)
        content.pack(fill="both", expand=True)

        # 1. FORMAT SELECTOR
        fmt_frame = tk.LabelFrame(content, text="STEP 1: SELECT TARGET WORKFLOW", bg=COLOR_BG, fg=COLOR_TEXT_DIM, font=("Segoe UI", 10, "bold"), padx=15, pady=15)
        fmt_frame.pack(fill="x", pady=(0, 20))
        
        self.selected_format = tk.StringVar(value="HOLLYWOOD MASTER (8K RAW 12-bit)")
        self.fmt_combo = ttk.Combobox(fmt_frame, textvariable=self.selected_format, values=list(VIDEO_FORMATS.keys()), state="readonly", font=("Segoe UI", 11))
        self.fmt_combo.pack(side="left", fill="x", expand=True, padx=(0, 10))
        self.fmt_combo.bind("<<ComboboxSelected>>", self.update_desc)
        
        self.desc_lbl = tk.Label(fmt_frame, text=VIDEO_FORMATS[self.selected_format.get()]["desc"], fg=COLOR_ACCENT_GOLD, bg=COLOR_BG, font=("Consolas", 10, "italic"))
        self.desc_lbl.pack(side="right")

        # 2. GAUGES
        gauges_frame = tk.Frame(content, bg=COLOR_BG)
        gauges_frame.pack(fill="x", pady=10)
        
        self.gauge_cpu = Gauge(gauges_frame, "TRADITIONAL CPU RENDER", 100.0, COLOR_ACCENT_RED, width=320, height=220)
        self.gauge_cpu.pack(side="left", padx=20, expand=True)
        
        self.gauge_disk = Gauge(gauges_frame, "METASPACE HYBRID I/O", 2000.0, COLOR_ACCENT_CYAN, width=320, height=220)
        self.gauge_disk.pack(side="right", padx=20, expand=True)

        # 3. REAL-TIME GRAPH
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(content, variable=self.progress_var, maximum=100, mode='determinate')
        self.progress_bar.pack(fill="x", pady=(20, 10))
        
        style = ttk.Style()
        style.theme_use('default')
        style.configure("TProgressbar", thickness=8, troughcolor=COLOR_PANEL, background=COLOR_ACCENT_CYAN)

        graph_frame = tk.Frame(content, bg=COLOR_PANEL, height=200)
        graph_frame.pack(fill="x", pady=10, expand=False)
        self.fig, self.ax = plt.subplots(figsize=(8, 2), facecolor=COLOR_PANEL)
        self.ax.set_facecolor("#0D1117")
        self.ax.tick_params(colors=COLOR_TEXT_DIM, labelsize=8)
        for spine in self.ax.spines.values(): spine.set_color(COLOR_PANEL)
        self.line_speed, = self.ax.plot([], [], color=COLOR_ACCENT_GREEN, label="Efficiency Multiplier (x)", linewidth=2)
        self.ax.legend(facecolor=COLOR_PANEL, edgecolor=COLOR_PANEL, labelcolor=COLOR_TEXT_DIM, loc='upper left', fontsize=8)
        self.canvas_graph = FigureCanvasTkAgg(self.fig, master=graph_frame)
        self.canvas_graph.get_tk_widget().pack(fill="both", expand=True)

        # 4. RESULTS & CONTROLS
        footer = tk.Frame(self, bg=COLOR_BG, height=100)
        footer.pack(fill="x", side="bottom", pady=30, padx=30)
        
        self.btn_run = tk.Button(footer, text="RUN HARDWARE AUDIT", bg=COLOR_ACCENT_CYAN, fg="black", 
                                 font=("Segoe UI", 12, "bold"), command=self.start_benchmark, relief="flat", padx=30, pady=12)
        self.btn_run.pack(side="top")
        
        self.result_frame = tk.Frame(footer, bg=COLOR_BG)
        self.result_frame.pack(side="top", pady=15)
        
        self.lbl_main_result = tk.Label(self.result_frame, text="", bg=COLOR_BG, font=("Segoe UI", 18, "bold"), fg=COLOR_ACCENT_GREEN)
        self.lbl_main_result.pack()
        self.lbl_time_saved = tk.Label(self.result_frame, text="", bg=COLOR_BG, font=("Consolas", 11), fg=COLOR_TEXT_DIM)
        self.lbl_time_saved.pack()

        self.x_data = []
        self.y_data = []

    def update_desc(self, event=None):
        fmt = self.selected_format.get()
        self.desc_lbl.config(text=VIDEO_FORMATS[fmt]["desc"])

    def log_status(self, msg):
        self.status_lbl.config(text=msg)

    def start_benchmark(self):
        if self.running: return
        self.running = True
        self.btn_run.config(state="disabled", text="AUDITING SYSTEM...")
        self.lbl_main_result.config(text="")
        self.lbl_time_saved.config(text="")
        self.progress_var.set(0)
        self.x_data, self.y_data = [], []
        self.ax.clear()
        self.ax.set_facecolor("#0D1117")
        self.canvas_graph.draw()
        
        threading.Thread(target=self.run_logic, daemon=True).start()

    def run_logic(self):
        try:
            fmt_name = self.selected_format.get()
            fmt_data = VIDEO_FORMATS[fmt_name]
            complexity = fmt_data["complexity"]
            
            # PHASE 1: CPU (Weighted by complexity)
            self.after(0, lambda: self.log_status(f"MEASURING CPU RENDER ({fmt_name})..."))
            start_time = time.time()
            # Simulation: Heavy hashing
            chunk = b'x' * 1024 * 1024
            target_mb = 15
            for i in range(target_mb):
                # More complexity = More loops
                loops = int(40 * complexity) 
                for _ in range(loops): hashlib.sha512(chunk).hexdigest()
                
                pct = (i/target_mb)*30
                speed = (i+1)/(time.time()-start_time)
                self.after(0, lambda p=pct, s=speed: self.update_ui(p, s, 0))
            
            raw_cpu_speed = target_mb / (time.time() - start_time)
            # Avoid division by zero
            self.cpu_score = max(0.1, raw_cpu_speed) 

            # PHASE 2: DISK GEN
            self.after(0, lambda: self.log_status("PREPARING STORAGE PAYLOAD..."))
            with open(self.temp_file, "wb") as f:
                f.write(os.urandom(1024*1024*64)) # 64MB Quick Test
                f.flush()
                os.fsync(f.fileno())

            # PHASE 3: METASPACE SIMULATION
            self.after(0, lambda: self.log_status("MEASURING METASPACE THROUGHPUT..."))
            start_time = time.time()
            bytes_read = 0
            file_size = 64 * 1024 * 1024
            
            with open(self.temp_file, "rb") as f:
                while True:
                    chunk = f.read(1024*1024)
                    if not chunk: break
                    bytes_read += len(chunk)
                    
                    # Simulate Bridge (10% of time, impacted by CPU complexity)
                    if (bytes_read // (1024*1024)) % 10 == 0:
                        loops = int(5 * complexity)
                        for _ in range(loops): hashlib.md5(chunk).digest()
                    
                    elapsed = time.time() - start_time
                    if elapsed > 0.05:
                        speed = (bytes_read/(1024*1024))/elapsed
                        pct = 30 + (bytes_read/file_size)*70
                        
                        # Calculate current multiplier
                        mult = speed / self.cpu_score
                        self.after(0, lambda p=pct, s=speed, m=mult: self.update_ui(p, self.cpu_score, s, m))

            self.disk_score = (bytes_read/(1024*1024))/(time.time()-start_time)
            
            self.after(0, self.show_results)

        except Exception as e:
            self.after(0, lambda: self.log_status(f"ERROR: {e}"))
        finally:
            self.running = False
            if os.path.exists(self.temp_file): os.remove(self.temp_file)
            self.after(0, lambda: self.btn_run.config(state="normal", text="RE-RUN AUDIT"))

    def update_ui(self, pct, cpu_val, disk_val, mult=0):
        self.progress_var.set(pct)
        self.gauge_cpu.update_value(cpu_val)
        self.gauge_disk.update_value(disk_val)
        
        if mult > 0:
            self.x_data.append(len(self.x_data))
            self.y_data.append(mult)
            if len(self.x_data) > 50: 
                self.x_data.pop(0)
                self.y_data.pop(0)
            
            self.ax.clear()
            self.ax.set_facecolor("#0D1117")
            self.ax.plot(self.x_data, self.y_data, color=COLOR_ACCENT_GREEN, linewidth=2)
            self.ax.legend(["Speedup Factor (x)"], facecolor=COLOR_PANEL, labelcolor=COLOR_TEXT_DIM, loc='upper left', fontsize=8)
            self.canvas_graph.draw()

    def show_results(self):
        self.progress_var.set(100)
        self.log_status("CALCULATION COMPLETE")
        
        multiplier = self.disk_score / self.cpu_score
        self.lbl_main_result.config(text=f"SPEEDUP FACTOR: {multiplier:.1f}x FASTER", fg=COLOR_ACCENT_GREEN)
        
        # Calculate Time Saved for 1 Hour Project (3600 sec)
        # Traditional Time
        trad_time = 3600 
        # MetaSpace Time = 3600 / multiplier
        meta_time = 3600 / multiplier
        saved_min = (trad_time - meta_time) / 60
        
        fmt = self.selected_format.get()
        self.lbl_time_saved.config(text=f"On a 1-hour {fmt} project,\nyou would save approx. {int(saved_min)} minutes.")

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