ConanServerManager/client/lib/settings.dart

import 'dart:io';

import 'package:libac_flutter/nbt/NbtIo.dart';
import 'package:libac_flutter/nbt/impl/CompoundTag.dart';
import 'package:libac_flutter/packets/packets.dart';
import 'package:libac_flutter/utils/IOTools.dart';
import 'package:servermanager/mod.dart';
import 'package:servermanager/settingsEntry.dart';
import 'package:servermanager/statemachine.dart';

class Settings {
  Settings._();
  static final Settings Instance = Settings._();

  String steamcmd_path = "";
  String game_path = "";
  PacketClient? client;

  StateMachine subsys = StateMachine();

  factory Settings() {
    return Instance;
  }

  SettingsEntry? inst;

  Future<void> Read() async {
    try {
      var tag = await NbtIo.read(
          PathHelper.builder(game_path).resolve("settings.dat").build());

      inst = SettingsEntry.deserialize(tag.get("entry") as CompoundTag);
    } catch (E) {
      inst = SettingsEntry();
    }
  }

  void Write() {
    if (!isValid()) return;
    CompoundTag tag = CompoundTag();
    tag.put("entry", inst!.serialize());

    NbtIo.write(
        PathHelper.builder(game_path).resolve("settings.dat").build(), tag);
  }

  bool isValid() {
    if (inst == null) {
      return false;
    } else {
      return true;
    }
  }

  Future<void> Open() async {
    Close();
    Instance.Read();
  }

  static void Close() async {
    if (Instance.isValid()) {
      Instance.Write();
      Instance.inst = null;
    }
  }

  String getServerPath() {
    return "$game_path${Platform.pathSeparator}server";
  }

  bool checkInitDone() {
    if (File("$steamcmd_path${Platform.pathSeparator}cxinit").existsSync()) {
      return true;
    } else {
      return false;
    }
  }

  String getSteamCmd() {
    return "$steamcmd_path${Platform.pathSeparator}steamcmd${Platform.isWindows ? ".exe" : ".sh"}";
  }

  String getSteamCmd2FA() {
    return "$steamcmd_path${Platform.pathSeparator}steamcmd-2fa${Platform.isWindows ? ".exe" : ""}";
  }

  String getModPath() {
    return "$game_path${Platform.pathSeparator}mods";
  }

  String getModJailPath() {
    return "$game_path${Platform.pathSeparator}mods.jail";
  }

  Future<void> createModFolderIfNotExists() async {
    if (Directory(getModPath()).existsSync()) {
      return;
    } else {
      await Directory(getModPath()).create(recursive: true);
    }
  }

  Future<void> createModJailFolderIfNotExists() async {
    if (Directory(getModJailPath()).existsSync()) {
      return;
    } else {
      await Directory(getModJailPath()).create(recursive: true);
    }
  }

  bool serverInstalled() {
    return File(
            "${getServerPath()}${Platform.pathSeparator}ConanSandboxServer.exe")
        .existsSync();
  }

  Future<ProcessResult> RunUpdate({bool valid = true}) {
    return Process.run(getSteamCmd(), [
      "+@sSteamCmdForcePlatformType",
      "windows",
      "+force_install_dir",
      getServerPath(),
      "+login",
      "anonymous",
      "+app_update",
      "443030",
      "public",
      if (valid) "validate",
      "+quit"
    ]);
  }

  Future<void> createServerModFolderIfNotExists() async {
    Directory dir = Directory(PathHelper(pth: getServerPath())
        .resolve("ConanSandbox")
        .resolve("Mods")
        .build());

    if (await dir.exists()) {
      return;
    } else
      await dir.create(recursive: true);
  }

  File getModListFile() {
    return File(PathHelper(pth: getServerPath())
        .resolve("ConanSandbox")
        .resolve("Mods")
        .resolve("modlist.txt")
        .build());
  }

  Future<void> writeOutModListFile() async {
    await createServerModFolderIfNotExists();
    var file = getModListFile();

    List<String> paths = [];
    for (Mod mod in inst!.mods) {
      var pth = PathHelper(pth: getModPath())
          .resolve("steamapps")
          .resolve("workshop")
          .resolve("content")
          .resolve("440900")
          .resolve("${mod.mod_id}")
          .resolve("${mod.mod_pak}")
          .build();
      if (Platform.isWindows) {
        paths.add(pth);
      } else {
        var rpl = []; // proton's
        rpl.addAll(pth.split('/'));
        rpl[0] = "Z:";
        paths.add(rpl.join("\\"));
      }
    }

    await file.writeAsString(paths.join("\n"),
        flush: true, mode: FileMode.writeOnly);
  }
}