Analytics Setup

import Foundation

/// App analytics events.
///
/// Add your app-specific events here. Use past tense for completed actions.
///
/// Example usage:
/// ```swift
/// analytics.track(.screenViewed(name: "Settings"))
/// analytics.track(.buttonTapped("subscribe"))
/// analytics.track(.featureUsed("dark_mode"))
/// ```
enum AnalyticsEvent: Sendable {

    // MARK: - App Lifecycle

    /// App launched (cold start)
    case appLaunched

    /// App moved to background
    case appBackgrounded

    /// App returned to foreground
    case appForegrounded

    // MARK: - Navigation

    /// Screen was viewed
    case screenViewed(name: String)

    // MARK: - User Actions

    /// Button was tapped
    case buttonTapped(name: String)

    /// Feature was used/enabled
    case featureUsed(name: String)

    /// Search performed
    case searchPerformed(query: String)

    // MARK: - Errors

    /// Error occurred
    case errorOccurred(domain: String, code: Int)

    // MARK: - Custom Events

    /// Custom event with properties
    case custom(name: String, properties: [String: String])

    // MARK: - Add Your Events Below

    // Example:
    // case itemCreated(type: String)
    // case itemDeleted(type: String)
    // case subscriptionStarted(plan: String)
    // case settingsChanged(setting: String, value: String)
}

// MARK: - Event Names

extension AnalyticsEvent {

    /// The event name string used for tracking.
    var name: String {
        switch self {
        case .appLaunched:
            return "app_launched"
        case .appBackgrounded:
            return "app_backgrounded"
        case .appForegrounded:
            return "app_foregrounded"
        case .screenViewed(let name):
            return "screen_viewed_\(name.lowercased().replacingOccurrences(of: " ", with: "_"))"
        case .buttonTapped(let name):
            return "button_tapped_\(name.lowercased())"
        case .featureUsed(let name):
            return "feature_used_\(name.lowercased())"
        case .searchPerformed:
            return "search_performed"
        case .errorOccurred(let domain, let code):
            return "error_\(domain.lowercased())_\(code)"
        case .custom(let name, _):
            return name
        }
    }

    /// Additional properties for the event.
    var properties: [String: String] {
        switch self {
        case .screenViewed(let name):
            return ["screen_name": name]
        case .buttonTapped(let name):
            return ["button_name": name]
        case .featureUsed(let name):
            return ["feature_name": name]
        case .searchPerformed(let query):
            // Don't track exact query for privacy - just that search was used
            return ["query_length": String(query.count)]
        case .errorOccurred(let domain, let code):
            return ["error_domain": domain, "error_code": String(code)]
        case .custom(_, let properties):
            return properties
        default:
            return [:]
        }
    }
}

import Foundation

/// Protocol defining the analytics service interface.
///
/// This protocol allows swapping analytics providers without changing app code.
/// Use `NoOpAnalytics` for testing and previews.
///
/// Example:
/// ```swift
/// // In App.swift
/// let analytics: AnalyticsService = TelemetryDeckAnalytics(appID: "...")
///
/// // To swap providers, change ONE line:
/// let analytics: AnalyticsService = FirebaseAnalytics()
/// ```
protocol AnalyticsService: Sendable {

    /// Configure the analytics service. Call once at app launch.
    func configure()

    /// Track an event.
    func track(_ event: AnalyticsEvent)

    /// Track an event with additional properties.
    func track(_ event: AnalyticsEvent, properties: [String: String])

    /// Set a user property that persists across sessions.
    func setUserProperty(_ key: String, value: String)

    /// Set the user ID for attribution. Pass nil to clear.
    func setUserID(_ id: String?)

    /// Reset all user data. Call on logout.
    func reset()
}

// MARK: - Default Implementations

extension AnalyticsService {

    func track(_ event: AnalyticsEvent) {
        track(event, properties: [:])
    }

    func setUserID(_ id: String?) {
        // Optional - not all providers support this
    }

    func reset() {
        // Default no-op
    }
}

// MARK: - Common User Property Keys

enum AnalyticsUserProperty {
    static let appVersion = "app_version"
    static let subscriptionStatus = "subscription_status"
    static let theme = "theme"

    // Add your custom properties here
}

import SwiftUI

/// SwiftUI Environment key for analytics service.
///
/// Usage:
/// ```swift
/// // In App.swift
/// ContentView()
///     .environment(\.analytics, TelemetryDeckAnalytics(appID: "..."))
///
/// // In any View
/// struct MyView: View {
///     @Environment(\.analytics) private var analytics
///
///     var body: some View {
///         Button("Action") {
///             analytics.track(.buttonTapped("action"))
///         }
///     }
/// }
/// ```
private struct AnalyticsServiceKey: EnvironmentKey {
    static let defaultValue: AnalyticsService = NoOpAnalytics()
}

extension EnvironmentValues {
    var analytics: AnalyticsService {
        get { self[AnalyticsServiceKey.self] }
        set { self[AnalyticsServiceKey.self] = newValue }
    }
}

// MARK: - Screen Tracking Modifier

/// View modifier for automatic screen tracking.
///
/// Usage:
/// ```swift
/// SettingsView()
///     .trackScreen("Settings")
/// ```
struct AnalyticsScreenModifier: ViewModifier {
    let screenName: String
    @Environment(\.analytics) private var analytics

    func body(content: Content) -> some View {
        content.onAppear {
            analytics.track(.screenViewed(name: screenName))
        }
    }
}

extension View {
    /// Track when this screen appears.
    func trackScreen(_ name: String) -> some View {
        modifier(AnalyticsScreenModifier(screenName: name))
    }
}

import Foundation
import FirebaseCore
import FirebaseAnalytics

/// Firebase Analytics implementation.
///
/// Firebase Analytics provides comprehensive analytics with Google's infrastructure.
/// Note: May require user consent in EU/GDPR jurisdictions.
///
/// Setup:
/// 1. Add to Package.swift:
///    .package(url: "https://github.com/firebase/firebase-ios-sdk", from: "10.0.0")
///    // Add FirebaseAnalytics product
///
/// 2. Download GoogleService-Info.plist from Firebase Console
///    and add to your app target
///
/// 3. Initialize in App.swift:
///    let analytics: AnalyticsService = FirebaseAnalytics()
///
/// Usage:
/// ```swift
/// analytics.track(.screenViewed(name: "Settings"))
/// analytics.track(.buttonTapped("subscribe"))
/// ```
final class FirebaseAnalyticsService: AnalyticsService, @unchecked Sendable {

    init() {}

    func configure() {
        // FirebaseApp.configure() should be called once at app launch
        if FirebaseApp.app() == nil {
            FirebaseApp.configure()
        }
    }

    func track(_ event: AnalyticsEvent, properties: [String: String]) {
        var parameters: [String: Any] = event.properties
        for (key, value) in properties {
            parameters[key] = value
        }

        Analytics.logEvent(event.firebaseName, parameters: parameters.isEmpty ? nil : parameters)
    }

    func setUserProperty(_ key: String, value: String) {
        Analytics.setUserProperty(value, forName: key)
    }

    func setUserID(_ id: String?) {
        Analytics.setUserID(id)
    }

    func reset() {
        Analytics.setUserID(nil)
        Analytics.resetAnalyticsData()
    }
}

// MARK: - Firebase Event Names

extension AnalyticsEvent {

    /// Firebase-compatible event name.
    /// Firebase has specific naming requirements and reserved event names.
    var firebaseName: String {
        switch self {
        case .appLaunched:
            return "app_open" // Firebase reserved event
        case .screenViewed:
            return AnalyticsEventScreenView // Firebase reserved event
        case .buttonTapped:
            return "button_tap"
        case .featureUsed:
            return "feature_use"
        case .searchPerformed:
            return AnalyticsEventSearch // Firebase reserved event
        case .errorOccurred:
            return "app_error"
        case .custom(let name, _):
            return name
        default:
            return name.replacingOccurrences(of: "-", with: "_")
        }
    }
}

// MARK: - Consent Management

extension FirebaseAnalyticsService {

    /// Set analytics collection based on user consent.
    /// Call this when user grants or revokes consent.
    static func setAnalyticsCollectionEnabled(_ enabled: Bool) {
        Analytics.setAnalyticsCollectionEnabled(enabled)
    }
}

import Foundation

/// No-operation analytics implementation.
///
/// Use for:
/// - Unit tests
/// - SwiftUI previews
/// - Users who opted out of analytics
/// - Debug builds (optional)
///
/// Example:
/// ```swift
/// // In tests
/// let analytics: AnalyticsService = NoOpAnalytics()
///
/// // In previews
/// #Preview {
///     ContentView()
///         .environment(\.analytics, NoOpAnalytics())
/// }
///
/// // For user opt-out
/// let analytics: AnalyticsService = userOptedIn ? TelemetryDeckAnalytics(...) : NoOpAnalytics()
/// ```
final class NoOpAnalytics: AnalyticsService, @unchecked Sendable {

    init() {}

    func configure() {
        // No-op
    }

    func track(_ event: AnalyticsEvent, properties: [String: String]) {
        // No-op
        #if DEBUG
        // Uncomment to see what would be tracked:
        // print("[Analytics NoOp] \(event.name) - \(properties)")
        #endif
    }

    func setUserProperty(_ key: String, value: String) {
        // No-op
    }

    func setUserID(_ id: String?) {
        // No-op
    }

    func reset() {
        // No-op
    }
}

import Foundation
import TelemetryClient

/// TelemetryDeck analytics implementation.
///
/// TelemetryDeck is a privacy-friendly analytics service that doesn't require
/// user consent in most jurisdictions (no cookies, no personal data).
///
/// Setup:
/// 1. Add to Package.swift:
///    .package(url: "https://github.com/TelemetryDeck/SwiftClient", from: "1.0.0")
///
/// 2. Get your App ID from https://dashboard.telemetrydeck.com
///
/// 3. Initialize in App.swift:
///    let analytics: AnalyticsService = TelemetryDeckAnalytics(appID: "YOUR-APP-ID")
///
/// Usage:
/// ```swift
/// analytics.track(.screenViewed(name: "Settings"))
/// analytics.track(.buttonTapped("subscribe"))
/// ```
final class TelemetryDeckAnalytics: AnalyticsService, @unchecked Sendable {

    private let appID: String

    /// Initialize with your TelemetryDeck App ID.
    /// - Parameter appID: Your app ID from TelemetryDeck dashboard
    init(appID: String) {
        self.appID = appID
    }

    func configure() {
        let config = TelemetryManagerConfiguration(appID: appID)
        TelemetryManager.initialize(with: config)
    }

    func track(_ event: AnalyticsEvent, properties: [String: String]) {
        var allProperties = event.properties
        for (key, value) in properties {
            allProperties[key] = value
        }

        TelemetryManager.send(event.name, with: allProperties)
    }

    func setUserProperty(_ key: String, value: String) {
        // TelemetryDeck uses default user properties from the SDK
        // Custom properties are sent with each signal
        // Store locally if you need to include in all future events
    }

    func setUserID(_ id: String?) {
        // TelemetryDeck generates anonymous user IDs automatically
        // No need to set explicitly
    }

    func reset() {
        // TelemetryDeck doesn't store user state that needs resetting
    }
}

// MARK: - Configuration Options

extension TelemetryDeckAnalytics {

    /// Create with additional configuration options.
    static func configured(
        appID: String,
        salt: String? = nil,
        testMode: Bool = false
    ) -> TelemetryDeckAnalytics {
        let analytics = TelemetryDeckAnalytics(appID: appID)

        // Configure with options if needed
        var config = TelemetryManagerConfiguration(appID: appID)
        if let salt = salt {
            config.salt = salt
        }
        config.testMode = testMode

        TelemetryManager.initialize(with: config)

        return analytics
    }
}