content: package com.alphabugx;
  
  import com.alphabugx.security.SecurityManager;
  import com.alphabugx.security.AntiDecompileShield;
  import javafx.application.Application;
  import javafx.application.Platform;
  import javafx.fxml.FXMLLoader;
  import javafx.scene.Scene;
  import javafx.scene.control.Alert;
  import javafx.scene.control.ButtonBar;
  import javafx.scene.control.ButtonType;
  import javafx.scene.layout.AnchorPane;  // 修改为 AnchorPane
  import javafx.scene.layout.BorderPane;
  import javafx.stage.Stage;
  
  import java.io.IOException;
  import java.util.Optional;
  
  public class Jawd extends Application {
  
      // 静态代码块：在类加载时执行安全检查
      static {
          try {
              // 开发环境检测
              boolean isDevelopment = isDebugEnvironment();
              
              if (!isDevelopment) {
                  // 执行假的安全检查以迷惑反编译者
                  AntiDecompileShield.performDecoySecurityCheck();
                  
                  // 执行真正的安全检查
                  SecurityManager.performSecurityCheck();
                  
                  // 验证高级保护是否激活
                  if (!AntiDecompileShield.isProtectionActive()) {
                      throw new SecurityException("Protection validation failed");
                  }
              } else {
                  System.out.println("开发环境检测到，跳过安全检查");
                  // 打印编码信息用于调试
                  com.alphabugx.util.EncodingHelper.printEncodingInfo();
              }
          } catch (Exception e) {
              // 安全检查失败，伪装成配置错误
              System.err.println("Configuration initialization failed: " + e.getMessage());
              System.exit(1);
          }
      }
      
      /**
       * 检测是否为开发环境
       */
      private static boolean isDebugEnvironment() {
          // 检查是否在IDE中运行
          String classpath = System.getProperty("java.class.path", "");
          if (classpath.contains("idea") || classpath.contains("eclipse") || classpath.contains("netbeans")) {
              return true;
          }
          
          // 检查是否在Maven target目录中运行
          String userDir = System.getProperty("user.dir", "");
          if (userDir.contains("target") || userDir.contains("IdeaProjects")) {
              return true;
          }
          
          // 检查JVM参数
          String vmOptions = System.getProperty("java.vm.name", "");
          if (vmOptions.contains("HotSpot") && System.getProperty("sun.java.command", "").contains("idea")) {
              return true;
          }
          
          return false;
      }
  
      public static void main(String[] args) throws IOException {
          // 运行前再次检查环境安全性
          if (!SecurityManager.isSecureEnvironment()) {
              System.err.println("Unsupported runtime environment");
              System.exit(1);
              return;
          }
          
          launch(args);
      }
  
      @Override
      public void start(Stage primaryStage) throws IOException {
          // 启动时安全检查
          if (!SecurityManager.isSecureEnvironment()) {
              System.err.println("Runtime security check failed");
              Platform.exit();
              return;
          }
          
          FXMLLoader loader = new FXMLLoader(Jawd.class.getResource("/com/alphabugx/Editor.fxml"));
          BorderPane root = loader.load();
  
          // 使用加密的应用标题
          String appName = SecurityManager.getAppName();
          String version = SecurityManager.getVersion();
          String title = appName + " v1.0 - by Alphabug";
  //        String title = appName + " v" + version + " - by Alphabug";
  
          // 设置场景
          Scene scene = new Scene(root, 1200, 800);
          primaryStage.setTitle(title);
          primaryStage.setScene(scene);
          primaryStage.setMinWidth(800);
          primaryStage.setMinHeight(600);
          
          // 设置关闭时的强制退出处理
          primaryStage.setOnCloseRequest(event -> {
              event.consume(); // 阻止默认关闭行为
              
              Alert alert = new Alert(Alert.AlertType.WARNING);
              alert.setTitle("确认退出");
              alert.setHeaderText("强制退出应用程序");
              alert.setContentText("检测到后台可能存在运行的进程。\n" +
                                 "点击「强制退出」将终止所有相关的Java进程。\n" +
                                 "点击「取消」返回应用程序。\n\n" +
                                 "是否确认强制退出？");
              
              // 自定义按钮
              ButtonType forceExitButton = new ButtonType("强制退出", ButtonBar.ButtonData.YES);
              ButtonType cancelButton = new ButtonType("取消", ButtonBar.ButtonData.CANCEL_CLOSE);
              alert.getButtonTypes().setAll(forceExitButton, cancelButton);
              
              // 设置警告图标
              alert.setAlertType(Alert.AlertType.WARNING);
              
              Optional<ButtonType> result = alert.showAndWait();
              if (result.isPresent() && result.get() == forceExitButton) {
                  performForceExit();
              }
          });
          
          primaryStage.show();
      }
      
  
      
      /**
       * 执行强制退出操作
       */
      private void performForceExit() {
          try {
              // 1. 安全清理
              SecurityManager.performCleanup();
              
              // 2. 显示退出进度
              System.out.println("正在强制退出应用程序...");
              
              // 3. 尝试终止所有Java进程（包括javaw）
              killJavaProcesses();
              
              // 4. 强制退出JavaFX平台
              Platform.exit();
              
              // 5. 最后的保险 - 强制退出JVM
              System.exit(0);
              
          } catch (Exception e) {
              System.err.println("强制退出时发生异常: " + e.getMessage());
              // 即使出现异常也要强制退出
              System.exit(1);
          }
      }
      
      /**
       * 终止所有相关的Java进程
       */
      private void killJavaProcesses() {
          try {
              String os = System.getProperty("os.name").toLowerCase();
              
              if (os.contains("win")) {
                  // Windows系统 - 终止javaw.exe进程
                  System.out.println("终止Windows Java进程...");
                  
                  // 方法1：使用taskkill终止当前进程组
                  String currentPid = getCurrentProcessId();
                  ProcessBuilder pb1 = new ProcessBuilder("taskkill", "/F", "/T", "/PID", currentPid);
                  pb1.start();
                  
                  // 方法2：终止所有javaw.exe（谨慎使用，可能影响其他Java应用）
                  // ProcessBuilder pb2 = new ProcessBuilder("taskkill", "/F", "/IM", "javaw.exe");
                  // pb2.start();
                  
                  // 给进程一点时间来终止
                  Thread.sleep(1000);
                  
              } else if (os.contains("nix") || os.contains("nux") || os.contains("mac")) {
                  // Unix/Linux/Mac系统
                  System.out.println("终止Unix/Linux Java进程...");
                  
                  // 获取当前进程PID
                  String currentPid = getCurrentProcessId();
                  
                  // 使用kill命令终止进程组
                  ProcessBuilder pb = new ProcessBuilder("kill", "-TERM", currentPid);
                  pb.start();
                  
                  Thread.sleep(500);
                  
                  // 如果温和终止失败，使用强制终止
                  ProcessBuilder pb2 = new ProcessBuilder("kill", "-KILL", currentPid);
                  pb2.start();
              }
              
          } catch (Exception e) {
              System.err.println("终止Java进程时出错: " + e.getMessage());
              // 继续执行其他退出步骤
          }
      }
      
      /**
       * 获取当前进程ID (Java 8兼容版本)
       */
      private String getCurrentProcessId() {
          try {
              // 方法1：使用JMX获取进程名称，然后提取PID
              String jvmName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
              // jvmName格式通常是: "pid@hostname"
              if (jvmName.contains("@")) {
                  return jvmName.split("@")[0];
              }
              
              // 方法2：如果上述方法失败，使用反射获取
              String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
              return processName.substring(0, processName.indexOf('@'));
              
          } catch (Exception e) {
              System.err.println("无法获取进程ID: " + e.getMessage());
              // 返回一个默认值，虽然可能不准确但不会导致程序崩溃
              return "0";
          }
      }
  }
  