import 'dart:ffi';
import 'dart:io';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:get/get.dart';
import 'package:naiyouwl/app/bean/proxie.dart';
import 'package:naiyouwl/app/common/LogHelper.dart';
import 'package:naiyouwl/app/common/SharedPreferencesUtil.dart';
import 'package:naiyouwl/app/common/constants.dart';
import 'package:naiyouwl/app/controller/controllers.dart';
import 'package:naiyouwl/app/data/model/NodeMode.dart';
import 'package:naiyouwl/app/network/api_service.dart';
import 'package:naiyouwl/app/network/dio_client.dart';
import 'package:naiyouwl/app/utils/shell.dart';
import 'package:naiyouwl/app/utils/system_proxy.dart';
import 'package:naiyouwl/app/utils/utils.dart';
import 'package:proxy_manager/proxy_manager.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:tray_manager/tray_manager.dart';
import 'package:window_manager/window_manager.dart';
import 'package:path/path.dart' as path;
import 'package:wl_base_help/wl_base_help.dart';
import '../const/const.dart';

class GlobalController extends GetxController {
  final proxyManager = ProxyManager();
  bool systemProxy = false;
  late BuildContext context;
  final List<String> modes = ['rule', 'global'];
  final List<String> routeModes = ['sys', 'tun'];
  var msgStatus = "未连接".obs;
  var routeModesSelect = "sys".obs;
  var modesSelect = "rule".obs;
  var nodeModes = <NodeMode>[].obs;
  var isLoading = false.obs;
  var errorMsg = ''.obs;
  var statusCode = 0.obs;
  var selectMageNode = false.obs;
  var systemProxySwitchIng = false.obs;
  var tunProxySwitchIng = false.obs;
  var nodeId = 0.obs;
  bool allowStatusUpdate = false;
  final _wlBaseHelpPlugin = WlBaseHelp();
  var sysInfo = ''.obs;
  var sysVersion = kVersion.obs;

  final selectedNode = Rx<NodeMode?>(null);
  // // 策略组
  // var proxieGroups = <ProxieProxiesItem>[].obs;
  // // 代理集
  // var proxieProviders = <ProxieProviderItem>[].obs;
  // // 代理
  // var proxieProxies = <ProxieProxiesItem>[].obs;
  // // 所有节点
  // var allProxies = <String, ProxieProxiesItem>{}.obs;

  final List<String> groupInternalTypes = ['DIRECT', 'REJECT', 'GLOBAL'];
  final List<String> groupTypes = [
    ProxieProxieType.selector,
    ProxieProxieType.urltest,
    ProxieProxieType.fallback,
    ProxieProxieType.loadbalance,
  ];
  Future<void> init(BuildContext context) async {
    this.context = context;
    watchExit();
    // if(Platform.isWindows){
    //   createConsole();
    //   hideConsole();
    // }
    await SharedPreferencesUtil().delete("last_successful_url");
    // init plugins
    await controllers.tray.initTray();
    controllers.window.initWindow();
  }

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> platformState() async {
    String platformVersion;
    if(Platform.isWindows){
      try {
        platformVersion =
            await _wlBaseHelpPlugin.getPlatformVersion() ?? 'Unknown platform version';
        platformVersion = platformVersion + ClashName.architecture.name;
      } on PlatformException {
        platformVersion = 'Failed to get platform version.';
      }
      sysInfo.value = platformVersion;
    }
    else {
      sysInfo.value = ClashName.os.name + "-" + ClashName.architecture.name;
    }

  }

  Future<void> onRunAdmin() async {
    if(Platform.isWindows){

      try {
          await _wlBaseHelpPlugin.runAsAdministrator();
      } on PlatformException {

      }
    }

  }

  Future<bool> onIsRunAdmin() async {
    bool isAdmin;
    try {
      isAdmin = await _wlBaseHelpPlugin.isRunningAsAdmin() ?? false;
    } on PlatformException {
      isAdmin = false;
    }

    return isAdmin;
  }

  Future<bool> onIsProcessRunning(String passName) async {
    bool isRun = false;
    if(Platform.isWindows){

      try {
        isRun = await _wlBaseHelpPlugin.isProcessRunning(passName) ?? false;

        if (isRun){
          await onKillProcess(passName);
        }

      } on PlatformException {
        isRun = false;
      }
    }
    return isRun;
  }

  Future<void> onKillProcess(String passName) async {

    try {
      await _wlBaseHelpPlugin.killProcess(passName);
    } on PlatformException {

    }

  }
  void updateMsg(String msg) {
    msgStatus.value = msg;
  }

  Future<void> updateMode(String route) async {
    if(allowStatusUpdate){

      return;
    }
    modesSelect.value = route;
    final coreStatus = controllers.service.coreStatus.value;
    if( coreStatus == RunningState.running){
      controllers.core.fetchConfigUpdate({'mode': modesSelect.value});
    }
  }
  Future<void> updateRoute(String route) async {
    if(allowStatusUpdate){

      return;
    }
    // if(route == "tun"){
    //   final res = await showNormalDialog( context,content: '启用网卡模式需要管理员',title: '提示', cancelText: '取消', enterText: '确认安装');
    //   if (res != true) return;
    //   controllers.service.serviceModeSwitch(true);
    // }
    routeModesSelect.value = route;
    LogHelper().d("当前ROUTE模式${routeModesSelect.value}");
  }
  Future<void> fetchNodes() async {
    nodeModes.value = await ApiService().getNode("/api/client/v4/nodes?vless=1");
    //await makeProxy();
    // if(controllers.service.coreStatus.value == RunningState.stoped){
    //   await controllers.service.reloadClashCore();
    // }
    // if (controllers.service.coreStatus.value != RunningState.running) return;
    // await controllers.core.updateVersion();
    // await updateDate();
    //


  }




  Future<void> updateNode() async {
    NodeMode? targetNode;
    if (selectedNode.value == null) {
      targetNode = await findNodeWithMinUsers(nodeModes);
    } else {
      targetNode = selectedNode.value;
    }
    if (targetNode != null){
      selectNode(targetNode);
      await swift(targetNode.name ?? "");

    }
  }

  Future<void> showConsole() async {
    await _wlBaseHelpPlugin.showConsole();
  }
  Future<void> hideConsole() async {
    await _wlBaseHelpPlugin.hideConsole();
  }
  Future<void> startSysMode() async {

    await makeProxy();

    //await updateDate();
  }
  Future<void> startTunMode() async {
    await makeProxy();
  }

  Future<void> swift(String name) async {

    try{
      var g = "proxy";
      if(modesSelect.value == "global")
      {
        g = "GLOBAL";
      }

      await controllers.core.fetchSetProxieGroup(g, name);
      final conn = await controllers.core.fetchConnection();
      if(conn == null) { return; }
      for (final it in conn.connections) {
        if (it.chains.contains(name)) controllers.core.fetchCloseConnections(it.id);
      }
    }catch (e) {
      //LogHelper().d(e.toString());
    }


  }



  Future<void> makeProxy() async {
     await controllers.config.makeClashConfig(nodeModes);
     // await controllers.service.reloadClashCore();

  }
  Future<NodeMode> findNodeWithMinUsers(List<NodeMode> nodes) async {
    return nodes
        .where((node) => node.countryCode == "hk")
        .reduce((a, b) => a.onlineUsers! < b.onlineUsers! ? a : b);
  }




  Future<SystemProxyConfig> getSysProxy() async{
     return  await SystemProxy.instance.get();
  }


  Future<void> TunProxySwitch(bool open) async {
    tunProxySwitchIng.value = true;
    routeModesSelect.value = open ? "tun": "sys";
    LogHelper().d("TunProxySwitch ----- 当前ROUTE模式${routeModesSelect.value}");
    tunProxySwitchIng.value = false;
  }



  Future<void> systemProxySwitch(bool open) async {
    systemProxySwitchIng.value = true;
    //await SystemProxy.instance.set(open ? controllers.core.proxyConfig : SystemProxyConfig());
    await controllers.config.setSystemProxy(open);
    if(open)
    {
      if(Platform.isWindows){
        await openProxy();
      } else {
       await controllers.service.fetchSetProxy();
      }

    } else {
      if(Platform.isWindows){
        await  closeProxy();
      } else {
        await controllers.service.fetchSetProxyStop();
      }

    }
    systemProxySwitchIng.value = false;
  }

  // Future<dynamic> _updateProxie() async {
  //   final proxie = await controllers.core.fetchProxie();
  //   final global = proxie.proxies["GLOBAL"]!;
  //   proxieGroups.value = global.all!
  //       .where((it) => !groupInternalTypes.contains(it) && groupTypes.contains(proxie.proxies[it]!.type))
  //       .map((it) => proxie.proxies[it]!)
  //       .toList();
  //   proxieProxies.value = global.all!
  //       .where((it) => !groupInternalTypes.contains(it) && !groupTypes.contains(proxie.proxies[it]!.type))
  //       .map((it) => proxie.proxies[it]!)
  //       .toList();
  //   if (controllers.core.config.value.mode == 'global') proxieGroups.insert(0, global);
  // }
  //
  // Future<dynamic> _updateProxieProvider() async {
  //   proxieProviders.value = (await controllers.core.fetchProxieProvider()).providers.values.where((it) => it.vehicleType != 'Compatible').toList();
  //   for (final it in proxieProviders) {
  //     it.proxies.sort((a, b) {
  //       if (a.delay == 0) return 1;
  //       if (b.delay == 0) return -1;
  //       return a.delay - b.delay;
  //     });
  //   }
  // }

  // Future<void> updateDate() async {
  //   //LogHelper().d('controller.proxie.updateDate()');
  //   try
  //   {
  //     await controllers.core.updateConfig();
  //     await _updateProxie();
  //     await _updateProxieProvider();
  //     allProxies.clear();
  //     for (final provide in proxieProviders) {
  //       for (final it in provide.proxies) {
  //         allProxies[it.name] = it;
  //       }
  //     }
  //     for (final it in proxieProxies) {
  //       allProxies[it.name] = it;
  //       //LogHelper().d('controller.proxieProxies');
  //     }
  //     for (final it in proxieGroups) {
  //       allProxies[it.name] = it;
  //       //LogHelper().d('controller.proxieGroups');
  //     }
  //     proxieGroups.refresh();
  //     proxieProxies.refresh();
  //     proxieProviders.refresh();
  //     allProxies.refresh();
  //   } catch (e){
  //     LogHelper().d("updateDate -- ${e.toString()}");
  //   }
  //
  // }


  // Future<void> handleSetProxieGroup(ProxieProxiesItem proxie, String value) async {
  //   if (proxie.now == value) return;
  //   await controllers.core.fetchSetProxieGroup(proxie.name, value);
  //   await updateDate();
  //   if (controllers.config.config.value.breakConnections) {
  //     final conn = await controllers.core.fetchConnection();
  //     for (final it in conn.connections) {
  //       if (it.chains.contains(proxie.name)) controllers.core.fetchCloseConnections(it.id);
  //     }
  //   }
  // }
  //
  // Future<void> handleSetSelectProxieGroup(NodeMode proxie, String value) async {
  //   if (proxie.name == value) return;
  //   await controllers.core.fetchSetProxieGroup(proxie.name ?? "", value);
  //   await updateDate();
  //   final conn = await controllers.core.fetchConnection();
  //   for (final it in conn.connections) {
  //     if (it.chains.contains(proxie.name)) controllers.core.fetchCloseConnections(it.id);
  //   }
  // }

  void watchExit() {
    // watch process kill
    // ref https://github.com/dart-lang/sdk/issues/12170
    if (Platform.isMacOS) {
      // windows not support https://github.com/dart-lang/sdk/issues/28603
      // for macos 任务管理器退出进程
      ProcessSignal.sigterm.watch().listen((_) {
        stdout.writeln('exit: sigterm');
        handleExit();
      });
    }
    // for macos, windows ctrl+c
    ProcessSignal.sigint.watch().listen((_) {
      stdout.writeln('exit: sigint');
      handleExit();
    });
  }
  void selectNode(NodeMode node) {
    nodeId.value = node.id ?? 0;
    controllers.global.selectedNode.value = node;
    _storeSelectedNode(node);
  }

  Future<void> _storeSelectedNode(NodeMode node) async {
    final prefs = await SharedPreferences.getInstance();
    // 为简化起见，我们只存储node的ID，但您可以根据需要存储更多信息

    prefs.setInt('selectedNodeId', node.id ?? -1);
    await loadSelectedNode();
  }


  Future<void> loadSelectedNode() async {
    final prefs = await SharedPreferences.getInstance();
    final selectedNodeId = prefs.getInt('selectedNodeId');
    if (selectedNodeId != null) {
      //selectedIndex.value = nodeModes.indexWhere((item) => item.id == selectedNodeId);
      selectedNode.value = nodeModes.firstWhere((node) => node.id == selectedNodeId);
    }
  }


  void initRegularlyUpdate() {
    Future.delayed(const Duration(minutes: 5)).then((_) async {
      for (final it in controllers.config.config.value.subs) {
        try {
          if (it.url == null || it.url!.isEmpty) continue;
          if (((DateTime.now().millisecondsSinceEpoch ~/ 1000) - (it.updateTime ?? 0)) < controllers.config.config.value.updateInterval) continue;
          final chenged = await controllers.config.updateSub(it);
          if (!chenged) continue;
          if (it.name != controllers.config.config.value.selected) continue;
          // restart clash core
          await controllers.service.reloadClashCore();
          await Future.delayed(const Duration(seconds: 20));
        } catch (_) {}
      }
      initRegularlyUpdate();
    });
  }
  /// 打开代理

  Future<void> openProxy() async {



    int? port = controllers.config.mixedPort.value;
    if (port == 0) {
      port = null;
    }
    int? socksPort = controllers.config.mixedPort.value;
    if (socksPort == 0) {
      socksPort = null;
    }
    int? mixedPort = controllers.config.mixedPort.value;
    if (mixedPort == 0) {
      mixedPort = null;
    }
    port = port ?? mixedPort ?? 0;
    if (port != 0) {
      if(Platform.isWindows){
        String loa = '127.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;192.168.*';
        int? exitCode;
        // Process sysproxy = await Process.start(Files.assetsSysProxyWin.path,,mode: ProcessStartMode.inheritStdio);
        // sysproxy.exitCode.then((code) => exitCode = code);
        try {
          var result = await Process.run(
            Files.assetsSysProxyWin.path,
            ['global','127.0.0.1:$port',loa],
            runInShell: true,
          );
          LogHelper().d(result.stderr);
          LogHelper().d(result.stdout);
        } on ProcessException catch (e) {
          //.e('Failed to start $coreName: ${e.message}');
          throw Exception('Failed to start sysproxy: ${e.message}');
        }
      } else {
        await proxyManager.setAsSystemProxy(
          ProxyTypes.http,
          "127.0.0.1",
          port,
        );
        await proxyManager.setAsSystemProxy(
          ProxyTypes.https,
          "127.0.0.1",
          port,
        );
        systemProxy = true;
      }
    }



    //
    // port = port ?? mixedPort ?? 0;
    // if (port != 0) {

    // }
    socksPort = socksPort ?? mixedPort ?? 0;
    if (socksPort != 0) {

      if (!Platform.isWindows) {
        await proxyManager.setAsSystemProxy(
          ProxyTypes.socks,
          "127.0.0.1",
          socksPort,
        );
      }
      systemProxy = true;
    }
  }

  /// 关闭代理

  Future<void> closeProxy() async {
    //
    if (Platform.isWindows) {
      try {
        var result =  await Process.run(
          Files.assetsSysProxyWin.path,
          ['set','1','','',''],
          runInShell: true,
        );
        LogHelper().d(result.stderr);
        LogHelper().d(result.stdout);
      } on ProcessException catch (e) {
        //.e('Failed to start $coreName: ${e.message}');
        throw Exception('Failed to start sysproxy: ${e.message}');
      }
      proxyManager.cleanSystemProxy();
    }

    systemProxy = false;
  }
  Future<void> stopAllCore() async {
    await systemProxySwitch(false);
    if(Platform.isWindows){
      await controllers.service.stopClashCore();
    } else if(Platform.isMacOS) {
      await controllers.service.fetchStop();
    }
    if(!controllers.service.serviceMode.value){{
      if(Platform.isWindows){
        await onKillProcess(path.basename(Files.assetsCCore.path));
      }
      await killProcess(path.basename(Files.assetsCCore.path));
    }}

    if(!controllers.service.serviceMode.value){
      await killProcess(path.basename(Files.assetsClashService.path));
    }

  }
  Future<void> handleExit() async {
    await stopAllCore();
    await trayManager.destroy();
    await windowManager.destroy();
    // exit(0);
  }
  void handleApiError(dynamic error) {
    if (error is AppException) {
      LogHelper().d('API error with status code: ${error.statusCode}');
      statusCode.value = error.statusCode ?? -1;
      errorMsg.value = error.toString();
    } else {
      LogHelper().d('Other error: $error');
      errorMsg.value = error.toString();
    }

  }

  @override
  void dispose() {
    controllers.tray.dispose();
    controllers.window.dispose();
    //controllers.protocol.dispose();
    super.dispose();
  }
}