app/lib/services/server_service.dart

import '../config/api_config.dart';
import '../data/models/server_model.dart';
import '../data/models/user_model.dart';
import 'storage_service.dart';
import '../core/utils/app_logger.dart';

/// 服务器服务 - 固定使用内置服务器
class ServerService {
  static ServerService? _instance;
  ServerService._();

  static ServerService get instance {
    _instance ??= ServerService._();
    return _instance!;
  }

  static const String _defaultLabel = '共云网盘';
  static const String _defaultBaseUrl = ApiConfig.defaultBaseUrl;

  List<ServerModel> _servers = [];
  ServerModel? _currentServer;

  /// 获取服务器列表
  List<ServerModel> get servers => List.unmodifiable(_servers);

  /// 获取当前服务器
  ServerModel? get currentServer => _currentServer;

  /// 初始化服务器
  Future<void> init() async {
    await _loadServers();
  }

  /// 从存储加载服务器列表
  Future<void> _loadServers() async {
    try {
      // 从 StorageService 加载服务器列表
      final loadedServers = await StorageService.instance.servers;
      _setFixedDefaultServer(loadedServers);
      await _saveServers();
      await _saveLastSelected();

      AppLogger.d('加载了 ${_servers.length} 个服务器配置');
      AppLogger.d('当前服务器: ${_currentServer?.label}');
    } catch (e) {
      AppLogger.d('加载服务器列表失败: $e');
      // 加载失败时使用默认服务器
      _servers = [ServerModel(label: _defaultLabel, baseUrl: _defaultBaseUrl)];
      _currentServer = _servers.first;
    }
  }

  /// 固定使用内置服务器，并保留同地址服务器上的登录信息
  void _setFixedDefaultServer(List<ServerModel> loadedServers) {
    ServerModel? savedDefaultServer;
    for (final server in loadedServers) {
      if (server.baseUrl == _defaultBaseUrl) {
        savedDefaultServer = server;
        break;
      }
    }

    _currentServer =
        (savedDefaultServer ??
                ServerModel(label: _defaultLabel, baseUrl: _defaultBaseUrl))
            .copyWith(label: _defaultLabel, baseUrl: _defaultBaseUrl);

    _servers = [_currentServer!];
  }

  /// 保存服务器列表到存储
  Future<void> _saveServers() async {
    try {
      await StorageService.instance.setServers(_servers);
      AppLogger.d('已保存 ${_servers.length} 个服务器配置');
    } catch (e) {
      AppLogger.d('保存服务器列表失败: $e');
    }
  }

  /// 保存上次选中的服务器
  Future<void> _saveLastSelected() async {
    if (_currentServer != null) {
      await StorageService.instance.setLastSelectedServerLabel(
        _currentServer!.label,
      );
    }
  }

  /// 固定服务器模式下不支持添加服务器
  Future<void> addServer(ServerModel server) async {
    throw UnsupportedError('当前版本不支持自定义服务器');
  }

  /// 固定服务器模式下不支持更新服务器
  Future<void> updateServer(String oldLabel, ServerModel newServer) async {
    throw UnsupportedError('当前版本不支持自定义服务器');
  }

  /// 固定服务器模式下不支持删除服务器
  Future<void> deleteServer(String label) async {
    throw UnsupportedError('当前版本不支持自定义服务器');
  }

  /// 固定服务器模式下始终使用内置服务器
  Future<void> selectServer(String label) async {
    if (_currentServer == null || _currentServer!.baseUrl != _defaultBaseUrl) {
      _setFixedDefaultServer(_servers);
    }
    await _saveLastSelected();
    AppLogger.d('当前服务器: ${_currentServer?.label}');
  }

  /// 更新当前服务器的服务登录信息
  Future<void> updateCurrentServerLogin({
    String? email,
    String? password,
    UserModel? user,
    bool? rememberMe,
    bool clearEmail = false,
    bool clearPassword = false,
    bool clearUser = false,
  }) async {
    if (_currentServer == null) {
      throw Exception('没有选中的服务器');
    }

    _currentServer = ServerModel(
      label: _currentServer!.label,
      baseUrl: _currentServer!.baseUrl,
      rememberMe: rememberMe ?? _currentServer!.rememberMe,
      email: clearEmail ? null : (email ?? _currentServer!.email),
      password: clearPassword ? null : (password ?? _currentServer!.password),
      user: clearUser ? null : (user ?? _currentServer!.user),
    );

    // 更新列表中的引用
    final index = _servers.indexWhere((s) => s.label == _currentServer!.label);
    if (index != -1) {
      _servers[index] = _currentServer!;
    }

    await _saveServers();
  }

  /// 清除当前服务器的服务登录信息
  Future<void> clearCurrentServerLogin() async {
    await updateCurrentServerLogin(
      email: null,
      password: null,
      user: null,
      clearEmail: true,
      clearPassword: true,
      clearUser: true,
    );
  }

  /// 重置为默认服务器列表
  Future<void> resetToDefault() async {
    _servers = [ServerModel(label: _defaultLabel, baseUrl: _defaultBaseUrl)];
    _currentServer = _servers.first;
    await _saveServers();
    await _saveLastSelected();
  }
}