Error Monitoring

import Foundation
// import FirebaseCrashlytics  // Uncomment after adding Firebase SDK
// import FirebaseCore

/// Firebase Crashlytics implementation of ErrorMonitoringService.
///
/// Prerequisites:
/// 1. Add Firebase SDK via SPM or CocoaPods
/// 2. Download GoogleService-Info.plist from Firebase Console
/// 3. Enable Crashlytics in Firebase Console
/// 4. Uncomment the imports and implementation below
///
/// Usage:
/// ```swift
/// let service: ErrorMonitoringService = CrashlyticsErrorMonitoring()
/// service.configure()  // Call at app launch
/// ```
final class CrashlyticsErrorMonitoring: ErrorMonitoringService, @unchecked Sendable {

    // MARK: - ErrorMonitoringService

    func configure() {
        // TODO: Uncomment after adding Firebase SDK
        /*
        // Configure Firebase (if not already done)
        if FirebaseApp.app() == nil {
            FirebaseApp.configure()
        }

        // Enable collection (respect user preference)
        Crashlytics.crashlytics().setCrashlyticsCollectionEnabled(true)

        // Set custom keys
        Crashlytics.crashlytics().setCustomValue(releaseVersion, forKey: "app_version")

        #if DEBUG
        // Disable in debug builds to avoid noise
        Crashlytics.crashlytics().setCrashlyticsCollectionEnabled(false)
        #endif
        */

        print("[Crashlytics] Would configure Firebase Crashlytics")
    }

    func captureError(_ error: Error, context: ErrorContext?) {
        // TODO: Uncomment after adding Firebase SDK
        /*
        let nsError = error as NSError

        // Record error with context
        Crashlytics.crashlytics().record(error: nsError, userInfo: buildUserInfo(context))

        // Also set custom keys from tags
        if let context {
            for (key, value) in context.tags {
                Crashlytics.crashlytics().setCustomValue(value, forKey: key)
            }
        }
        */

        print("[Crashlytics] Would record error: \(error)")
    }

    func captureMessage(_ message: String, level: ErrorLevel) {
        // TODO: Uncomment after adding Firebase SDK
        /*
        // Crashlytics uses log() for non-fatal messages
        Crashlytics.crashlytics().log("\(level.rawValue.uppercased()): \(message)")

        // For fatal level, also record as exception
        if level == .fatal {
            let error = NSError(
                domain: "AppError",
                code: -1,
                userInfo: [NSLocalizedDescriptionKey: message]
            )
            Crashlytics.crashlytics().record(error: error)
        }
        */

        print("[Crashlytics] Would log \(level.rawValue): \(message)")
    }

    func addBreadcrumb(_ breadcrumb: Breadcrumb) {
        // TODO: Uncomment after adding Firebase SDK
        /*
        // Crashlytics uses log() for breadcrumbs
        let message = "[\(breadcrumb.category)] \(breadcrumb.message)"
        Crashlytics.crashlytics().log(message)

        // Add data as custom keys if present
        if let data = breadcrumb.data {
            for (key, value) in data {
                Crashlytics.crashlytics().setCustomValue(
                    value,
                    forKey: "breadcrumb_\(key)"
                )
            }
        }
        */

        print("[Crashlytics] Would log breadcrumb: [\(breadcrumb.category)] \(breadcrumb.message)")
    }

    func setUser(_ user: MonitoringUser?) {
        // TODO: Uncomment after adding Firebase SDK
        /*
        if let user {
            Crashlytics.crashlytics().setUserID(user.id)

            if let segment = user.segment {
                Crashlytics.crashlytics().setCustomValue(segment, forKey: "user_segment")
            }

            if let username = user.username {
                Crashlytics.crashlytics().setCustomValue(username, forKey: "username")
            }
        } else {
            Crashlytics.crashlytics().setUserID("")
        }
        */

        if let user {
            print("[Crashlytics] Would set user ID: \(user.id)")
        } else {
            print("[Crashlytics] Would clear user ID")
        }
    }

    func reset() {
        // TODO: Uncomment after adding Firebase SDK
        /*
        Crashlytics.crashlytics().setUserID("")

        // Clear custom keys
        // Note: Crashlytics doesn't have a clear all method
        // Set known keys to empty
        Crashlytics.crashlytics().setCustomValue("", forKey: "user_segment")
        Crashlytics.crashlytics().setCustomValue("", forKey: "username")
        */

        print("[Crashlytics] Would reset user data")
    }

    // MARK: - Helpers

    private var releaseVersion: String {
        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
        let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "0"
        return "\(version) (\(build))"
    }

    private func buildUserInfo(_ context: ErrorContext?) -> [String: Any] {
        var userInfo: [String: Any] = [:]

        if let context {
            // Add tags
            for (key, value) in context.tags {
                userInfo["tag_\(key)"] = value
            }

            // Add extra (converted to strings for NSError userInfo)
            for (key, value) in context.extra {
                userInfo["extra_\(key)"] = String(describing: value)
            }
        }

        return userInfo
    }
}

// MARK: - Crashlytics Collection Control

extension CrashlyticsErrorMonitoring {

    /// Enable or disable crash collection (for user consent).
    func setCollectionEnabled(_ enabled: Bool) {
        // TODO: Uncomment after adding Firebase SDK
        /*
        Crashlytics.crashlytics().setCrashlyticsCollectionEnabled(enabled)
        */

        print("[Crashlytics] Would set collection enabled: \(enabled)")
    }

    /// Check if crash collection is enabled.
    var isCollectionEnabled: Bool {
        // TODO: Uncomment after adding Firebase SDK
        /*
        return Crashlytics.crashlytics().isCrashlyticsCollectionEnabled()
        */

        return true
    }
}

import Foundation

/// Context information for error reports.
///
/// Includes breadcrumbs, tags, and extra data to help debug issues.
///
/// Usage:
/// ```swift
/// let context = ErrorContext(
///     tags: ["feature": "checkout", "step": "payment"],
///     extra: ["cart_items": 3, "total": 99.99]
/// )
/// errorMonitoring.captureError(error, context: context)
/// ```
struct ErrorContext: Sendable {

    /// Indexed tags for filtering (string values only).
    var tags: [String: String]

    /// Additional data for debugging.
    var extra: [String: any Sendable]

    /// Custom fingerprint for error grouping.
    /// Errors with the same fingerprint are grouped together.
    var fingerprint: [String]?

    init(
        tags: [String: String] = [:],
        extra: [String: any Sendable] = [:],
        fingerprint: [String]? = nil
    ) {
        self.tags = tags
        self.extra = extra
        self.fingerprint = fingerprint
    }
}

// MARK: - Builder Pattern

extension ErrorContext {

    /// Add a tag.
    func tag(_ key: String, _ value: String) -> ErrorContext {
        var copy = self
        copy.tags[key] = value
        return copy
    }

    /// Add extra data.
    func with(_ key: String, _ value: any Sendable) -> ErrorContext {
        var copy = self
        copy.extra[key] = value
        return copy
    }

    /// Set custom fingerprint.
    func fingerprinted(_ values: String...) -> ErrorContext {
        var copy = self
        copy.fingerprint = values
        return copy
    }
}

// MARK: - Breadcrumb

/// A breadcrumb represents an event that happened before an error.
///
/// Breadcrumbs provide a trail of events leading to errors,
/// helping with debugging.
///
/// Usage:
/// ```swift
/// // UI event
/// let breadcrumb = Breadcrumb(
///     category: "ui",
///     message: "User tapped checkout button"
/// )
///
/// // Network event
/// let breadcrumb = Breadcrumb(
///     category: "network",
///     message: "API request completed",
///     data: ["endpoint": "/api/orders", "status": "200"]
/// )
/// ```
struct Breadcrumb: Sendable {

    /// When the event occurred.
    let timestamp: Date

    /// Category of the event (e.g., "navigation", "ui", "network", "user").
    let category: String

    /// Human-readable description.
    let message: String

    /// Severity level.
    let level: ErrorLevel

    /// Additional data.
    let data: [String: String]?

    init(
        category: String,
        message: String,
        level: ErrorLevel = .info,
        data: [String: String]? = nil
    ) {
        self.timestamp = .now
        self.category = category
        self.message = message
        self.level = level
        self.data = data
    }
}

// MARK: - Common Breadcrumb Categories

extension Breadcrumb {

    /// Navigation breadcrumb (screen changes).
    static func navigation(_ screenName: String) -> Breadcrumb {
        Breadcrumb(
            category: "navigation",
            message: "Viewed \(screenName)"
        )
    }

    /// UI interaction breadcrumb.
    static func ui(_ action: String, element: String? = nil) -> Breadcrumb {
        var data: [String: String]? = nil
        if let element {
            data = ["element": element]
        }
        return Breadcrumb(
            category: "ui",
            message: action,
            data: data
        )
    }

    /// Network request breadcrumb.
    static func network(
        method: String,
        url: String,
        statusCode: Int? = nil
    ) -> Breadcrumb {
        var data = ["method": method, "url": url]
        if let statusCode {
            data["status"] = String(statusCode)
        }
        return Breadcrumb(
            category: "network",
            message: "\(method) \(url)",
            data: data
        )
    }

    /// User action breadcrumb.
    static func user(_ action: String, data: [String: String]? = nil) -> Breadcrumb {
        Breadcrumb(
            category: "user",
            message: action,
            data: data
        )
    }

    /// State change breadcrumb.
    static func state(_ description: String, data: [String: String]? = nil) -> Breadcrumb {
        Breadcrumb(
            category: "state",
            message: description,
            data: data
        )
    }

    /// Error breadcrumb (for non-fatal errors).
    static func error(_ description: String) -> Breadcrumb {
        Breadcrumb(
            category: "error",
            message: description,
            level: .error
        )
    }
}

// MARK: - SwiftUI Navigation Tracking

import SwiftUI

extension View {

    /// Automatically add navigation breadcrumb when view appears.
    func trackScreen(_ name: String) -> some View {
        onAppear {
            Task { @MainActor in
                ErrorMonitoring.shared.service.addBreadcrumb(.navigation(name))
            }
        }
    }
}

import Foundation
import SwiftUI

/// Protocol for error monitoring services.
///
/// Provides a consistent interface for capturing errors, messages,
/// and breadcrumbs across different providers (Sentry, Crashlytics, etc.).
///
/// Usage:
/// ```swift
/// // Capture an error
/// errorMonitoring.captureError(error)
///
/// // Capture with context
/// let context = ErrorContext(tags: ["feature": "checkout"])
/// errorMonitoring.captureError(error, context: context)
///
/// // Add breadcrumb
/// errorMonitoring.addBreadcrumb(
///     Breadcrumb(category: "navigation", message: "Opened settings")
/// )
/// ```
protocol ErrorMonitoringService: Sendable {

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

    /// Capture an error with optional context.
    func captureError(_ error: Error, context: ErrorContext?)

    /// Capture a message with severity level.
    func captureMessage(_ message: String, level: ErrorLevel)

    /// Add a breadcrumb for debugging context.
    func addBreadcrumb(_ breadcrumb: Breadcrumb)

    /// Set the current user (use anonymized IDs only).
    func setUser(_ user: MonitoringUser?)

    /// Clear user and session data.
    /// Call on logout.
    func reset()
}

// MARK: - Default Implementations

extension ErrorMonitoringService {

    /// Capture an error without additional context.
    func captureError(_ error: Error) {
        captureError(error, context: nil)
    }
}

// MARK: - Error Level

/// Severity level for captured messages.
enum ErrorLevel: String, Sendable, CaseIterable {
    case debug      // Development debugging
    case info       // Informational
    case warning    // Unexpected but not critical
    case error      // Error affecting user experience
    case fatal      // Critical failure / crash
}

// MARK: - Monitoring User

/// User information for error reports.
/// Use anonymized IDs only - never include PII.
struct MonitoringUser: Sendable, Equatable {
    /// Anonymized user identifier (hash of real ID).
    let id: String

    /// Optional username (if user consents to sharing).
    let username: String?

    /// User segment (e.g., "free", "premium").
    let segment: String?

    init(id: String, username: String? = nil, segment: String? = nil) {
        self.id = id
        self.username = username
        self.segment = segment
    }
}

// MARK: - Central Access

/// Central access point for error monitoring.
///
/// Usage:
/// ```swift
/// // At app launch
/// ErrorMonitoring.shared.configure()
///
/// // Capture errors
/// ErrorMonitoring.shared.service.captureError(error)
/// ```
@MainActor
final class ErrorMonitoring {

    static let shared = ErrorMonitoring()

    /// The active error monitoring service.
    /// Change this to swap providers:
    /// - `SentryErrorMonitoring()` for Sentry
    /// - `CrashlyticsErrorMonitoring()` for Firebase
    /// - `NoOpErrorMonitoring()` for testing/privacy
    #if DEBUG
    let service: ErrorMonitoringService = NoOpErrorMonitoring()
    #else
    let service: ErrorMonitoringService = NoOpErrorMonitoring()
    // TODO: Replace with your provider:
    // let service: ErrorMonitoringService = SentryErrorMonitoring()
    #endif

    private init() {}

    /// Configure error monitoring. Call once at app launch.
    func configure() {
        service.configure()
    }
}

// MARK: - Environment Key

private struct ErrorMonitoringKey: EnvironmentKey {
    static let defaultValue: ErrorMonitoringService = NoOpErrorMonitoring()
}

extension EnvironmentValues {
    /// Error monitoring service for capturing errors.
    var errorMonitoring: ErrorMonitoringService {
        get { self[ErrorMonitoringKey.self] }
        set { self[ErrorMonitoringKey.self] = newValue }
    }
}

import Foundation

/// No-op implementation of ErrorMonitoringService.
///
/// Use this for:
/// - Debug/development builds
/// - Users who opt out of crash reporting
/// - Unit tests
/// - Privacy-focused mode
///
/// Usage:
/// ```swift
/// let service: ErrorMonitoringService = NoOpErrorMonitoring()
/// service.captureError(error)  // Does nothing
/// ```
final class NoOpErrorMonitoring: ErrorMonitoringService, Sendable {

    // MARK: - Configuration

    func configure() {
        // No-op
        #if DEBUG
        print("[ErrorMonitoring] NoOp mode - errors will not be reported")
        #endif
    }

    // MARK: - Error Capture

    func captureError(_ error: Error, context: ErrorContext?) {
        #if DEBUG
        print("[ErrorMonitoring] Would capture error: \(error)")
        if let context {
            if !context.tags.isEmpty {
                print("  Tags: \(context.tags)")
            }
        }
        #endif
    }

    func captureMessage(_ message: String, level: ErrorLevel) {
        #if DEBUG
        print("[ErrorMonitoring] Would capture \(level.rawValue): \(message)")
        #endif
    }

    // MARK: - Breadcrumbs

    func addBreadcrumb(_ breadcrumb: Breadcrumb) {
        #if DEBUG
        print("[ErrorMonitoring] Breadcrumb: [\(breadcrumb.category)] \(breadcrumb.message)")
        #endif
    }

    // MARK: - User

    func setUser(_ user: MonitoringUser?) {
        #if DEBUG
        if let user {
            print("[ErrorMonitoring] Would set user: \(user.id)")
        } else {
            print("[ErrorMonitoring] Would clear user")
        }
        #endif
    }

    func reset() {
        #if DEBUG
        print("[ErrorMonitoring] Would reset session")
        #endif
    }
}

// MARK: - Debug Error Monitoring

#if DEBUG
/// Debug implementation that prints all events to console.
///
/// Useful during development to verify error capture is working.
final class DebugErrorMonitoring: ErrorMonitoringService, Sendable {

    private let dateFormatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "HH:mm:ss.SSS"
        return formatter
    }()

    func configure() {
        print("🔧 [ErrorMonitoring] Debug mode configured")
    }

    func captureError(_ error: Error, context: ErrorContext?) {
        let timestamp = dateFormatter.string(from: .now)
        print("🔴 [\(timestamp)] ERROR: \(error)")
        print("   Type: \(type(of: error))")

        if let localizedError = error as? LocalizedError {
            if let description = localizedError.errorDescription {
                print("   Description: \(description)")
            }
            if let reason = localizedError.failureReason {
                print("   Reason: \(reason)")
            }
            if let recovery = localizedError.recoverySuggestion {
                print("   Recovery: \(recovery)")
            }
        }

        if let context {
            if !context.tags.isEmpty {
                print("   Tags: \(context.tags)")
            }
            if !context.extra.isEmpty {
                print("   Extra: \(context.extra)")
            }
        }
    }

    func captureMessage(_ message: String, level: ErrorLevel) {
        let timestamp = dateFormatter.string(from: .now)
        let emoji = switch level {
        case .debug: "🔍"
        case .info: "ℹ️"
        case .warning: "⚠️"
        case .error: "🔴"
        case .fatal: "💀"
        }
        print("\(emoji) [\(timestamp)] \(level.rawValue.uppercased()): \(message)")
    }

    func addBreadcrumb(_ breadcrumb: Breadcrumb) {
        let timestamp = dateFormatter.string(from: breadcrumb.timestamp)
        print("🍞 [\(timestamp)] [\(breadcrumb.category)] \(breadcrumb.message)")
        if let data = breadcrumb.data, !data.isEmpty {
            print("   Data: \(data)")
        }
    }

    func setUser(_ user: MonitoringUser?) {
        if let user {
            print("👤 Set user: id=\(user.id), segment=\(user.segment ?? "none")")
        } else {
            print("👤 Cleared user")
        }
    }

    func reset() {
        print("🔄 Session reset")
    }
}
#endif

import Foundation
// import Sentry  // Uncomment after adding Sentry SDK

/// Sentry implementation of ErrorMonitoringService.
///
/// Prerequisites:
/// 1. Add Sentry SDK to Package.swift:
///    `.package(url: "https://github.com/getsentry/sentry-cocoa", from: "8.0.0")`
/// 2. Get DSN from Sentry dashboard
/// 3. Uncomment the import and implementation below
///
/// Usage:
/// ```swift
/// let service: ErrorMonitoringService = SentryErrorMonitoring()
/// service.configure()  // Call at app launch
/// ```
final class SentryErrorMonitoring: ErrorMonitoringService, @unchecked Sendable {

    // MARK: - Configuration

    /// Your Sentry DSN from Project Settings > Client Keys
    private let dsn = "YOUR_SENTRY_DSN_HERE"

    /// Sample rate for error events (0.0 to 1.0)
    private let sampleRate: Float = 1.0

    /// Sample rate for performance traces (0.0 to 1.0)
    private let tracesSampleRate: Float = 0.1

    // MARK: - ErrorMonitoringService

    func configure() {
        // TODO: Uncomment after adding Sentry SDK
        /*
        SentrySDK.start { options in
            options.dsn = self.dsn
            options.sampleRate = NSNumber(value: self.sampleRate)
            options.tracesSampleRate = NSNumber(value: self.tracesSampleRate)

            // Enable automatic breadcrumbs
            options.enableAutoBreadcrumbTracking = true
            options.enableUIViewControllerTracing = true
            options.enableNetworkTracking = true

            // Set release version
            options.releaseName = self.releaseVersion

            // Debug mode (disable in production)
            #if DEBUG
            options.debug = true
            #endif

            // Set environment
            #if DEBUG
            options.environment = "development"
            #else
            options.environment = "production"
            #endif
        }
        */

        print("[Sentry] Would configure with DSN: \(dsn.prefix(20))...")
    }

    func captureError(_ error: Error, context: ErrorContext?) {
        // TODO: Uncomment after adding Sentry SDK
        /*
        SentrySDK.capture(error: error) { scope in
            if let context {
                // Add tags
                for (key, value) in context.tags {
                    scope.setTag(value: value, key: key)
                }

                // Add extra data
                for (key, value) in context.extra {
                    scope.setExtra(value: value, key: key)
                }

                // Set custom fingerprint
                if let fingerprint = context.fingerprint {
                    scope.setFingerprint(fingerprint)
                }
            }
        }
        */

        print("[Sentry] Would capture error: \(error)")
    }

    func captureMessage(_ message: String, level: ErrorLevel) {
        // TODO: Uncomment after adding Sentry SDK
        /*
        SentrySDK.capture(message: message) { scope in
            scope.setLevel(level.sentryLevel)
        }
        */

        print("[Sentry] Would capture \(level.rawValue): \(message)")
    }

    func addBreadcrumb(_ breadcrumb: Breadcrumb) {
        // TODO: Uncomment after adding Sentry SDK
        /*
        let sentryBreadcrumb = Sentry.Breadcrumb()
        sentryBreadcrumb.category = breadcrumb.category
        sentryBreadcrumb.message = breadcrumb.message
        sentryBreadcrumb.level = breadcrumb.level.sentryLevel
        sentryBreadcrumb.timestamp = breadcrumb.timestamp

        if let data = breadcrumb.data {
            sentryBreadcrumb.data = data
        }

        SentrySDK.addBreadcrumb(sentryBreadcrumb)
        */

        print("[Sentry] Would add breadcrumb: [\(breadcrumb.category)] \(breadcrumb.message)")
    }

    func setUser(_ user: MonitoringUser?) {
        // TODO: Uncomment after adding Sentry SDK
        /*
        if let user {
            let sentryUser = Sentry.User()
            sentryUser.userId = user.id
            sentryUser.username = user.username
            sentryUser.segment = user.segment
            SentrySDK.setUser(sentryUser)
        } else {
            SentrySDK.setUser(nil)
        }
        */

        if let user {
            print("[Sentry] Would set user: \(user.id)")
        } else {
            print("[Sentry] Would clear user")
        }
    }

    func reset() {
        // TODO: Uncomment after adding Sentry SDK
        /*
        SentrySDK.setUser(nil)
        SentrySDK.configureScope { scope in
            scope.clear()
        }
        */

        print("[Sentry] Would reset session")
    }

    // MARK: - Helpers

    private var releaseVersion: String {
        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
        let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "0"
        let bundleID = Bundle.main.bundleIdentifier ?? "unknown"
        return "\(bundleID)@\(version)+\(build)"
    }
}

// MARK: - Sentry Level Mapping

/*
// Uncomment after adding Sentry SDK
extension ErrorLevel {
    var sentryLevel: SentryLevel {
        switch self {
        case .debug: return .debug
        case .info: return .info
        case .warning: return .warning
        case .error: return .error
        case .fatal: return .fatal
        }
    }
}
*/