import Combine
import SwiftUI
import OSLog
import UniformTypeIdentifiers

// MARK: - AppEventLog
//
// Exportierbares In-Memory-Log für Support & Debugging.
// Ergänzt os.log – alle Einträge bleiben für die Laufzeit der App erhalten
// und können als Textdatei geteilt werden.
// Thread-sicher: record() dispatcht UI-Updates auf den Main Thread.

final class AppEventLog: ObservableObject {
    static let shared = AppEventLog()

    @Published private(set) var entries: [Entry] = []
    private let capacity = 500

    // MARK: - Entry

    struct Entry: Identifiable, Sendable {
        let id: UUID
        let timestamp: Date
        let level: Level
        let category: String
        let message: String

        init(level: Level, category: String, message: String) {
            self.id        = UUID()
            self.timestamp = Date()
            self.level     = level
            self.category  = category
            self.message   = message
        }

        enum Level: String, CaseIterable, Sendable {
            case info     = "INFO"
            case success  = "OK"
            case warning  = "WARN"
            case error    = "FEHLER"
            case critical = "KRITISCH"

            var emoji: String {
                switch self {
                case .info:     return "ℹ️"
                case .success:  return "✅"
                case .warning:  return "⚠️"
                case .error:    return "❌"
                case .critical: return "🚨"
                }
            }

            var color: Color {
                switch self {
                case .info:     return .secondary
                case .success:  return .green
                case .warning:  return .orange
                case .error:    return .red
                case .critical: return .red
                }
            }

            // Für Level-Filter: höherer Wert = höhere Priorität
            var priority: Int {
                switch self {
                case .info:     return 0
                case .success:  return 1
                case .warning:  return 2
                case .error:    return 3
                case .critical: return 4
                }
            }
        }

        var formattedTimestamp: String {
            NahbarLogDateFormatter.time.string(from: timestamp)
        }
    }

    // MARK: - Init

    private init() {
        // Ersten Eintrag ohne den Ring-Buffer-Overhead direkt schreiben
        entries.append(Entry(level: .info, category: "Lifecycle", message: "App gestartet"))
    }

    // MARK: - Public API

    /// Fügt einen Eintrag hinzu. Kann von jedem Thread aufgerufen werden.
    func record(_ message: String, level: Entry.Level = .info, category: String = "App") {
        let entry = Entry(level: level, category: category, message: message)
        DispatchQueue.main.async { [self] in
            if entries.count >= capacity { entries.removeFirst() }
            entries.append(entry)
        }
    }

    /// Gefilterte Einträge ab einem Mindest-Level.
    func entries(minLevel: Entry.Level) -> [Entry] {
        entries.filter { $0.level.priority >= minLevel.priority }
    }

    /// Exportiert alle Einträge als lesbaren Textstring.
    func exportText() -> String {
        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "?"
        let build   = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "?"
        let device  = UIDevice.current.model
        let sysVer  = UIDevice.current.systemVersion

        let header = """
        ═══════════════════════════════════════════════════════════
        nahbar App-Log
        Exportiert: \(NahbarLogDateFormatter.full.string(from: Date()))
        Version:    \(version) (\(build))
        Gerät:      \(device), iOS \(sysVer)
        Einträge:   \(entries.count)/\(capacity)
        ═══════════════════════════════════════════════════════════

        """

        let body = entries.map { e in
            "[\(e.formattedTimestamp)] \(e.level.emoji) [\(e.level.rawValue)] [\(e.category)] \(e.message)"
        }.joined(separator: "\n")

        return header + body
    }

    func clear() {
        entries.removeAll()
        record("Log geleert", level: .info, category: "Lifecycle")
    }
}

// MARK: - DateFormatters (Singletons für Performance)

private enum NahbarLogDateFormatter {
    static let time: DateFormatter = {
        let f = DateFormatter()
        f.locale = Locale(identifier: "de_DE")
        f.dateFormat = "HH:mm:ss"
        return f
    }()

    static let full: DateFormatter = {
        let f = DateFormatter()
        f.locale = Locale(identifier: "de_DE")
        f.dateStyle = .medium
        f.timeStyle = .medium
        return f
    }()
}

// MARK: - Sharesheet Item

/// Wrapper für den ShareLink / UIActivityViewController Export.
struct LogExportDocument: Transferable {
    let text: String

    static var transferRepresentation: some TransferRepresentation {
        DataRepresentation(exportedContentType: .plainText) { doc in
            Data(doc.text.utf8)
        }
    }
}
