ShadowsocksX-NG/ShadowsocksX-NG2/App/ProxyControlWorkflow/ProxyControlAdapters.swift

import Combine
import Foundation

/// 生产运行时 adapter（issue #47）：现有 `ProxyRuntimeController` 的唯一
/// 包装，由应用组合根接线。只把控制器既有能力与观察投影到 workflow 缝上，
/// 不复制状态机、generation、健康门禁与系统代理生命周期语义。
@MainActor
final class ControllerProxyRuntimeAdapter: ProxyRuntimeAdapting {
  private let controller: ProxyRuntimeController

  init(controller: ProxyRuntimeController) {
    self.controller = controller
  }

  var runtimeFacts: ProxyRuntimeFacts { controller.runtimeFacts }

  var agentIntentEnabled: Bool { controller.agentIntentEnabled }

  var activationFailure: ActivationFailure? { controller.lastActivationFailure }

  var systemProxyIntentEnabled: Bool { controller.systemProxyIntentEnabled }

  var systemProxyApplication: SystemProxyApplicationFacts {
    switch controller.systemProxyState {
    case .idle: return .idle
    case .pending: return .pending
    case .applied: return .applied
    case .failed(let facts): return .failed(facts)
    }
  }

  var systemProxyApprovalRequired: Bool { controller.systemProxyApprovalRequired }

  var proxyMode: ProxyMode { controller.proxyMode }

  var ruleDefaultAction: RuleDefaultAction { controller.ruleDefaultAction }

  var skippedInvalidServerCount: Int { controller.skippedServers.count }

  var activeTargetID: NodeID? { controller.activeTargetID }

  var httpExportCapability: HTTPExportCapability {
    HTTPExportCapability(listen: controller.listenSettings)
  }

  var terminalProxyEnvironmentCommands: TerminalProxyEnvironmentCommands {
    TerminalProxyEnvironmentCommands(listen: controller.listenSettings)
  }

  /// 控制器的 `objectWillChange` 是 willChange 语义；主队列 hop 落地时被
  /// 发布的新值已可读，workflow 重观察不会读到半程状态。
  var changes: AnyPublisher<Void, Never> {
    controller.objectWillChange
      .map { _ in () }
      .receive(on: DispatchQueue.main)
      .eraseToAnyPublisher()
  }

  func resyncOnLaunch() async {
    await controller.resyncOnLaunch()
  }

  func setAgentEnabled(_ enabled: Bool) async {
    await controller.setAgentEnabled(enabled)
  }

  func setSystemProxyEnabled(_ enabled: Bool) async {
    await controller.setSystemProxyEnabled(enabled)
  }

  func openSystemProxyHelperApproval() async {
    await controller.openSystemProxyHelperApproval()
  }

  func setProxyMode(_ mode: ProxyMode) async {
    await controller.setProxyMode(mode)
  }

  func setRuleDefaultAction(_ action: RuleDefaultAction) async {
    await controller.setRuleDefaultAction(action)
  }
}

/// HTTP 导出能力的唯一派生点：监听设置 → 本机终端使用的可复制导出行。
/// 环境变量始终指向回环地址，避免将命令误用于其他设备。
extension HTTPExportCapability {
  init(listen: SslocalListenSettings) {
    let urlHost = listen.proxyLoopbackURLHost
    let endpoint = "http://\(urlHost):\(listen.httpPort)"
    self.init(copyableLine: "export http_proxy=\(endpoint);export https_proxy=\(endpoint);")
  }
}

extension TerminalProxyEnvironmentCommands {
  init(listen: SslocalListenSettings) {
    let host = listen.proxyLoopbackURLHost
    let httpEndpoint = "'http://\(host):\(listen.httpPort)'"
    let socksEndpoint = "'socks5://\(host):\(listen.socksPort)'"
    let noProxy = "'localhost,127.0.0.1,::1,.local'"
    let zshBash =
      [
        "export http_proxy=\(httpEndpoint)",
        "export https_proxy=\(httpEndpoint)",
        "export all_proxy=\(socksEndpoint)",
        "export no_proxy=\(noProxy)",
      ].joined(separator: "; ") + ";"
    let fish =
      [
        "set -gx http_proxy \(httpEndpoint)",
        "set -gx https_proxy \(httpEndpoint)",
        "set -gx all_proxy \(socksEndpoint)",
        "set -gx no_proxy \(noProxy)",
      ].joined(separator: "; ") + ";"
    self.init(
      zshBash: zshBash,
      fish: fish)
  }
}

extension SslocalListenSettings {
  fileprivate var proxyLoopbackURLHost: String {
    let host = listenerMode.proxyLoopbackAddress
    return host.contains(":") ? "[\(host)]" : host
  }
}

/// 目录侧唯一的目标事实出口（窄缝，story 28）：存在性 + 显示名路径摘要；
/// 完整目录树、订阅对象与凭据不出此接口。
extension CatalogWorkflow: ProxyTargetFactsReading {
  func activeTargetFacts(for targetID: NodeID?) -> ProxyActiveTargetFacts? {
    guard let targetID else { return nil }
    return ProxyActiveTargetFacts(id: targetID, pathSummary: tree.pathSummary(for: targetID))
  }
}