Swift Feature Flags：功能切换的应用价值

// 移动端功能标志的特殊考虑因素
struct MobileFeatureFlags {
    let requiresAppUpdate: Bool // 是否需要应用更新才能使用
    let minimumOSVersion: String // 最低系统要求
    let requiresUserConsent: Bool // 是否需要用户明确同意
    let networkDependency: Bool // 是否有网络依赖
}

// 方案管理的实用扩展
extension SchemeManager {
    static var activeScheme: String {
        #if DEBUG
        return "Development"
        #elseif TESTFLIGHT
        return "TestFlight"
        #elseif APPSTORE
        return "AppStore"
        #else
        return "Unknown"
        #endif
    }
    
    static var isDevelopment: Bool {
        activeScheme == "Development"
    }
    
    static var isTestFlight: Bool {
        activeScheme == "TestFlight"
    }
    
    static var isAppStore: Bool {
        activeScheme == "AppStore"
    }
}

/// 分发环境枚举，定义不同的构建配置
/// - 使用Sendable协议确保线程安全
public enum Distribution: Sendable, CaseIterable {
    case debug
    case appstore
    case testflight
    case custom(String) // 支持自定义环境
    
    /// 当前活跃的分发环境
    public static var current: Self {
        #if APPSTORE
        return .appstore
        #elseif TESTFLIGHT
        return .testflight
        #elseif DEBUG
        return .debug
        #else
        // 默认回退到debug环境
        return .debug
        #endif
    }
}

extension Distribution {
    /// 环境描述信息
    public var description: String {
        switch self {
        case .debug: return "开发环境"
        case .appstore: return "生产环境"
        case .testflight: return "测试环境"
        case .custom(let name): return "自定义环境: \(name)"
        }
    }
    
    /// 环境简写标识
    public var identifier: String {
        switch self {
        case .debug: return "DEBUG"
        case .appstore: return "APPSTORE"
        case .testflight: return "TESTFLIGHT"
        case .custom(let name): return "CUSTOM_\(name.uppercased())"
        }
    }
    
    /// 是否允许调试功能
    public var allowsDebugFeatures: Bool {
        self == .debug || self == .testflight
    }
    
    /// 是否生产环境
    public var isProduction: Bool {
        self == .appstore
    }
    
    /// 环境优先级，用于多环境判断
    public var priority: Int {
        switch self {
        case .debug: return 0
        case .testflight: return 1
        case .appstore: return 2
        case .custom: return 3
        }
    }
}

extension Distribution {
    /// 从字符串创建Distribution实例
    public init?(from string: String) {
        switch string.lowercased() {
        case "debug", "development": self = .debug
        case "appstore", "production": self = .appstore
        case "testflight", "beta": self = .testflight
        default: self = .custom(string)
        }
    }
    
    /// 比较两个环境是否兼容
    public func isCompatible(with other: Distribution) -> Bool {
        // 开发环境与测试环境兼容
        if (self == .debug && other == .testflight) ||
           (self == .testflight && other == .debug) {
            return true
        }
        
        // 相同环境当然兼容
        return self == other
    }
    
    /// 获取环境对应的API基地址
    public var baseURL: URL {
        switch self {
        case .debug:
            return URL(string: "https://api.dev.example.com")!
        case .testflight:
            return URL(string: "https://api.staging.example.com")!
        case .appstore:
            return URL(string: "https://api.example.com")!
        case .custom(let name):
            return URL(string: "https://api.\(name).example.com")!
        }
    }
}

/// 功能标志管理器
/// - Decodable: 支持从JSON配置文件解析
/// - Sendable: 确保线程安全
public struct FeatureFlags: Sendable, Decodable {
    // MARK: - 功能标志属性
    
    /// 是否需要支付墙
    public let requirePaywall: Bool
    
    /// 是否需要 onboarding 流程
    public let requireOnboarding: Bool
    
    /// 实验性功能X
    public let featureX: Bool
    
    /// 用户分析功能
    public let analyticsEnabled: Bool
    
    /// 崩溃报告功能
    public let crashReportingEnabled: Bool
    
    /// 性能监控功能
    public let performanceMonitoringEnabled: Bool
    
    /// 高级日志功能
    public let advancedLogging: Bool
    
    // MARK: - 初始化方法
    
    /// 根据分发环境初始化功能标志
    public init(distribution: Distribution) {
        switch distribution {
        case .debug:
            // 开发环境：启用所有功能以便测试
            self.requirePaywall = false // 开发环境禁用支付墙
            self.requireOnboarding = true // 启用onboarding测试
            self.featureX = true // 启用实验功能
            self.analyticsEnabled = true // 启用分析
            self.crashReportingEnabled = true // 启用崩溃报告
            self.performanceMonitoringEnabled = true // 启用性能监控
            self.advancedLogging = true // 启用详细日志
            
        case .testflight:
            // 测试环境：大部分功能启用，但支付相关可能禁用
            self.requirePaywall = false // 测试环境通常免费
            self.requireOnboarding = true
            self.featureX = true // 允许测试新功能
            self.analyticsEnabled = true
            self.crashReportingEnabled = true
            self.performanceMonitoringEnabled = true
            self.advancedLogging = true
            
        case .appstore:
            // 生产环境：保守设置，只启用稳定功能
            self.requirePaywall = true // 生产环境启用支付
            self.requireOnboarding = true
            self.featureX = false // 新功能默认禁用
            self.analyticsEnabled = true
            self.crashReportingEnabled = true
            self.performanceMonitoringEnabled = true
            self.advancedLogging = false // 生产环境减少日志
            
        case .custom:
            // 自定义环境：使用保守的默认值
            self.requirePaywall = true
            self.requireOnboarding = true
            self.featureX = false
            self.analyticsEnabled = true
            self.crashReportingEnabled = false
            self.performanceMonitoringEnabled = true
            self.advancedLogging = false
        }
    }
    
    /// 从字典解码（支持JSON配置）
    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        // 提供默认值的解码方式
        self.requirePaywall = try container.decodeIfPresent(Bool.self, forKey: .requirePaywall) ?? true
        self.requireOnboarding = try container.decodeIfPresent(Bool.self, forKey: .requireOnboarding) ?? true
        self.featureX = try container.decodeIfPresent(Bool.self, forKey: .featureX) ?? false
        self.analyticsEnabled = try container.decodeIfPresent(Bool.self, forKey: .analyticsEnabled) ?? true
        self.crashReportingEnabled = try container.decodeIfPresent(Bool.self, forKey: .crashReportingEnabled) ?? true
        self.performanceMonitoringEnabled = try container.decodeIfPresent(Bool.self, forKey: .performanceMonitoringEnabled) ?? true
        self.advancedLogging = try container.decodeIfPresent(Bool.self, forKey: .advancedLogging) ?? false
    }
    
    // MARK: - 编码键定义
    private enum CodingKeys: String, CodingKey {
        case requirePaywall = "require_paywall"
        case requireOnboarding = "require_onboarding"
        case featureX = "feature_x"
        case analyticsEnabled = "analytics_enabled"
        case crashReportingEnabled = "crash_reporting_enabled"
        case performanceMonitoringEnabled = "performance_monitoring_enabled"
        case advancedLogging = "advanced_logging"
    }
}

extension FeatureFlags {
    /// 功能标志版本信息
    public var version: String {
        return "1.2.0"
    }
    
    /// 获取所有标志的字典表示
    public var dictionaryRepresentation: [String: Any] {
        return [
            "requirePaywall": requirePaywall,
            "requireOnboarding": requireOnboarding,
            "featureX": featureX,
            "analyticsEnabled": analyticsEnabled,
            "crashReportingEnabled": crashReportingEnabled,
            "performanceMonitoringEnabled": performanceMonitoringEnabled,
            "advancedLogging": advancedLogging,
            "version": version
        ]
    }
    
    /// 合并两个功能标志配置
    public func merging(with remoteFlags: [String: Any]) -> FeatureFlags {
        var mergedFlags = self
        
        // 这里可以实现远程配置覆盖本地配置的逻辑
        // 实际项目中可能会更复杂，包括版本检查、类型验证等
        
        return mergedFlags
    }
    
    /// 验证功能标志配置的有效性
    public func validate() throws {
        // 检查冲突的配置
        if requirePaywall && !featureX {
            // 这里可以记录日志或抛出异常
            print("警告: 支付墙已启用但相关功能被禁用")
        }
        
        // 更多验证逻辑...
    }
}

extension FeatureFlags {
    /// 支付相关功能组
    struct PaymentFeatures {
        let subscriptionEnabled: Bool
        let inAppPurchases: Bool
        let paymentProcessing: Bool
    }
    
    /// 社交功能组
    struct SocialFeatures {
        let sharingEnabled: Bool
        let commentsEnabled: Bool
        let userProfiles: Bool
    }
    
    /// 获取支付功能组
    var paymentFeatures: PaymentFeatures {
        return PaymentFeatures(
            subscriptionEnabled: requirePaywall,
            inAppPurchases: requirePaywall,
            paymentProcessing: requirePaywall
        )
    }
}

import SwiftUI

/// 环境键定义
private struct FeatureFlagsKey: EnvironmentKey {
    static let defaultValue: FeatureFlags = FeatureFlags(distribution: .debug)
}

/// 环境值扩展
extension EnvironmentValues {
    /// 功能标志环境值
    public var featureFlags: FeatureFlags {
        get { self[FeatureFlagsKey.self] }
        set { self[FeatureFlagsKey.self] = newValue }
    }
}

/// 主应用结构体
@main
struct CardioBotApp: App {
    // 状态管理
    @State private var featureFlags: FeatureFlags
    @State private var isLoading = true
    
    /// 初始化应用
    init() {
        // 初始化功能标志
        let distribution = Distribution.current
        self._featureFlags = State(initialValue: FeatureFlags(distribution: distribution))
        
        // 配置初始设置
        configureAppearance()
        configureAnalytics()
    }
    
    var body: some Scene {
        WindowGroup {
            Group {
                if isLoading {
                    // 启动加载界面
                    LoadingView()
                } else {
                    // 主界面
                    RootView()
                        .environment(\.featureFlags, featureFlags)
                }
            }
            .onAppear {
                // 模拟启动加载过程
                DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
                    isLoading = false
                }
            }
        }
    }
    
    // MARK: - 私有方法
    
    private func configureAppearance() {
        // 配置应用外观
        UITabBar.appearance().backgroundColor = UIColor.systemBackground
        UINavigationBar.appearance().prefersLargeTitles = true
    }
    
    private func configureAnalytics() {
        // 配置分析工具（根据功能标志决定）
        if featureFlags.analyticsEnabled {
            AnalyticsManager.shared.initialize()
        }
    }
}

/// 示例视图：根据功能标志显示不同内容
struct ContentView: View {
    @Environment(\.featureFlags) private var flags
    
    var body: some View {
        NavigationView {
            List {
                // 支付相关功能
                if flags.requirePaywall {
                    PaymentSection()
                }
                
                // 实验性功能
                if flags.featureX {
                    ExperimentalFeaturesSection()
                }
                
                // 通用功能
                GeneralSettingsSection()
                
                // 调试功能（仅在开发环境显示）
                if !flags.isProduction {
                    DebugSection()
                }
            }
            .navigationTitle("功能设置")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EnvironmentIndicator()
                }
            }
        }
    }
}

/// 环境指示器
struct EnvironmentIndicator: View {
    @Environment(\.featureFlags) private var flags
    
    var body: some View {
        Text(flags.distribution.description)
            .font(.caption2)
            .padding(4)
            .background(flags.isProduction ? Color.green : Color.orange)
            .foregroundColor(.white)
            .cornerRadius(4)
    }
}

/// 远程功能标志服务
actor RemoteFeatureFlagsService {
    static let shared = RemoteFeatureFlagsService()
    
    private let cacheURL: URL
    private var remoteConfig: [String: Any] = [:]
    private var lastUpdateTime: Date?
    
    private init() {
        // 初始化缓存路径
        let cacheDirectory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
        self.cacheURL = cacheDirectory.appendingPathComponent("feature_flags_cache.json")
        
        // 加载缓存配置
        loadCachedConfig()
    }
    
    /// 获取远程配置
    func fetchRemoteConfig() async throws {
        let distribution = Distribution.current
        let url = distribution.baseURL.appendingPathComponent("/api/feature-flags")
        
        let (data, _) = try await URLSession.shared.data(from: url)
        let config = try JSONSerialization.jsonObject(with: data) as? [String: Any] ?? [:]
        
        // 更新内存缓存
        self.remoteConfig = config
        self.lastUpdateTime = Date()
        
        // 保存到磁盘缓存
        saveConfigToCache(config)
    }
    
    /// 获取功能标志值
    func value<T>(forKey key: String, defaultValue: T) -> T {
        return remoteConfig[key] as? T ?? defaultValue
    }
    
    /// 检查配置是否过期
    func isConfigExpired() -> Bool {
        guard let lastUpdate = lastUpdateTime else { return true }
        return Date().timeIntervalSince(lastUpdate) > 3600 // 1小时过期
    }
    
    // MARK: - 私有方法
    
    private func loadCachedConfig() {
        guard FileManager.default.fileExists(atPath: cacheURL.path) else { return }
        
        do {
            let data = try Data(contentsOf: cacheURL)
            let config = try JSONSerialization.jsonObject(with: data) as? [String: Any] ?? [:]
            self.remoteConfig = config
            self.lastUpdateTime = Date(timeIntervalSince1970: 
                (config["_timestamp"] as? Double) ?? 0)
        } catch {
            print("加载缓存配置失败: \(error)")
        }
    }
    
    private func saveConfigToCache(_ config: [String: Any]) {
        var mutableConfig = config
        mutableConfig["_timestamp"] = Date().timeIntervalSince1970
        
        do {
            let data = try JSONSerialization.data(withJSONObject: mutableConfig, options: .prettyPrinted)
            try data.write(to: cacheURL)
        } catch {
            print("保存配置到缓存失败: \(error)")
        }
    }
}

/// 功能标志变化观察器
@MainActor
class FeatureFlagsObserver: ObservableObject {
    @Published private(set) var currentFlags: FeatureFlags
    private var distribution: Distribution
    private var remoteService: RemoteFeatureFlagsService?
    
    init(distribution: Distribution) {
        self.distribution = distribution
        self.currentFlags = FeatureFlags(distribution: distribution)
        
        // 初始化远程服务（如果可用）
        if distribution.allowsDebugFeatures {
            self.remoteService = RemoteFeatureFlagsService.shared
        }
    }
    
    /// 重新加载功能标志
    func reloadFlags() async {
        // 如果有远程服务，尝试获取最新配置
        if let remoteService = remoteService,
           remoteService.isConfigExpired() {
            do {
                try await remoteService.fetchRemoteConfig()
                
                // 创建新的功能标志实例，合并远程配置
                var newFlags = FeatureFlags(distribution: distribution)
                let remoteConfig = await remoteService.getRemoteConfig()
                newFlags = newFlags.merging(with: remoteConfig)
                
                // 更新当前标志
                currentFlags = newFlags
                
            } catch {
                print("获取远程配置失败: \(error)")
                // 失败时使用默认配置
                currentFlags = FeatureFlags(distribution: distribution)
            }
        }
    }
    
    /// 检查特定功能是否可用
    func isFeatureEnabled(_ feature: FeatureIdentifier) -> Bool {
        // 这里可以根据需要实现更复杂的逻辑
        return currentFlags.value(for: feature) ?? false
    }
}

import XCTest
@testable import YourApp

class FeatureFlagsTests: XCTestCase {
    
    func testDebugFlags() {
        // 给定
        let distribution = Distribution.debug
        
        // 当
        let flags = FeatureFlags(distribution: distribution)
        
        // 则
        XCTAssertFalse(flags.requirePaywall, "Debug环境应禁用支付墙")
        XCTAssertTrue(flags.featureX, "Debug环境应启用实验功能")
        XCTAssertTrue(flags.advancedLogging, "Debug环境应启用高级日志")
    }
    
    func testAppStoreFlags() {
        // 给定
        let distribution = Distribution.appstore
        
        // 当
        let flags = FeatureFlags(distribution: distribution)
        
        // 则
        XCTAssertTrue(flags.requirePaywall, "生产环境应启用支付墙")
        XCTAssertFalse(flags.featureX, "生产环境应禁用实验功能")
        XCTAssertFalse(flags.advancedLogging, "生产环境应禁用高级日志")
    }
    
    func testEnvironmentValues() {
        // 给定
        let flags = FeatureFlags(distribution: .testflight)
        let environment = EnvironmentValues()
        
        // 当
        environment.featureFlags = flags
        
        // 则
        XCTAssertEqual(environment.featureFlags.requirePaywall, flags.requirePaywall)
    }
    
    func testRemoteConfigMerge() async {
        // 给定
        let localFlags = FeatureFlags(distribution: .testflight)
        let remoteConfig = ["feature_x": true, "new_feature": false]
        
        // 当
        let mergedFlags = localFlags.merging(with: remoteConfig)
        
        // 则
        XCTAssertTrue(mergedFlags.featureX, "远程配置应覆盖本地设置")
    }
}

import XCTest

class FeatureFlagsUITests: XCTestCase {
    
    let app = XCUIApplication()
    
    override func setUp() {
        super.setUp()
        
        // 设置启动环境变量
        app.launchEnvironment["FEATURE_FLAGS"] = """
        {
            "require_paywall": false,
            "feature_x": true,
            "analytics_enabled": false
        }
        """
        
        continueAfterFailure = false
        app.launch()
    }
    
    func testPaymentSectionVisibility() {
        // 支付墙禁用时，支付部分不应显示
        XCTAssertFalse(app.buttons["支付设置"].exists, 
                      "支付墙禁用时支付设置不应显示")
    }
    
    func testExperimentalFeaturesVisible() {
        // 实验功能启用时，相关UI应该显示
        XCTAssertTrue(app.buttons["实验功能"].exists,
                     "实验功能启用时应显示相关UI")
    }
}

/// 电商应用功能标志实践
struct ECommerceFeatureFlags {
    let enableNewCheckout: Bool
    let enableProductRecommendations: Bool
    let enableWishlist: Bool
    let enableSocialSharing: Bool
    let enableARView: Bool
    
    init(distribution: Distribution) {
        switch distribution {
        case .debug:
            // 开发环境：启用所有新功能
            self.enableNewCheckout = true
            self.enableProductRecommendations = true
            self.enableWishlist = true
            self.enableSocialSharing = true
            self.enableARView = true
            
        case .testflight:
            // 测试环境：启用大部分功能，AR功能可选
            self.enableNewCheckout = true
            self.enableProductRecommendations = true
            self.enableWishlist = true
            self.enableSocialSharing = true
            self.enableARView = false // 需要额外设备支持
            
        case .appstore:
            // 生产环境：逐步启用功能
            self.enableNewCheckout = false // 逐步 rollout
            self.enableProductRecommendations = true
            self.enableWishlist = true
            self.enableSocialSharing = true
            self.enableARView = false
        }
    }
}

/// 社交媒体应用功能标志
struct SocialMediaFeatureFlags {
    let enableStories: Bool
    let enableLiveStreaming: Bool
    let enableDarkMode: Bool
    let enableGroupChats: Bool
    let enableVideoCalls: Bool
    
    // 基于用户分组的标志
    let enableForUserGroup: [String: Bool]
    
    init(distribution: Distribution, userGroup: String? = nil) {
        // 基础配置
        switch distribution {
        case .debug, .testflight:
            enableStories = true
            enableLiveStreaming = true
            enableDarkMode = true
            enableGroupChats = true
            enableVideoCalls = true
        case .appstore:
            enableStories = true
            enableLiveStreaming = false // 新功能
            enableDarkMode = true
            enableGroupChats = true
            enableVideoCalls = false // 新功能
        }
        
        // 用户分组配置
        var groupFlags: [String: Bool] = [:]
        if let userGroup = userGroup {
            // 这里可以实现基于用户分组的特性启用
            groupFlags[userGroup] = true
        }
        self.enableForUserGroup = groupFlags
    }
}

/// 高性能功能标志实现
final class OptimizedFeatureFlags {
    // 使用位掩码优化存储
    private var featureBitmask: UInt64 = 0
    
    // 功能标志枚举
    private enum Feature: Int, CaseIterable {
        case paywall, onboarding, featureX, analytics, crashReporting
        // ... 更多功能
        
        var bitValue: UInt64 {
            return 1 << UInt64(rawValue)
        }
    }
    
    init(distribution: Distribution) {
        configureForDistribution(distribution)
    }
    
    private func configureForDistribution(_ distribution: Distribution) {
        switch distribution {
        case .debug:
            // 启用所有功能位
            Feature.allCases.forEach { feature in
                featureBitmask |= feature.bitValue
            }
        case .testflight:
            // 启用大部分功能，但禁用某些敏感功能
            featureBitmask = Feature.allCases
                .filter { $0 != .paywall } // 测试环境禁用支付
                .reduce(0) { $0 | $1.bitValue }
        case .appstore:
            // 只启用稳定功能
            featureBitmask = [.paywall, .onboarding, .analytics]
                .reduce(0) { $0 | $1.bitValue }
        case .custom:
            // 自定义环境使用保守设置
            featureBitmask = Feature.allCases
                .filter { [.paywall, .onboarding].contains($0) }
                .reduce(0) { $0 | $1.bitValue }
        }
    }
    
    /// 检查功能是否启用
    func isEnabled(_ feature: Feature) -> Bool {
        return (featureBitmask & feature.bitValue) != 0
    }
    
    /// 动态启用功能
    mutating func enable(_ feature: Feature) {
        featureBitmask |= feature.bitValue
    }
    
    /// 动态禁用功能
    mutating func disable(_ feature: Feature) {
        featureBitmask &= ~feature.bitValue
    }
}

// 使用示例
var flags = OptimizedFeatureFlags(distribution: .debug)
print(flags.isEnabled(.featureX)) // true
flags.disable(.featureX)
print(flags.isEnabled(.featureX)) // false

/// 线程安全的功能标志管理器
actor ThreadSafeFeatureFlags {
    private var flags: FeatureFlags
    private let distribution: Distribution
    
    init(distribution: Distribution) {
        self.distribution = distribution
        self.flags = FeatureFlags(distribution: distribution)
    }
    
    /// 获取功能标志值（线程安全）
    func getValue<T>(for keyPath: KeyPath<FeatureFlags, T>) -> T {
        return flags[keyPath: keyPath]
    }
    
    /// 更新功能标志（线程安全）
    func update(with newFlags: FeatureFlags) {
        self.flags = newFlags
    }
    
    /// 批量更新功能标志
    func batchUpdate(_ updates: (inout FeatureFlags) -> Void) {
        var tempFlags = flags
        updates(&tempFlags)
        flags = tempFlags
    }
}

/// 带缓存的功能标志服务
final class CachedFeatureFlagsService {
    private let memoryCache: NSCache<NSString, FeatureFlags>
    private let diskCacheURL: URL
    private let cacheExpiration: TimeInterval = 3600 // 1小时
    
    init() {
        self.memoryCache = NSCache()
        memoryCache.countLimit = 10 // 缓存10个配置
        
        let cacheDirectory = FileManager.default.urls(
            for: .cachesDirectory, 
            in: .userDomainMask
        ).first!
        self.diskCacheURL = cacheDirectory.appendingPathComponent("feature_flags")
        
        createCacheDirectoryIfNeeded()
    }
    
    /// 获取功能标志（带缓存）
    func getFlags(for distribution: Distribution) async -> FeatureFlags {
        // 首先检查内存缓存
        if let cachedFlags = memoryCache.object(forKey: distribution.identifier as NSString) {
            return cachedFlags
        }
        
        // 然后检查磁盘缓存
        if let diskFlags = loadFromDisk(distribution: distribution) {
            memoryCache.setObject(diskFlags, forKey: distribution.identifier as NSString)
            return diskFlags
        }
        
        // 都没有则创建新的
        let newFlags = FeatureFlags(distribution: distribution)
        saveToDisk(flags: newFlags, distribution: distribution)
        memoryCache.setObject(newFlags, forKey: distribution.identifier as NSString)
        
        return newFlags
    }
    
    // MARK: - 私有方法
    
    private func createCacheDirectoryIfNeeded() {
        if !FileManager.default.fileExists(atPath: diskCacheURL.path) {
            try? FileManager.default.createDirectory(
                at: diskCacheURL,
                withIntermediateDirectories: true
            )
        }
    }
    
    private func loadFromDisk(distribution: Distribution) -> FeatureFlags? {
        let fileURL = diskCacheURL.appendingPathComponent("\(distribution.identifier).json")
        
        guard FileManager.default.fileExists(atPath: fileURL.path),
              let data = try? Data(contentsOf: fileURL),
              let flags = try? JSONDecoder().decode(FeatureFlags.self, from: data),
              isCacheValid(for: fileURL) else {
            return nil
        }
        
        return flags
    }
    
    private func saveToDisk(flags: FeatureFlags, distribution: Distribution) {
        let fileURL = diskCacheURL.appendingPathComponent("\(distribution.identifier).json")
        
        if let data = try? JSONEncoder().encode(flags) {
            try? data.write(to: fileURL)
        }
    }
    
    private func isCacheValid(for fileURL: URL) -> Bool {
        guard let attributes = try? FileManager.default.attributesOfItem(atPath: fileURL.path),
              let modificationDate = attributes[.modificationDate] as? Date else {
            return false
        }
        
        return Date().timeIntervalSince(modificationDate) < cacheExpiration
    }
}

/// 功能标志生命周期管理器
class FeatureFlagLifecycleManager {
    private var activeFlags: Set<String> = []
    private var deprecatedFlags: Set<String> = []
    private let cleanupInterval: TimeInterval = 86400 // 24小时
    
    init() {
        startCleanupTimer()
    }
    
    /// 标记功能标志为活跃
    func markAsActive(_ flagName: String) {
        activeFlags.insert(flagName)
        deprecatedFlags.remove(flagName)
    }
    
    /// 标记功能标志为已弃用
    func markAsDeprecated(_ flagName: String) {
        deprecatedFlags.insert(flagName)
        activeFlags.remove(flagName)
    }
    
    /// 检查功能标志是否已弃用
    func isDeprecated(_ flagName: String) -> Bool {
        return deprecatedFlags.contains(flagName)
    }
    
    /// 获取所有活跃标志
    func getActiveFlags() -> Set<String> {
        return activeFlags
    }
    
    /// 获取所有弃用标志
    func getDeprecatedFlags() -> Set<String> {
        return deprecatedFlags
    }
    
    /// 定期清理过期的弃用标志
    private func startCleanupTimer() {
        Timer.scheduledTimer(withTimeInterval: cleanupInterval, repeats: true) { [weak self] _ in
            self?.cleanupDeprecatedFlags()
        }
    }
    
    private func cleanupDeprecatedFlags() {
        // 这里可以实现具体的清理逻辑
        // 比如移除已经弃用一段时间的标志
        print("执行弃用功能标志清理...")
    }
}

/// 版本兼容性管理器
struct VersionCompatibility {
    let currentVersion: String
    let minimumSupportedVersion: String
    let featureMinimumVersions: [String: String]
    
    /// 检查功能是否在当前版本可用
    func isFeatureAvailable(_ feature: String) -> Bool {
        guard let minVersion = featureMinimumVersions[feature] else {
            return true // 没有版本限制的功能始终可用
        }
        
        return compareVersions(currentVersion, minVersion) >= 0
    }
    
    /// 比较两个版本号
    private func compareVersions(_ version1: String, _ version2: String) -> Int {
        let components1 = version1.split(separator: ".")
        let components2 = version2.split(separator: ".")
        
        for i in 0..<max(components1.count, components2.count) {
            let part1 = i < components1.count ? Int(components1[i]) ?? 0 : 0
            let part2 = i < components2.count ? Int(components2[i]) ?? 0 : 0
            
            if part1 != part2 {
                return part1 > part2 ? 1 : -1
            }
        }
        
        return 0
    }
}

// 使用示例
let compatibility = VersionCompatibility(
    currentVersion: "2.1.0",
    minimumSupportedVersion: "1.0.0",
    featureMinimumVersions: [
        "new_checkout": "2.0.0",
        "dark_mode": "1.5.0"
    ]
)

print(compatibility.isFeatureAvailable("new_checkout")) // true
print(compatibility.isFeatureAvailable("legacy_feature")) // true

/// 功能标志使用监控器
actor FeatureFlagUsageMonitor {
    private var usageCount: [String: Int] = [:]
    private var lastResetDate: Date = Date()
    private let resetInterval: TimeInterval = 86400 // 24小时
    
    /// 记录功能标志使用
    func recordUsage(_ flagName: String) {
        usageCount[flagName, default: 0] += 1
        checkResetNeeded()
    }
    
    /// 获取使用统计
    func getUsageStatistics() -> [String: Int] {
        return usageCount
    }
    
    /// 重置统计（定期自动执行）
    func resetStatistics() {
        usageCount.removeAll()
        lastResetDate = Date()
    }
    
    /// 检查是否需要重置
    private func checkResetNeeded() {
        if Date().timeIntervalSince(lastResetDate) >= resetInterval {
            resetStatistics()
        }
    }
    
    /// 生成使用报告
    func generateReport() -> String {
        let sortedUsage = usageCount.sorted { $0.value > $1.value }
        var report = "功能标志使用报告:\n"
        
        for (flag, count) in sortedUsage {
            report += "\(flag): \(count) 次使用\n"
        }
        
        return report
    }
}

/// 功能标志日志记录器
struct FeatureFlagLogger {
    enum LogLevel: String {
        case debug, info, warning, error
    }
    
    static func log(_ message: String, level: LogLevel = .info, feature: String? = nil) {
        #if DEBUG
        let timestamp = DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium)
        var logMessage = "[\(timestamp)] [\(level.rawValue.uppercased())]"
        
        if let feature = feature {
            logMessage += " [\(feature)]"
        }
        
        logMessage += " \(message)"
        
        print(logMessage)
        #endif
    }
    
    static func debug(_ message: String, feature: String? = nil) {
        log(message, level: .debug, feature: feature)
    }
    
    static func info(_ message: String, feature: String? = nil) {
        log(message, level: .info, feature: feature)
    }
    
    static func warning(_ message: String, feature: String? = nil) {
        log(message, level: .warning, feature: feature)
    }
    
    static func error(_ message: String, feature: String? = nil) {
        log(message, level: .error, feature: feature)
    }
}

// 使用示例
FeatureFlagLogger.info("功能标志初始化完成", feature: "支付系统")
FeatureFlagLogger.debug("实验功能X已启用", feature: "功能X")

/// 安全相关的功能标志管理
struct SecurityFeatureFlags {
    let enableEncryption: Bool
    let enableBiometricAuth: Bool
    let enableTwoFactorAuth: Bool
    let enableSecureStorage: Bool
    let enableNetworkSecurity: Bool
    
    // 敏感操作的安全设置
    let securityLevel: SecurityLevel
    
    enum SecurityLevel: Int {
        case low, medium, high, maximum
    }
    
    init(distribution: Distribution) {
        // 安全设置应该更加保守
        switch distribution {
        case .debug:
            // 开发环境：降低安全要求以便测试
            self.enableEncryption = true
            self.enableBiometricAuth = false
            self.enableTwoFactorAuth = false
            self.enableSecureStorage = true
            self.enableNetworkSecurity = true
            self.securityLevel = .medium
            
        case .testflight:
            // 测试环境：中等安全级别
            self.enableEncryption = true
            self.enableBiometricAuth = true
            self.enableTwoFactorAuth = false
            self.enableSecureStorage = true
            self.enableNetworkSecurity = true
            self.securityLevel = .high
            
        case .appstore:
            // 生产环境：最高安全级别
            self.enableEncryption = true
            self.enableBiometricAuth = true
            self.enableTwoFactorAuth = true
            self.enableSecureStorage = true
            self.enableNetworkSecurity = true
            self.securityLevel = .maximum
        }
    }
    
    /// 验证安全配置
    func validateSecurityConfiguration() throws {
        if enableEncryption && !enableSecureStorage {
            throw SecurityError.inconsistentConfiguration(
                "加密已启用但安全存储被禁用"
            )
        }
        
        if enableTwoFactorAuth && !enableBiometricAuth {
            throw SecurityError.inconsistentConfiguration(
                "双因素认证需要生物识别支持"
            )
        }
    }
}

enum SecurityError: Error {
    case inconsistentConfiguration(String)
    case insufficientSecurityLevel
    case featureNotAvailable
}

/// 敏感数据功能标志
struct SensitiveDataFlags {
    let allowDataCollection: Bool
    let allowDataSharing: Bool
    let allowDataExport: Bool
    let requireExplicitConsent: Bool
    let dataRetentionPeriod: TimeInterval // 数据保留期限
    
    init(distribution: Distribution) {
        switch distribution {
        case .debug:
            self.allowDataCollection = true
            self.allowDataSharing = true
            self.allowDataExport = true
            self.requireExplicitConsent = false // 开发环境简化 consent
            self.dataRetentionPeriod = 7 * 86400 // 7天
            
        case .testflight:
            self.allowDataCollection = true
            self.allowDataSharing = false // 测试环境限制数据共享
            self.allowDataExport = false
            self.requireExplicitConsent = true
            self.dataRetentionPeriod = 30 * 86400 // 30天
            
        case .appstore:
            self.allowDataCollection = true
            self.allowDataSharing = true
            self.allowDataExport = true
            self.requireExplicitConsent = true
            self.dataRetentionPeriod = 365 * 86400 // 1年
        }
    }
    
    /// 检查数据操作是否被允许
    func canPerformOperation(_ operation: DataOperation) -> Bool {
        switch operation {
        case .collection:
            return allowDataCollection
        case .sharing:
            return allowDataSharing
        case .export:
            return allowDataExport
        }
    }
}

enum DataOperation {
    case collection, sharing, export
}

/// 功能标志代码审查清单
struct FeatureFlagCodeReviewChecklist {
    let hasProperDocumentation: Bool
    let hasUnitTests: Bool
    let hasIntegrationTests: Bool
    let followsNamingConventions: Bool
    let includesCleanupPlan: Bool
    let hasSecurityReview: Bool
    let hasPerformanceReview: Bool
    let hasUXReview: Bool
    
    /// 检查是否通过所有审查
    var isApproved: Bool {
        return hasProperDocumentation &&
               hasUnitTests &&
               hasIntegrationTests &&
               followsNamingConventions &&
               includesCleanupPlan &&
               hasSecurityReview &&
               hasPerformanceReview &&
               hasUXReview
    }
    
    /// 生成审查报告
    func generateReport() -> String {
        var report = "功能标志代码审查报告:\n"
        report += "✅ 文档齐全: \(hasProperDocumentation)\n"
        report += "✅ 单元测试: \(hasUnitTests)\n"
        report += "✅ 集成测试: \(hasIntegrationTests)\n"
        report += "✅ 命名规范: \(followsNamingConventions)\n"
        report += "✅ 清理计划: \(includesCleanupPlan)\n"
        report += "✅ 安全审查: \(hasSecurityReview)\n"
        report += "✅ 性能审查: \(hasPerformanceReview)\n"
        report += "✅ UX审查: \(hasUXReview)\n"
        report += "📊 总体通过: \(isApproved)"
        
        return report
    }
}

/// AI驱动的功能标志优化
class AIFeatureFlagOptimizer {
    private let machineLearningModel: MLModel
    private let usageData: [String: Any]
    private let performanceMetrics: [String: Double]
    
    init(usageData: [String: Any], performanceMetrics: [String: Double]) {
        self.usageData = usageData
        self.performanceMetrics = performanceMetrics
        // 这里可以初始化机器学习模型
        self.machineLearningModel = try! MLModel(contentsOf: URL(fileURLWithPath: "model.mlmodel"))
    }
    
    /// 基于AI预测最佳功能标志配置
    func predictOptimalConfiguration() -> [String: Bool] {
        // 使用机器学习模型预测最佳配置
        let input = AIFeatureFlagInput(
            usageData: usageData,
            performanceMetrics: performanceMetrics
        )
        
        guard let prediction = try? machineLearningModel.prediction(from: input) else {
            return defaultConfiguration()
        }
        
        return processPrediction(prediction)
    }
    
    private func defaultConfiguration() -> [String: Bool] {
        // 返回保守的默认配置
        return [
            "feature_x": false,
            "new_checkout": false,
            "experimental_ui": false
        ]
    }
    
    private func processPrediction(_ prediction: MLFeatureProvider) -> [String: Bool] {
        // 处理模型预测结果
        var configuration: [String: Bool] = [:]
        
        // 这里实现具体的处理逻辑
        // ...
        
        return configuration
    }
}

/// 实时功能标志更新系统
class RealTimeFeatureFlagUpdater {
    private let webSocketClient: WebSocketClient
    private let featureFlagObserver: FeatureFlagsObserver
    private var isConnected = false
    
    init(featureFlagObserver: FeatureFlagsObserver) {
        self.featureFlagObserver = featureFlagObserver
        self.webSocketClient = WebSocketClient(url: URL(string: "wss://flags.example.com/ws")
        setupWebSocketHandlers()
    }
    
    /// 连接到实时更新服务
    func connect() {
        webSocketClient.connect()
        isConnected = true
    }
    
    /// 断开连接
    func disconnect() {
        webSocketClient.disconnect()
        isConnected = false
    }
    
    /// 设置WebSocket处理器
    private func setupWebSocketHandlers() {
        webSocketClient.onMessage = { [weak self] message in
            self?.handleRealTimeUpdate(message)
        }
        
        webSocketClient.onConnect = {
            print("实时功能标志更新已连接")
        }
        
        webSocketClient.onDisconnect = {
            print("实时功能标志更新已断开")
        }
    }
    
    /// 处理实时更新
    private func handleRealTimeUpdate(_ message: String) {
        guard let data = message.data(using: .utf8),
              let update = try? JSONDecoder().decode(FeatureFlagUpdate.self, from: data) else {
            return
        }
        
        Task {
            await featureFlagObserver.applyUpdate(update)
        }
    }
}

/// 功能标志更新消息
struct FeatureFlagUpdate: Codable {
    let feature: String
    let enabled: Bool
    let timestamp: Date
    let reason: String?
}