#!/usr/bin/env python3
"""
gen_evm_key_retro.py — Générateur de clés privées EVM style KEYGEN des années 2000.
Dimensions verrouillées : 500x360 pixels.
Thème visuel : Ville Overmind en parallaxe sur 3 couches, route perspective 3D animée, scanlines CRT.
Thème sonore : Syntheur Chiptune basse fréquence sans aucun aigu strident (style Mephisto Attack).
"""

from __future__ import annotations

import argparse
import json
import math
import os
import random
import struct
import sys
import threading
import time
from typing import Any

# =========================================================================
# SYSTEME DE GENERATION DE CLES CRYPTOGRAPHIQUES EVM (EIP-55 Checksum)
# =========================================================================
try:
    # eth_account utilise le CSPRNG du système d'exploitation sous le capot
    from eth_account import Account
except ImportError:
    sys.stderr.write("Erreur : le module 'eth-account' est manquant.\n")
    sys.stderr.write("Veuillez l'installer avec : pip install eth-account\n")
    sys.exit(1)


def gen_one(no_0x: bool = False) -> dict[str, str]:
    """
    Génère une clé privée de 32 octets via un générateur pseudo-aléatoire cryptographiquement sûr.
    Dérive ensuite l'adresse publique Ethereum avec le checksum conforme à la norme EIP-55.
    
    Args:
        no_0x (bool): Si True, la clé privée sera retournée sans le préfixe '0x'.
        
    Returns:
        dict[str, str]: Contient la clé privée sous 'private_key' et l'adresse sous 'address'.
    """
    # Création d'un compte éphémère sécurisé
    acct = Account.create()
    priv = acct.key.hex()
    if not no_0x:
        priv = "0x" + priv
    return {"private_key": priv, "address": acct.address}


# Détection de la disponibilité de l'interface graphique Tkinter
GUI_AVAILABLE = False
try:
    import tkinter as tk
    from tkinter import font as tkfont
    GUI_AVAILABLE = True
except ImportError:
    pass

# Détection de la compatibilité audio Windows
WINSOUND_AVAILABLE = False
if sys.platform == "win32":
    try:
        import winsound
        WINSOUND_AVAILABLE = True
    except ImportError:
        pass


# =========================================================================
# CHIPTUNE SYNTH — Moteur Audio Basse Fréquence (Anti-Aigu & Anti-Clics)
# =========================================================================
class ChiptuneSynth:
    """
    Générateur de musique chiptune rétro 8-bit mono à 22 050 Hz.
    Toutes les notes ont été transposées d'une octave supplémentaire vers le bas (40 Hz - 130 Hz)
    afin d'éliminer toute fréquence aiguë ou stridence agaçante pour l'utilisateur.
    Le signal utilise une enveloppe linéaire d'attaque et de relâchement pour éviter les bruits de clic.
    """

    SAMPLE_RATE = 22050  # Fréquence d'échantillonnage standard chiptune

    def __init__(self) -> None:
        self.playing = False
        self.temp_file = None
        self.wav_data: bytes | None = None
        self._generate_wav()  # Prégénération du signal en mémoire pour un chargement instantané

    def _generate_wav(self) -> None:
        """
        Génère les échantillons PCM 16-bit et construit le conteneur binaire au format RIFF/WAVE.
        La structure de la chanson comprend : Couplet x2 -> Refrain x2 -> Couplet x1 -> Pont x1 -> Refrain x2.

        Nettoie aussi tout fichier temporaire orphelin laissé par une session crashée précédente.
        """
        import io

        # --- Purge fichier temporaire orphelin d'une session précédente crashée ---
        try:
            import tempfile
            _orphan = os.path.join(tempfile.gettempdir(), "overmind_keygen_music.wav")
            if os.path.exists(_orphan):
                os.remove(_orphan)
        except Exception:
            pass
        
        # Fréquences transposées très bas (basse lourde et chaude)
        # 1. Couplet (Riff sombre et rapide en E-Phrygien)
        verse = [
            41.20, 41.20, 43.65, 41.20, 49.00, 43.65, 41.20, 43.65,
            41.20, 41.20, 61.74, 55.00, 49.00, 43.65, 41.20, 43.65
        ]
        
        # 2. Refrain (Ligne mélodique plus présente et enveloppante)
        chorus = [
            55.00, 65.41, 82.41, 110.00, 98.00, 82.41, 87.31, 73.42,
            55.00, 65.41, 82.41, 110.00, 123.47, 130.81, 110.00, 98.00
        ]
        
        # 3. Pont (Pulsations lourdes de sub-basse)
        bridge = [
            32.70, 32.70, 41.20, 32.70, 36.71, 36.71, 43.65, 36.71,
            49.00, 49.00, 55.00, 49.00, 55.00, 55.00, 65.41, 55.00
        ]
        
        # Assemblage structurel de la boucle audio
        melody = verse * 2 + chorus * 2 + verse + bridge + chorus * 2
        
        note_duration = 0.09  # Durée de 90ms par note (rythme rapide d'arpégiateur)
        samples_per_note = int(self.SAMPLE_RATE * note_duration)
        
        data = []
        for freq in melody:
            for i in range(samples_per_note):
                t = i / self.SAMPLE_RATE
                # Génération de l'onde sinusoïdale pure (plus douce que les ondes carrées)
                val = math.sin(2 * math.pi * freq * t)
                
                # Enveloppe ADSR simplifiée (Attaque de 15% et Relâchement de 25%) pour supprimer les clics
                envelope = 1.0
                fade_in_samples = int(samples_per_note * 0.15)
                fade_out_samples = int(samples_per_note * 0.25)
                
                if i < fade_in_samples:
                    envelope = i / fade_in_samples
                elif i > (samples_per_note - fade_out_samples):
                    envelope = (samples_per_note - i) / fade_out_samples
                
                # Amplitude calibrée à 6% maximum pour rester une musique d'ambiance très discrète
                val_scaled = int(val * 32767 * 0.06 * envelope)
                data.append(val_scaled)

        # En-tête standard du format audio WAVE (PCM 16-bit Mono)
        num_samples = len(data)
        data_bytes = struct.pack(f"<{num_samples}h", *data)
        byte_rate = self.SAMPLE_RATE * 2
        data_size = num_samples * 2
        
        buffer = io.BytesIO()
        buffer.write(b"RIFF")
        buffer.write(struct.pack("<I", 36 + data_size))
        buffer.write(b"WAVEfmt ")
        buffer.write(struct.pack("<IHHIIHH", 16, 1, 1, self.SAMPLE_RATE, byte_rate, 2, 16))
        buffer.write(b"data")
        buffer.write(struct.pack("<I", data_size))
        buffer.write(data_bytes)
        self.wav_data = buffer.getvalue()

    def start(self) -> None:
        """Démarre la lecture asynchrone de la musique en boucle depuis un fichier temporaire."""
        if not WINSOUND_AVAILABLE or not self.wav_data:
            return
        self.playing = True
        try:
            import tempfile
            # Écriture du buffer binaire sur le disque pour contourner les limitations SND_MEMORY de Windows
            self.temp_file = os.path.join(tempfile.gettempdir(), "overmind_keygen_music.wav")
            with open(self.temp_file, "wb") as f:
                f.write(self.wav_data)
            # Lecture asynchrone en boucle infinie
            winsound.PlaySound(self.temp_file, winsound.SND_FILENAME | winsound.SND_ASYNC | winsound.SND_LOOP)
        except Exception:
            pass

    def stop(self) -> None:
        """Arrête la musique et supprime proprement le fichier WAV temporaire."""
        self.playing = False
        if WINSOUND_AVAILABLE:
            try:
                winsound.PlaySound(None, winsound.SND_PURGE)
                if self.temp_file and os.path.exists(self.temp_file):
                    os.remove(self.temp_file)
            except Exception:
                pass

    def toggle(self) -> bool:
        """Bascule entre la lecture et la mise en pause."""
        if self.playing:
            self.stop()
            return False
        self.start()
        return True

    def reveal_beep(self) -> None:
        """Génère un signal sonore de transition grave/médium doux lors du reveal de la clé."""
        if not WINSOUND_AVAILABLE:
            return
        try:
            # Balayage fréquentiel grave (120 Hz à 240 Hz) pour éviter tout sifflement strident
            sps = int(self.SAMPLE_RATE * 0.18)
            raw = bytearray()
            for i in range(sps):
                t = i / self.SAMPLE_RATE
                f = 120.0 + (240.0 - 120.0) * (i / sps)
                val = math.sin(2 * math.pi * f * t)
                env = 1.0 - (i / sps) * 0.8
                v = int(val * 127 * 0.3 * env)
                raw.append((v + 128) & 0xFF)

            data_size = len(raw)
            buf = bytearray()
            buf += b"RIFF"
            buf += struct.pack("<I", 36 + data_size)
            buf += b"WAVEfmt "
            buf += struct.pack("<IHHIIHH", 16, 1, 1, self.SAMPLE_RATE, self.SAMPLE_RATE, 1, 8)
            buf += b"data"
            buf += struct.pack("<I", data_size)
            buf += raw
            winsound.PlaySound(bytes(buf), winsound.SND_MEMORY | winsound.SND_ASYNC)
        except Exception:
            pass


# =========================================================================
# APPLICATION GRAPHIQUE Retro Keygen 2000 (Tkinter)
# =========================================================================
class KeygenApp:
    # Palette de couleurs Cyberpunk néon
    BG_DEEP = "#000000"
    BG_PANEL = "#07070d"
    BG_TITLE = "#0f0f15"
    FG_GREEN = "#00ff41"
    FG_CYAN = "#00ffff"
    FG_MAG = "#ff00ff"
    FG_YEL = "#ffff00"
    FG_RED = "#ff0055"

    # Dimensions fixes obligatoires du Keygen
    W = 500
    H = 360
    CANVAS_H = 216  # Hauteur dédiée à la scène graphique animée

    def __init__(self, root: tk.Tk) -> None:
        self.root = root
        self.root.title("OVERMIND BEARER KEYGEN 2000")
        self.root.configure(bg=self.BG_DEEP)
        self.root.resizable(False, False)

        # Mode Borderless (pas de bordures système Windows)
        self.root.overrideredirect(True)
        sw, sh = root.winfo_screenwidth(), root.winfo_screenheight()
        x, y = (sw - self.W) // 2, (sh - self.H) // 2
        self.root.geometry(f"{self.W}x{self.H}+{x}+{y}")

        # Variables pour permettre le déplacement (drag & drop) de la fenêtre
        self._drag_x: int | None = None
        self._drag_y: int | None = None
        root.bind("<ButtonPress-1>", self._on_press)
        root.bind("<ButtonRelease-1>", self._on_release)
        root.bind("<B1-Motion>", self._on_motion)
        
        # Raccourcis clavier (Échap pour quitter, F1 pour générer)
        root.bind("<Escape>", lambda e: self._close())
        root.bind("<F1>", lambda e: self._start_generation())

        # Variables d'état des animations
        self.grid_offset = 0.0
        self.traffic_offset = 0.0
        self.scan_y = 0
        self.stars: list[dict[str, Any]] = []
        
        # ---------------------------------------------------------------------
        # DESIGN DE LA SCENE URBAINE DE LA VILLE EN PARALLAXE (3 COUCHES)
        # ---------------------------------------------------------------------
        
        # 1. COUCHE ARRIÈRE-PLAN (Lente, silhouettes très sombres)
        # Défilement : -0.07px par frame
        self.buildings_far = [
            {"x": 10.0, "w": 60, "h": 160, "col": "#0b0417"},
            {"x": 100.0, "w": 75, "h": 140, "col": "#05081f"},
            {"x": 200.0, "w": 55, "h": 170, "col": "#0b0417"},
            {"x": 290.0, "w": 80, "h": 150, "col": "#05081f"},
            {"x": 390.0, "w": 65, "h": 165, "col": "#0b0417"},
            {"x": 480.0, "w": 70, "h": 135, "col": "#05081f"}
        ]
        
        # 2. COUCHE INTERMÉDIAIRE (Vitesse moyenne, immeubles filaires mauves)
        # Défilement : -0.18px par frame
        self.buildings_mid = [
            {"x": 30.0, "w": 45, "h": 115, "col": "#1f0933", "roof": 1},
            {"x": 110.0, "w": 55, "h": 135, "col": "#101647", "roof": 0},
            {"x": 210.0, "w": 50, "h": 120, "col": "#1f0933", "roof": 3},
            {"x": 310.0, "w": 60, "h": 145, "col": "#101647", "roof": 1},
            {"x": 410.0, "w": 45, "h": 125, "col": "#1f0933", "roof": 0}
        ]
        
        # 3. COUCHE PREMIER PLAN (Rapide, détails néons, antennes, panneaux publicitaires)
        # Défilement : -0.48px par frame
        # types de toit (roof): 0=plat, 1=escalier, 2=antenne + feu de signalisation, 3=dôme, 4=double flèche
        self.buildings_fg = [
            {"x": 5.0, "w": 40, "h": 90, "col": "#b800b8", "roof": 2, "sign": "OVR"},
            {"x": 65.0, "w": 30, "h": 120, "col": "#0055ff", "roof": 0, "sign": ""},
            {"x": 115.0, "w": 35, "h": 75, "col": "#5a00bd", "roof": 1, "sign": ""},
            {"x": 170.0, "w": 45, "h": 135, "col": "#ff00ff", "roof": 4, "sign": "EVM"},
            {"x": 235.0, "w": 30, "h": 85, "col": "#0088ff", "roof": 0, "sign": ""},
            {"x": 285.0, "w": 35, "h": 110, "col": "#00ffcc", "roof": 3, "sign": "SYS"},
            {"x": 340.0, "w": 40, "h": 130, "col": "#990099", "roof": 2, "sign": ""},
            {"x": 400.0, "w": 45, "h": 115, "col": "#00ff99", "roof": 1, "sign": ""},
            {"x": 465.0, "w": 35, "h": 80, "col": "#0055ff", "roof": 0, "sign": ""}
        ]

        self.current_key: dict[str, str] | None = None

        # --- Splash LOADING style keygen 2000 (1.5s) ---
        self._splash_start = time.time()
        self._splash_label: tk.Label | None = None
        self._splash_bar: int = 0

        self._build_ui()
        self._show_splash()
        
        # Génération aléatoire d'un champ d'étoiles colorées et scintillantes
        for _ in range(40):
            self.stars.append({
                "x": random.randint(2, self.W - 2),
                "y": random.randint(2, 128),
                "color": random.choice(["#ffffff", "#00ffff", "#ff00ff", "#8888aa"]),
                "size": random.choice([1, 2])
            })

        # Initialisation et lecture de la musique
        self.synth = ChiptuneSynth()
        self.synth.start()

        # Démarrage des boucles temporelles d'animation Tkinter
        self._tick_city()
        self._tick_glitch()

    # Event Handlers pour le déplacement sans bordure de la fenêtre
    def _on_press(self, e):
        self._drag_x = e.x
        self._drag_y = e.y

    def _on_release(self, e):
        self._drag_x = None
        self._drag_y = None

    def _on_motion(self, e):
        if self._drag_x is None:
            return
        dx = e.x - self._drag_x
        dy = e.y - self._drag_y
        self.root.geometry(f"+{self.root.winfo_x() + dx}+{self.root.winfo_y() + dy}")

    def _tick_city(self) -> None:
        """Dessine et anime l'ensemble de la scène graphique néon de façon synchrone."""
        self.canvas_bg.delete("all")
        
        horizon_y = 130
        max_y = self.CANVAS_H
        
        # 1. ÉTOILES SCINTILLANTES
        for star in self.stars:
            # Twinkle discret par variation d'intensité aléatoire
            color = star["color"]
            if random.random() < 0.08:
                color = random.choice(["#333344", "#555566", star["color"]])
            
            s = star["size"]
            self.canvas_bg.create_oval(
                star["x"], star["y"], star["x"] + s, star["y"] + s,
                fill=color, outline=""
            )

        # 2. SILHOUETTES URBAINES D'ARRIÈRE-PLAN (COUCHE 1 - LENTE)
        for b in self.buildings_far:
            b["x"] -= 0.07
            if b["x"] + b["w"] < 0:
                b["x"] = self.W
            
            x, w, h, col = b["x"], b["w"], b["h"], b["col"]
            top_y = horizon_y - h
            # Rectangle plein avec bordure wireframe très sombre
            self.canvas_bg.create_rectangle(
                x, top_y, x + w, horizon_y,
                fill="#020006", outline=col, width=1
            )

        # 3. IMMEUBLES DE COUCHE INTERMÉDIAIRE (COUCHE 2 - MOYENNE)
        for b in self.buildings_mid:
            b["x"] -= 0.18
            if b["x"] + b["w"] < 0:
                b["x"] = self.W
            
            x, w, h, col, roof = b["x"], b["w"], b["h"], b["col"], b["roof"]
            top_y = horizon_y - h
            
            # Dessin de l'immeuble de base
            self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#04000b", outline=col, width=1)
            
            # Structures architecturales supplémentaires sur le toit
            if roof == 1:  # Stepped/Escalier
                self.canvas_bg.create_rectangle(x + 5, top_y - 6, x + w - 5, top_y, fill="#04000b", outline=col, width=1)
            elif roof == 3:  # Dome/Coupole
                self.canvas_bg.create_arc(x + 6, top_y - 12, x + w - 6, top_y + 4, start=0, extent=180, fill="#04000b", outline=col, width=1)

        # 4. IMMEUBLES DU PREMIER PLAN DETAILLES (COUCHE 3 - RAPIDE)
        for b in self.buildings_fg:
            b["x"] -= 0.48
            if b["x"] + b["w"] < 0:
                b["x"] = self.W
                
            x, w, h, col, roof = b["x"], b["w"], b["h"], b["col"], b["roof"]
            sign = b.get("sign", "")
            top_y = horizon_y - h
            
            # Structure du toit de premier plan
            if roof == 1:  # Toit en escalier
                self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#060012", outline=col, width=1.5)
                self.canvas_bg.create_rectangle(x + 4, top_y - 5, x + w - 4, top_y, fill="#060012", outline=col, width=1.5)
                self.canvas_bg.create_rectangle(x + 8, top_y - 10, x + w - 8, top_y - 5, fill="#060012", outline=col, width=1.5)
            elif roof == 2:  # Toit avec mât et feu rouge clignotant
                self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#060012", outline=col, width=1.5)
                cx = x + w // 2
                self.canvas_bg.create_line(cx, top_y, cx, top_y - 15, fill=col, width=1.5)
                # Clignotement du voyant de sécurité
                flash_col = "#ff0000" if (int(time.time() * 3.5) % 2 == 0) else "#440000"
                self.canvas_bg.create_oval(cx - 2.5, top_y - 17.5, cx + 2.5, top_y - 12.5, fill=flash_col, outline="")
            elif roof == 3:  # Coupole
                self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#060012", outline=col, width=1.5)
                self.canvas_bg.create_arc(x + 4, top_y - 14, x + w - 4, top_y + 2, start=0, extent=180, fill="#060012", outline=col, width=1.5)
            elif roof == 4:  # Deux antennes / flèches
                self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#060012", outline=col, width=1.5)
                self.canvas_bg.create_line(x + 6, top_y, x + 6, top_y - 12, fill=col, width=1.2)
                self.canvas_bg.create_line(x + w - 6, top_y, x + w - 6, top_y - 12, fill=col, width=1.2)
                # Feux de signalisation alternés
                f1_col = "#ff0000" if (int(time.time() * 3) % 2 == 0) else "#440000"
                f2_col = "#440000" if (int(time.time() * 3) % 2 == 0) else "#ff0000"
                self.canvas_bg.create_oval(x + 4, top_y - 14, x + 8, top_y - 10, fill=f1_col, outline="")
                self.canvas_bg.create_oval(x + w - 8, top_y - 14, x + w - 4, top_y - 10, fill=f2_col, outline="")
            else:  # Toit plat simple
                self.canvas_bg.create_rectangle(x, top_y, x + w, horizon_y, fill="#060012", outline=col, width=1.5)
                
            # Dessin des enseignes néons lumineuses publicitaires
            if sign:
                # Plaque de fond néon
                self.canvas_bg.create_rectangle(
                    x + w//2 - 14, top_y + 12, x + w//2 + 14, top_y + 24,
                    fill="#000000", outline=self.FG_CYAN if sign == "SYS" else self.FG_MAG, width=1
                )
                self.canvas_bg.create_text(
                    x + w//2, top_y + 18, text=sign,
                    fill=self.FG_CYAN if sign == "SYS" else self.FG_MAG,
                    font=("Courier", 8, "bold")
                )

            # Fenêtres éclairées de façon dynamique à l'aide d'un PRNG déterministe basé sur l'abscisse
            random.seed(int(x) + 400)
            cols = w // 8
            rows = h // 11
            for r in range(1, rows):
                for c in range(1, cols):
                    # Taux de fenêtres allumées (40%)
                    if random.random() < 0.40:
                        win_x = x + c * 8
                        win_y = top_y + r * 11
                        # Variantes de couleurs chaudes de fenêtres rétro
                        win_c = random.choice(["#ffff55", "#ffaa00", "#ffffff"])
                        self.canvas_bg.create_rectangle(
                            win_x, win_y, win_x + 2, win_y + 2,
                            fill=win_c, outline=""
                        )

        # 5. ROUTE HIGHWAY PERSPECTIVE 3D ET TRAFFIC D'IMPULSION
        # Ligne d'horizon néon magenta
        self.canvas_bg.create_line(0, horizon_y, self.W, horizon_y, fill="#ff00ff", width=2)
        
        # Dessin des lignes de fuite verticales (Perspective radiale)
        for i in range(-12, 13):
            self.canvas_bg.create_line(250 + i * 6, horizon_y, 250 + i * 45, max_y, fill="#003c55", width=1)
            
        # Lignes d'horizon horizontales qui se rapprochent et s'accélèrent vers le bas (effet tunnel)
        # L'incrément oscille entre 1.2 et 3.5 pour simuler des cycles d'accélération/décélération
        if not hasattr(self, "_grid_speed"):
            self._grid_speed = 1.2
            self._grid_dir = 1
        # Bascule de direction aux bornes pour rester dans une plage visuelle stable
        if self._grid_speed >= 3.5:
            self._grid_dir = -1
        elif self._grid_speed <= 1.2:
            self._grid_dir = 1
        self._grid_speed += 0.012 * self._grid_dir
        self.grid_offset = (self.grid_offset + self._grid_speed) % 12
        y_lines = [130, 133, 137, 143, 152, 165, 183, 208, 240]
        for idx, y in enumerate(y_lines[:-1]):
            next_y = y_lines[idx+1]
            interpolated_y = y + (next_y - y) * (self.grid_offset / 12.0)
            if interpolated_y <= max_y:
                self.canvas_bg.create_line(0, interpolated_y, self.W, interpolated_y, fill="#007799", width=1)

        # Animation des flux de trafic néon (les "voitures" ou paquets binaires)
        self.traffic_offset = (self.traffic_offset + 0.035) % 1.0
        # Les véhicules se déplacent sur les voies clés du réseau routier virtuel
        for lane_idx in [-5, -2, 2, 5]:
            for car_p in range(3):
                p = (self.traffic_offset + car_p / 3.0) % 1.0
                p_curved = p * p  # Distorsion quadratique perspective correcte
                
                y_p = horizon_y + p_curved * (max_y - horizon_y)
                x_p = 250 + lane_idx * (6 + p_curved * 39)
                
                # Taille proportionnelle à la proximité de la caméra
                size = 1 + p_curved * 4.5
                color = self.FG_CYAN if lane_idx > 0 else self.FG_MAG
                
                self.canvas_bg.create_rectangle(
                    x_p - size, y_p - size/2.5, x_p + size, y_p + size/2.5,
                    fill=color, outline=""
                )


        # 6. FILTRE CRT ET EFFET SCANLINE BALAYAGE VISUEL
        self.scan_y = (self.scan_y + 3) % (self.H + 80)
        self.canvas_bg.create_rectangle(
            0, self.scan_y - 20, self.W, self.scan_y,
            fill=self.FG_GREEN, stipple="gray12", outline=""
        )
        
        # Quadrillage de lignes horizontales d'interfaçage moniteur cathodique
        for y in range(0, self.CANVAS_H, 3):
            self.canvas_bg.create_line(0, y, self.W, y, fill="#010a05")

        # Prochain rafraîchissement d'affichage (~30 FPS)
        self.root.after(33, self._tick_city)

    def _tick_glitch(self) -> None:
        """Gère les micro-glitchs textuels et clignotements chromatiques du titre du Keygen."""
        try:
            colors = [self.FG_GREEN, self.FG_CYAN, self.FG_MAG, self.FG_YEL, self.FG_RED]
            self.title_lbl.config(fg=random.choice(colors))
            t = "🚀  OVERMIND BEARER KEYGEN 2 0 0 0  🚀"
            # Une chance sur quatre d'avoir un caractère altéré/cryptique temporaire
            if random.random() < 0.25:
                idx = random.randint(0, len(t) - 1)
                t = t[:idx] + random.choice("█▓▒░*#@&$") + t[idx + 1:]
            self.title_lbl.config(text=t)
        except Exception:
            pass
        self.root.after(160, self._tick_glitch)

    def _build_ui(self) -> None:
        """Initialise, positionne et configure tous les widgets Tkinter de l'application."""
        # Canvas principal recevant le rendu de la ville
        self.canvas_bg = tk.Canvas(
            self.root, width=self.W, height=self.CANVAS_H,
            bg="#020005", highlightthickness=0, bd=0
        )
        self.canvas_bg.place(x=0, y=26)

        # Barre de titre supérieure permettant de faire glisser la fenêtre borderless
        title_bar = tk.Frame(self.root, bg=self.BG_TITLE, height=26)
        title_bar.place(x=0, y=0, width=self.W, height=26)
        title_bar.bind("<ButtonPress-1>", self._on_press)
        title_bar.bind("<ButtonRelease-1>", self._on_release)
        title_bar.bind("<B1-Motion>", self._on_motion)

        self.title_lbl = tk.Label(
            title_bar, text="🚀  OVERMIND BEARER KEYGEN 2 0 0 0  🚀",
            fg=self.FG_GREEN, bg=self.BG_TITLE,
            font=("Courier", 11, "bold"),
        )
        self.title_lbl.pack(side="left", padx=8)

        # Bouton Fermer [X]
        close_btn = tk.Button(
            self.root, text="[X]", command=self._close,
            fg=self.FG_RED, bg=self.BG_TITLE,
            activeforeground="#ffffff", activebackground="#660000",
            bd=1, relief="raised",
            font=("Courier", 10, "bold"),
            width=4, cursor="hand2",
        )
        close_btn.place(x=self.W - 38, y=2)

        # Ruban de texte défilant de pied de scène (Marquee)
        self.marquee_text = "   *** OVERMIND BEARER KEYGEN v1.0 *** CRAFTED BY DEMON-CORP *** FORGE YOUR KEY SECURELY *** FOR OVERMIND BEARER USE *** GREETZ TO ALL CO-AGENTS IN THE GRID ***   "
        self.foot_lbl = tk.Label(
            self.root,
            text=self.marquee_text,
            fg=self.FG_MAG, bg=self.BG_DEEP,
            font=("Courier", 8, "bold")
        )
        self.foot_lbl.place(x=10, y=243)

        # Zone d'affichage des clés générées (Formulaire enclavé)
        self.key_frame = tk.Frame(self.root, bg=self.BG_PANEL, bd=1, relief="sunken")
        self.key_frame.place(x=10, y=264, width=self.W - 20, height=52)
        self.key_frame.columnconfigure(1, weight=1)

        # Label et Entry de l'Adresse Ethereum
        tk.Label(self.key_frame, text="ADDRESS:", fg=self.FG_CYAN, bg=self.BG_PANEL, font=("Courier", 8, "bold")).grid(row=0, column=0, sticky="w", padx=5, pady=2)
        self.addr_var = tk.StringVar(value="0x........................................")
        self.addr_entry = tk.Entry(self.key_frame, textvariable=self.addr_var, fg=self.FG_GREEN, bg="#050a06", insertbackground=self.FG_GREEN, font=("Courier", 8, "bold"), bd=1, width=52)
        self.addr_entry.grid(row=0, column=1, padx=5, pady=2, sticky="ew")
        self.addr_entry.config(state="readonly")

        # Label et Entry de la Clé Privée (Verrouillée en Cyan `#00ffff` sur fond sombre)
        tk.Label(self.key_frame, text="PRIVATE:", fg=self.FG_CYAN, bg=self.BG_PANEL, font=("Courier", 8, "bold")).grid(row=1, column=0, sticky="w", padx=5, pady=2)
        self.priv_var = tk.StringVar(value="")
        self.priv_entry = tk.Entry(self.key_frame, textvariable=self.priv_var, fg=self.FG_CYAN, bg="#050a0a", insertbackground=self.FG_CYAN, font=("Courier", 8, "bold"), bd=1, show="*", width=52)
        self.priv_entry.grid(row=1, column=1, padx=5, pady=2, sticky="ew")
        self.priv_entry.config(state="readonly")

        # Conteneur des boutons d'actions inférieurs
        btn_frame = tk.Frame(self.root, bg=self.BG_DEEP)
        btn_frame.place(x=10, y=320)

        # Usine à boutons stylisés
        def btn(parent, text, cmd, fg=None, width=15):
            return tk.Button(
                parent, text=text, command=cmd,
                fg=fg or self.FG_GREEN, bg=self.BG_TITLE,
                activeforeground="#ffffff", activebackground="#333333",
                bd=2, relief="raised",
                font=("Courier", 10, "bold"),
                width=width, padx=6, pady=4,
                cursor="hand2",
            )

        self.gen_btn = btn(btn_frame, "[ GENERATE ]", self._start_generation)
        self.gen_btn.pack(side="left", padx=5)

        self.copy_btn = btn(btn_frame, "[ COPY PRIVATE ]", self._copy_private, fg="#ffcc00")
        self.copy_btn.pack(side="left", padx=5)
        self.copy_btn.config(state="disabled")

        self.music_btn = btn(btn_frame, "[ MUSIC: ON ]", self._toggle_music, fg=self.FG_GREEN)
        self.music_btn.pack(side="left", padx=5)

    def _show_splash(self) -> None:
        """Affiche un écran de chargement rétro 'LOADING OVERMIND OS...' pendant 1.5s."""
        # Overlay plein écran sur le canvas de scène
        self._splash_overlay = tk.Frame(self.root, bg="#000000", bd=2, relief="ridge",
                                        highlightthickness=2, highlightbackground=self.FG_CYAN)
        self._splash_overlay.place(x=4, y=30, width=self.W - 8, height=self.CANVAS_H - 8)

        tk.Label(
            self._splash_overlay, text=">>> LOADING OVERMIND OS v1.0 <<<",
            fg=self.FG_GREEN, bg="#000000",
            font=("Courier", 10, "bold"),
        ).pack(pady=(40, 8))

        # Progress bar textuelle
        self._splash_bar_lbl = tk.Label(
            self._splash_overlay, text="[                    ]  0%",
            fg=self.FG_YEL, bg="#000000",
            font=("Courier", 10, "bold"),
        )
        self._splash_bar_lbl.pack(pady=4)

        tk.Label(
            self._splash_overlay, text="Mounting entropy pool...",
            fg=self.FG_MAG, bg="#000000",
            font=("Courier", 8, "bold"),
        ).pack(pady=(20, 0))

        # Démarre l'animation de la progress bar
        self._update_splash(0)

    def _update_splash(self, pct: int) -> None:
        """Avance la jauge LOADING et détruit l'overlay à 100%."""
        try:
            bar = "[" + "█" * (pct // 5) + " " * (20 - pct // 5) + "]"
            self._splash_bar_lbl.config(text=f"{bar}  {pct:3d}%")
        except Exception:
            return
        if pct >= 100:
            # Splash terminé -> on retire l'overlay
            try:
                self._splash_overlay.destroy()
            except Exception:
                pass
            return
        self.root.after(30, self._update_splash, pct + 2)

    def _glitch_rgb_shift(self) -> None:
        """Effet VHS : décale temporairement les couleurs de l'overlay frame pendant 150ms."""
        try:
            # On crée 3 copies translatées du canvas de scène en R/G/B (effet chromatisme)
            w, h = self.W, self.CANVAS_H
            # 3 lignes fines de couleurs pures qui flashent (simule un shift RGB discret)
            self.canvas_bg.create_rectangle(2, 0, w, 3, fill="#ff0000", stipple="gray25", outline="", tags="rgb")
            self.canvas_bg.create_rectangle(-2, 0, w - 4, 3, fill="#00ff00", stipple="gray25", outline="", tags="rgb")
            self.canvas_bg.create_rectangle(0, 0, w, 3, fill="#0000ff", stipple="gray25", outline="", tags="rgb")
            # Auto-cleanup
            self.root.after(150, lambda: self.canvas_bg.delete("rgb"))
        except Exception:
            pass

    def _start_generation(self) -> None:
        """Déclenche la routine asynchrone de génération et de reveal de la paire de clés."""
        if self.gen_btn.cget("state") == "disabled":
            return
        self.gen_btn.config(state="disabled")
        self.copy_btn.config(state="disabled")
        self.priv_var.set("")
        self.addr_var.set("0x" + "•" * 40)
        t = threading.Thread(target=self._scan_then_reveal, daemon=True)
        t.start()

    def _scan_then_reveal(self) -> None:
        """Génère la clé, joue le signal sonore basse-fréquence, et révèle les caractères l'un après l'autre."""
        try:
            key = gen_one()
        except Exception:
            self.root.after(0, lambda: self.gen_btn.config(state="normal"))
            return

        self.current_key = key
        addr = key["address"]
        priv = key["private_key"]

        # Signal de transition sonore non strident
        self.synth.reveal_beep()

        # Révélation progressive de l'Adresse
        for i in range(len(addr)):
            shown = addr[: i + 1] + "•" * (len(addr) - i - 1)
            self.root.after(0, lambda s=shown: self.addr_var.set(s))
            time.sleep(0.015)
        self.root.after(0, lambda: self.addr_var.set(addr))

        # Flash lumineux d'impact rétro sur le canvas
        self.root.after(0, self._flash)
        # Glitch VHS (décalage RGB) qui accompagne le reveal
        self.root.after(0, self._glitch_rgb_shift)

        # Révélation progressive de la Clé Privée
        for i in range(len(priv)):
            shown = priv[: i + 1] + "•" * (len(priv) - i - 1)
            self.root.after(0, lambda s=shown: self.priv_var.set(s))
            time.sleep(0.02)

        # Déverrouillage des boutons d'actions
        self.root.after(0, lambda: self.gen_btn.config(state="normal"))
        self.root.after(0, lambda: self.copy_btn.config(state="normal"))

    def _flash(self) -> None:
        """Crée un flash lumineux stroboscopique vert transparent d'une fraction de seconde."""
        fl = self.canvas_bg.create_rectangle(
            0, 0, self.W, self.CANVAS_H, fill=self.FG_GREEN, stipple="gray12", outline=""
        )
        self.root.after(120, lambda: self.canvas_bg.delete(fl))

    def _copy_private(self) -> None:
        """Copie la paire {address, private_key} en JSON dans le presse-papiers système.

        Format: {"address":"0x...","private_key":"0x..."}  (une seule ligne, prêt à coller).
        """
        if not self.current_key:
            return
        # JSON une ligne, séparateurs serrés, prêt à coller dans un autre outil
        payload = json.dumps(
            {"address": self.current_key["address"],
             "private_key": self.current_key["private_key"]},
            separators=(",", ":"),
        )
        try:
            self.root.clipboard_clear()
            self.root.clipboard_append(payload)
            self.root.update()
        except Exception:
            pass
        # Feedback visuel temporaire sur le bouton
        orig = "[ COPY PRIVATE ]"
        self.copy_btn.config(text="[ COPIED! ]", fg=self.FG_GREEN)
        self.root.after(1500, lambda: self.copy_btn.config(text=orig, fg="#ffcc00"))

    def _toggle_music(self) -> None:
        """Active/Désactive la lecture du module chiptune de fond."""
        playing = self.synth.toggle()
        if playing:
            self.music_btn.config(text="[ MUSIC: ON ]", fg=self.FG_GREEN)
        else:
            self.music_btn.config(text="[ MUSIC: OFF ]", fg=self.FG_RED)

    def start_marquee(self) -> None:
        """Démarre le fil de texte défilant dans un thread autonome."""
        def scroll():
            text = self.marquee_text
            while True:
                try:
                    text = text[1:] + text[0]
                    self.foot_lbl.config(text=text)
                    time.sleep(0.1)
                except Exception:
                    break
        t = threading.Thread(target=scroll, daemon=True)
        t.start()

    def _close(self) -> None:
        """Stoppe les audios et détruit la fenêtre Tkinter pour quitter proprement."""
        self.synth.stop()
        try:
            self.root.destroy()
        except Exception:
            pass


# =========================================================================
# LOBBY DE LANCEMENT ET EXECUTION CLI / GUI
# =========================================================================
def run_gui() -> None:
    root = tk.Tk()
    app = KeygenApp(root)
    app.start_marquee()
    root.mainloop()


def main() -> int:
    p = argparse.ArgumentParser(
      description="OVERMIND BEARER KEYGEN 2000 — Générateur rétro sécurisé d'adresses et clés privées EVM"
    )
    p.add_argument("--cli", action="store_true", help="Forcer le mode console CLI")
    p.add_argument("--count", type=int, default=1, help="Nombre de clés à générer (mode CLI)")
    p.add_argument("--out", type=str, default=None, help="Exporter les résultats en format JSON dans un fichier")
    p.add_argument("--no-0x", action="store_true", help="Générer la clé privée brute sans préfixe 0x")
    args = p.parse_args()

    # Si Tkinter est indisponible ou si l'utilisateur spécifie explicitement le mode CLI
    if not GUI_AVAILABLE or args.cli or args.out or args.count > 1:
        if args.count < 1 or args.count > 1000:
            sys.stderr.write("Erreur : --count doit être compris entre 1 et 1000.\n")
            return 1
        keys: list[dict[str, str]] = [gen_one(no_0x=args.no_0x) for _ in range(args.count)]
        payload: Any = keys[0] if args.count == 1 else keys
        text = json.dumps(payload, indent=2)
        
        if args.out:
            tmp = args.out + ".tmp"
            with open(tmp, "w", encoding="utf-8") as f:
                f.write(text)
                f.write("\n")
            try:
                os.chmod(tmp, 0o600)  # Restreindre la lecture/écriture au propriétaire de la machine
            except Exception:
                pass
            os.replace(tmp, args.out)
            sys.stderr.write(f"Succès : {len(keys)} clé(s) écrite(s) dans '{args.out}' (droits 0600).\n")
        else:
            sys.stdout.write(text + "\n")
        return 0

    run_gui()
    return 0


if __name__ == "__main__":
    sys.exit(main())