public class FontInspector {
    public static let shared = FontInspector()
    
    public func inspectFonts(in view: UIView) -> FontReport
    public func previewDynamicType(_ size: UIContentSizeCategory)
    public func exportTypography(_ report: FontReport, format: ExportFormat) -> String
}

struct FontReport {
    let fonts: [FontUsage]
    let issues: [TypographyIssue]
    let statistics: TypographyStatistics
}

struct FontUsage: Identifiable {
    let id: UUID
    let fontName: String
    let family: String
    let weight: UIFont.Weight
    let size: CGFloat
    let isCustomFont: Bool
    let occurrences: Int
    let locations: [FontLocation]
    let supportsDynamicType: Bool
}

struct FontLocation {
    let view: UIView
    let text: String?
    let textStyle: UIFont.TextStyle?
}

struct TypographyIssue {
    enum IssueType {
        case inconsistentSizes
        case noDynamicType
        case smallFont
        case customFontNotLoaded
        case tooManyFonts
    }
    
    let type: IssueType
    let description: String
    let affectedElements: [UIView]
    let suggestion: String
}

func inspectFonts(in view: UIView) -> FontReport {
    var fontMap: [String: FontUsage] = [:]
    
    func traverse(_ view: UIView) {
        var font: UIFont?
        var textStyle: UIFont.TextStyle?
        var text: String?
        var supportsDynamicType = false
        
        // Extract font from different view types
        if let label = view as? UILabel {
            font = label.font
            text = label.text
            supportsDynamicType = label.adjustsFontForContentSizeCategory
        } else if let textView = view as? UITextView {
            font = textView.font
            text = textView.text
            supportsDynamicType = textView.adjustsFontForContentSizeCategory
        } else if let textField = view as? UITextField {
            font = textField.font
            text = textField.text
            supportsDynamicType = textField.adjustsFontForContentSizeCategory
        } else if let button = view as? UIButton {
            font = button.titleLabel?.font
            text = button.title(for: .normal)
            supportsDynamicType = button.titleLabel?.adjustsFontForContentSizeCategory ?? false
        }
        
        if let font = font {
            recordFont(
                font,
                view: view,
                text: text,
                textStyle: textStyle,
                supportsDynamicType: supportsDynamicType,
                in: &fontMap
            )
        }
        
        view.subviews.forEach { traverse($0) }
    }
    
    traverse(view)
    
    let fonts = Array(fontMap.values).sorted { $0.occurrences > $1.occurrences }
    let issues = analyzeTypography(fonts)
    let statistics = calculateStatistics(fonts)
    
    return FontReport(fonts: fonts, issues: issues, statistics: statistics)
}

func recordFont(
    _ font: UIFont,
    view: UIView,
    text: String?,
    textStyle: UIFont.TextStyle?,
    supportsDynamicType: Bool,
    in fontMap: inout [String: FontUsage]
) {
    let key = "\(font.fontName)-\(font.pointSize)"
    
    if var existing = fontMap[key] {
        existing.occurrences += 1
        existing.locations.append(FontLocation(
            view: view,
            text: text,
            textStyle: textStyle
        ))
        fontMap[key] = existing
    } else {
        let isCustom = !font.familyName.hasPrefix(".")
        
        fontMap[key] = FontUsage(
            id: UUID(),
            fontName: font.fontName,
            family: font.familyName,
            weight: getFontWeight(font),
            size: font.pointSize,
            isCustomFont: isCustom,
            occurrences: 1,
            locations: [FontLocation(
                view: view,
                text: text,
                textStyle: textStyle
            )],
            supportsDynamicType: supportsDynamicType
        )
    }
}

func getFontWeight(_ font: UIFont) -> UIFont.Weight {
    let traits = font.fontDescriptor.object(forKey: .traits) as? [UIFontDescriptor.TraitKey: Any]
    let weight = traits?[.weight] as? CGFloat ?? 0
    
    switch weight {
    case ...(-0.8): return .ultraLight
    case -0.6..< -0.4: return .thin
    case -0.4..< -0.2: return .light
    case -0.2..<0.0: return .regular
    case 0.0..<0.23: return .medium
    case 0.23..<0.3: return .semibold
    case 0.3..<0.4: return .bold
    case 0.4..<0.56: return .heavy
    default: return .black
    }
}

func analyzeTypography(_ fonts: [FontUsage]) -> [TypographyIssue] {
    var issues: [TypographyIssue] = []
    
    // Check for inconsistent sizes
    let sizes = fonts.map { $0.size }
    let similarSizes = findSimilarSizes(sizes)
    if !similarSizes.isEmpty {
        issues.append(TypographyIssue(
            type: .inconsistentSizes,
            description: "Similar font sizes found: \(similarSizes)",
            affectedElements: [],
            suggestion: "Consider unifying to standard text styles"
        ))
    }
    
    // Check Dynamic Type support
    let noDynamicType = fonts.filter { !$0.supportsDynamicType }
    if !noDynamicType.isEmpty {
        let elements = noDynamicType.flatMap { $0.locations.map { $0.view } }
        issues.append(TypographyIssue(
            type: .noDynamicType,
            description: "\(elements.count) text elements don't support Dynamic Type",
            affectedElements: elements,
            suggestion: "Enable adjustsFontForContentSizeCategory"
        ))
    }
    
    // Check for small fonts
    let minSize: CGFloat = 11.0
    let smallFonts = fonts.filter { $0.size < minSize }
    if !smallFonts.isEmpty {
        let elements = smallFonts.flatMap { $0.locations.map { $0.view } }
        issues.append(TypographyIssue(
            type: .smallFont,
            description: "Font sizes below recommended minimum (\(minSize)pt)",
            affectedElements: elements,
            suggestion: "Increase font size for better readability"
        ))
    }
    
    // Check custom font loading
    let customFonts = fonts.filter { $0.isCustomFont }
    for customFont in customFonts {
        if UIFont(name: customFont.fontName, size: 12) == nil {
            issues.append(TypographyIssue(
                type: .customFontNotLoaded,
                description: "Custom font '\(customFont.fontName)' may not be loaded",
                affectedElements: customFont.locations.map { $0.view },
                suggestion: "Verify font is included in app bundle and Info.plist"
            ))
        }
    }
    
    return issues
}

func findSimilarSizes(_ sizes: [CGFloat]) -> [CGFloat] {
    var similar: [CGFloat] = []
    let threshold: CGFloat = 2.0
    
    for i in 0..<sizes.count {
        for j in (i+1)..<sizes.count {
            if abs(sizes[i] - sizes[j]) <= threshold && abs(sizes[i] - sizes[j]) > 0 {
                if !similar.contains(sizes[i]) { similar.append(sizes[i]) }
                if !similar.contains(sizes[j]) { similar.append(sizes[j]) }
            }
        }
    }
    
    return similar.sorted()
}

func previewDynamicType(_ size: UIContentSizeCategory) {
    let originalCategory = UIApplication.shared.preferredContentSizeCategory
    
    // Temporarily change content size
    UIApplication.shared.setValue(size, forKey: "preferredContentSizeCategory")
    
    // Force update
    NotificationCenter.default.post(
        name: UIContentSizeCategory.didChangeNotification,
        object: nil
    )
    
    // Restore after delay (for preview)
    DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
        UIApplication.shared.setValue(originalCategory, forKey: "preferredContentSizeCategory")
        NotificationCenter.default.post(
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
}

func exportAsSwift(_ report: FontReport) -> String {
    var code = "import UIKit\n\nextension UIFont {\n"
    
    for font in report.fonts.prefix(10) {
        let methodName = generateMethodName(for: font)
        
        if font.isCustomFont {
            code += """
                
                static func \(methodName)() -> UIFont {
                    return UIFont(name: "\(font.fontName)", size: \(font.size)) ?? .systemFont(ofSize: \(font.size))
                }
            """
        } else {
            code += """
                
                static func \(methodName)() -> UIFont {
                    return .systemFont(ofSize: \(font.size), weight: .\(font.weight))
                }
            """
        }
    }
    
    code += "\n}\n"
    return code
}

func exportAsCSS(_ report: FontReport) -> String {
    var css = ":root {\n"
    
    for (index, font) in report.fonts.prefix(10).enumerated() {
        let name = "font-\(index + 1)"
        let weight = Int(fontWeightToCSS(font.weight))
        
        css += "  --\(name): \(weight) \(font.size)px '\(font.family)';\n"
    }
    
    css += "}\n"
    return css
}

### Font Inspector
- Extract all fonts from current screen
- Identify custom vs system fonts
- Check Dynamic Type support
- Analyze typography consistency
- Export typography tokens

// Inspect fonts
let report = DebugSwift.FontInspector.inspect(view)

// Preview Dynamic Type
DebugSwift.FontInspector.previewDynamicType(.extraLarge)

// Export
let code = report.export(as: .swift)