import 'dart:convert';
import 'dart:io';

import 'aris_bundle.dart';
import 'go_core.dart';
import 'codex_config_bridge.dart';
import 'opencode_config_bridge.dart';
import 'runtime_models.dart';

class MultiAgentMountManager {
  MultiAgentMountManager({
    CodexConfigBridge? codexConfigBridge,
    OpencodeConfigBridge? opencodeConfigBridge,
    ArisBundleRepository? arisBundleRepository,
    GoCoreLocator? goCoreLocator,
  }) : this._(
         arisAdapter: ArisMountAdapter(
           arisBundleRepository ?? ArisBundleRepository(),
           goCoreLocator ?? GoCoreLocator(),
         ),
         codexConfigBridge: codexConfigBridge ?? CodexConfigBridge(),
         opencodeConfigBridge: opencodeConfigBridge ?? OpencodeConfigBridge(),
       );

  MultiAgentMountManager._({
    required ArisMountAdapter arisAdapter,
    required CodexConfigBridge codexConfigBridge,
    required OpencodeConfigBridge opencodeConfigBridge,
  }) : _arisAdapter = arisAdapter,
       _adapters = <CliMountAdapter>[
         arisAdapter,
         CodexMountAdapter(codexConfigBridge),
         ClaudeMountAdapter(),
         GeminiMountAdapter(),
         OpencodeMountAdapter(opencodeConfigBridge),
         OpenClawMountAdapter(),
       ];

  final ArisMountAdapter _arisAdapter;
  final List<CliMountAdapter> _adapters;

  Future<MultiAgentConfig> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final states = <ManagedMountTargetState>[];
    for (final adapter in _adapters) {
      try {
        states.add(
          await adapter.reconcile(
            config: config,
            aiGatewayUrl: aiGatewayUrl,
            configuredCodexCliPath: configuredCodexCliPath,
          ),
        );
      } catch (error) {
        states.add(
          ManagedMountTargetState.placeholder(
            targetId: adapter.targetId,
            label: adapter.label,
            supportsSkills: adapter.supportsSkills,
            supportsMcp: adapter.supportsMcp,
            supportsAiGatewayInjection: adapter.supportsAiGatewayInjection,
          ).copyWith(
            available: await adapter.isInstalled(
              configuredCodexCliPath: configuredCodexCliPath,
            ),
            discoveryState: 'error',
            syncState: 'error',
            detail: error.toString(),
          ),
        );
      }
    }
    final arisState = states.firstWhere(
      (item) => item.targetId == _arisAdapter.targetId,
      orElse: () => ManagedMountTargetState.placeholder(
        targetId: _arisAdapter.targetId,
        label: _arisAdapter.label,
        supportsSkills: _arisAdapter.supportsSkills,
        supportsMcp: _arisAdapter.supportsMcp,
        supportsAiGatewayInjection: _arisAdapter.supportsAiGatewayInjection,
      ),
    );
    return config.copyWith(
      mountTargets: states,
      arisBundleVersion: _arisAdapter.lastBundleVersion,
      arisCompatStatus: arisState.syncState,
    );
  }
}

abstract class CliMountAdapter {
  String get targetId;
  String get label;
  bool get supportsSkills;
  bool get supportsMcp;
  bool get supportsAiGatewayInjection;

  Future<bool> isInstalled({String configuredCodexCliPath = ''});

  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  });

  Future<String> _runCommand(List<String> command) async {
    final result = await Process.run(
      command.first,
      command.sublist(1),
      runInShell: true,
    );
    final stdout = '${result.stdout}'.trim();
    final stderr = '${result.stderr}'.trim();
    return stdout.isNotEmpty ? stdout : stderr;
  }

  Future<int> _countListedEntries(List<String> command) async {
    final output = await _runCommand(command);
    if (output.isEmpty ||
        output.contains('No MCP servers configured') ||
        output.contains('No MCP servers configured yet') ||
        output.contains('No MCP servers configured.')) {
      return 0;
    }
    return output
        .split('\n')
        .map((item) => item.trim())
        .where((item) => item.isNotEmpty)
        .where((item) => !item.startsWith('Usage:'))
        .where((item) => !item.startsWith('┌'))
        .where((item) => !item.startsWith('│'))
        .where((item) => !item.startsWith('└'))
        .length;
  }

  Future<bool> _binaryExists(String command) async {
    final check = await Process.run(
      Platform.isWindows ? 'where' : 'which',
      <String>[command],
      runInShell: true,
    );
    return check.exitCode == 0 && '${check.stdout}'.trim().isNotEmpty;
  }

  int countMcpTomlSections(String content) {
    return RegExp(
      r'^\[mcp_servers\.[^\]]+\]',
      multiLine: true,
    ).allMatches(content).length;
  }
}

class ArisMountAdapter extends CliMountAdapter {
  ArisMountAdapter(this._bundleRepository, this._goCoreLocator);

  final ArisBundleRepository _bundleRepository;
  final GoCoreLocator _goCoreLocator;
  String _lastBundleVersion = '';

  String get lastBundleVersion => _lastBundleVersion;

  @override
  String get targetId => 'aris';

  @override
  String get label => 'ARIS';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => true;

  @override
  bool get supportsAiGatewayInjection => false;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) async {
    try {
      await _bundleRepository.loadManifest();
      return true;
    } catch (_) {
      return false;
    }
  }

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    try {
      final bundle = await _bundleRepository.ensureReady();
      _lastBundleVersion = bundle.manifest.bundleVersion;
      final skillCount = await _bundleRepository.countSkillFiles();
      final bridgeAvailable = await _goCoreLocator.isAvailable();
      final llmChatEntry = bundle.manifest.llmChatServerPath.trim();
      final llmChatReady = llmChatEntry.isNotEmpty;
      return ManagedMountTargetState.placeholder(
        targetId: targetId,
        label: label,
        supportsSkills: supportsSkills,
        supportsMcp: supportsMcp,
        supportsAiGatewayInjection: supportsAiGatewayInjection,
      ).copyWith(
        available: true,
        discoveryState: 'ready',
        syncState: config.usesAris && llmChatReady && bridgeAvailable
            ? 'ready'
            : 'embedded',
        discoveredSkillCount: skillCount,
        discoveredMcpCount: llmChatReady ? 1 : 0,
        managedMcpCount: config.usesAris && llmChatReady && bridgeAvailable
            ? 1
            : 0,
        detail: llmChatReady
            ? bridgeAvailable
                  ? 'Embedded bundle ${bundle.manifest.bundleVersion} ready; XWorkmate Go core manages llm-chat and claude-review.'
                  : 'Embedded bundle is ready, but the XWorkmate Go core is not available yet.'
            : 'Embedded bundle extracted, but llm-chat metadata is missing.',
      );
    } catch (error) {
      return ManagedMountTargetState.placeholder(
        targetId: targetId,
        label: label,
        supportsSkills: supportsSkills,
        supportsMcp: supportsMcp,
        supportsAiGatewayInjection: supportsAiGatewayInjection,
      ).copyWith(
        available: false,
        discoveryState: 'error',
        syncState: 'error',
        detail: error.toString(),
      );
    }
  }
}

class CodexMountAdapter extends CliMountAdapter {
  CodexMountAdapter(this._bridge);

  final CodexConfigBridge _bridge;

  @override
  String get targetId => 'codex';

  @override
  String get label => 'Codex';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => true;

  @override
  bool get supportsAiGatewayInjection => true;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) async {
    final configuredPath = configuredCodexCliPath.trim();
    if (configuredPath.isNotEmpty && await File(configuredPath).exists()) {
      return true;
    }
    return _binaryExists('codex');
  }

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final available = await isInstalled(
      configuredCodexCliPath: configuredCodexCliPath,
    );
    final configFile = File('${_bridge.codexHome}/config.toml');
    final content = await configFile.exists()
        ? await configFile.readAsString()
        : '';
    final discoveredMcpCount = countMcpTomlSections(content);
    final managedMcpServers = config.managedMcpServers
        .where((item) => item.enabled && item.command.trim().isNotEmpty)
        .toList(growable: false);
    if (available && config.autoSync && managedMcpServers.isNotEmpty) {
      await _bridge.configureManagedMcpServers(
        servers: managedMcpServers
            .map(
              (item) => CodexMcpServer(
                name: item.id,
                command: item.command,
                args: item.args,
              ),
            )
            .toList(growable: false),
      );
    }
    return ManagedMountTargetState.placeholder(
      targetId: targetId,
      label: label,
      supportsSkills: supportsSkills,
      supportsMcp: supportsMcp,
      supportsAiGatewayInjection: supportsAiGatewayInjection,
    ).copyWith(
      available: available,
      discoveryState: available ? 'ready' : 'missing',
      syncState: !available
          ? 'missing'
          : config.autoSync
          ? 'ready'
          : 'disabled',
      discoveredMcpCount: discoveredMcpCount,
      managedMcpCount: managedMcpServers.length,
      detail: aiGatewayUrl.isNotEmpty
          ? 'LLM API uses launch-scoped defaults for collaboration runs.'
          : 'LLM API not configured.',
    );
  }
}

class ClaudeMountAdapter extends CliMountAdapter {
  @override
  String get targetId => 'claude';

  @override
  String get label => 'Claude';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => true;

  @override
  bool get supportsAiGatewayInjection => true;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) =>
      _binaryExists('claude');

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final available = await isInstalled();
    final discoveredMcpCount = available
        ? await _countListedEntries(<String>['claude', 'mcp', 'list'])
        : 0;
    return ManagedMountTargetState.placeholder(
      targetId: targetId,
      label: label,
      supportsSkills: supportsSkills,
      supportsMcp: supportsMcp,
      supportsAiGatewayInjection: supportsAiGatewayInjection,
    ).copyWith(
      available: available,
      discoveryState: available ? 'ready' : 'missing',
      syncState: available && config.autoSync ? 'launch-only' : 'disabled',
      discoveredMcpCount: discoveredMcpCount,
      managedMcpCount: config.managedMcpServers
          .where((item) => item.enabled)
          .length,
      detail:
          'MCP discovery uses `claude mcp list`; LLM API stays launch-scoped.',
    );
  }
}

class GeminiMountAdapter extends CliMountAdapter {
  @override
  String get targetId => 'gemini';

  @override
  String get label => 'Gemini';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => true;

  @override
  bool get supportsAiGatewayInjection => true;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) =>
      _binaryExists('gemini');

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final available = await isInstalled();
    final discoveredMcpCount = available
        ? await _countListedEntries(<String>['gemini', 'mcp', 'list'])
        : 0;
    return ManagedMountTargetState.placeholder(
      targetId: targetId,
      label: label,
      supportsSkills: supportsSkills,
      supportsMcp: supportsMcp,
      supportsAiGatewayInjection: supportsAiGatewayInjection,
    ).copyWith(
      available: available,
      discoveryState: available ? 'ready' : 'missing',
      syncState: available && config.autoSync ? 'launch-only' : 'disabled',
      discoveredMcpCount: discoveredMcpCount,
      managedMcpCount: config.managedMcpServers
          .where((item) => item.enabled)
          .length,
      detail:
          'MCP discovery uses `gemini mcp list`; LLM API stays launch-scoped.',
    );
  }
}

class OpencodeMountAdapter extends CliMountAdapter {
  OpencodeMountAdapter(this._bridge);

  final OpencodeConfigBridge _bridge;

  @override
  String get targetId => 'opencode';

  @override
  String get label => 'OpenCode';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => true;

  @override
  bool get supportsAiGatewayInjection => true;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) =>
      _binaryExists('opencode');

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final available = await isInstalled();
    final content = await _bridge.readConfig();
    final discoveredMcpCount = countMcpTomlSections(content);
    final managedMcpServers = config.managedMcpServers
        .where((item) => item.enabled)
        .toList(growable: false);
    if (available && config.autoSync && managedMcpServers.isNotEmpty) {
      await _bridge.configureManagedMcpServers(
        servers: managedMcpServers
            .map(
              (item) => OpencodeMcpServer(
                name: item.id,
                command: item.command,
                url: item.url,
                args: item.args,
              ),
            )
            .toList(growable: false),
      );
    }
    return ManagedMountTargetState.placeholder(
      targetId: targetId,
      label: label,
      supportsSkills: supportsSkills,
      supportsMcp: supportsMcp,
      supportsAiGatewayInjection: supportsAiGatewayInjection,
    ).copyWith(
      available: available,
      discoveryState: available ? 'ready' : 'missing',
      syncState: !available
          ? 'missing'
          : config.autoSync
          ? 'ready'
          : 'disabled',
      discoveredMcpCount: discoveredMcpCount,
      managedMcpCount: managedMcpServers.length,
      detail: 'Managed MCP config is preserved in ~/.opencode/config.toml.',
    );
  }
}

class OpenClawMountAdapter extends CliMountAdapter {
  @override
  String get targetId => 'openclaw';

  @override
  String get label => 'OpenClaw';

  @override
  bool get supportsSkills => true;

  @override
  bool get supportsMcp => false;

  @override
  bool get supportsAiGatewayInjection => true;

  @override
  Future<bool> isInstalled({String configuredCodexCliPath = ''}) =>
      _binaryExists('openclaw');

  @override
  Future<ManagedMountTargetState> reconcile({
    required MultiAgentConfig config,
    required String aiGatewayUrl,
    String configuredCodexCliPath = '',
  }) async {
    final available = await isInstalled();
    final configFile = File(
      '${Platform.environment['HOME'] ?? ''}/.openclaw/openclaw.json',
    );
    var discoveredSkillCount = 0;
    var detail = 'OpenClaw acts as the host/control plane mount.';
    if (await configFile.exists()) {
      try {
        final decoded = jsonDecode(await configFile.readAsString());
        final agents =
            (decoded is Map<String, dynamic> &&
                decoded['agents'] is Map<String, dynamic> &&
                (decoded['agents'] as Map<String, dynamic>)['list'] is List)
            ? ((decoded['agents'] as Map<String, dynamic>)['list'] as List)
                  .length
            : 0;
        final skillsDir = Directory(
          '${Platform.environment['HOME'] ?? ''}/.openclaw/skills',
        );
        if (await skillsDir.exists()) {
          discoveredSkillCount = await skillsDir
              .list()
              .where((entity) => entity is File || entity is Directory)
              .length;
        }
        detail = 'agents: $agents · skills: $discoveredSkillCount';
      } catch (_) {
        detail = 'OpenClaw config detected but could not be fully parsed.';
      }
    }
    return ManagedMountTargetState.placeholder(
      targetId: targetId,
      label: label,
      supportsSkills: supportsSkills,
      supportsMcp: supportsMcp,
      supportsAiGatewayInjection: supportsAiGatewayInjection,
    ).copyWith(
      available: available,
      discoveryState: available ? 'ready' : 'missing',
      syncState: available && config.autoSync ? 'launch-only' : 'disabled',
      discoveredSkillCount: discoveredSkillCount,
      detail: detail,
    );
  }
}