// v2.x (still works with deprecation warnings)
RichText(html: htmlContent)
    .foregroundColor(light: .black, dark: .white)
    .backgroundColor("transparent")
    .loadingPlaceholder("Loading...")

// v3.0.0 (recommended modern approach)
RichText(html: htmlContent)
    .textColor(light: .primary, dark: .secondary)
    .backgroundColor(.transparent)
    .placeholder {
        VStack {
            ProgressView()
            Text("Loading...")
        }
    }

RichText(html: htmlContent)
    // Type-safe enum options
    .backgroundColor(.transparent)
    .backgroundColor(.system)
    .backgroundColor(.hex("FF0000"))
    .backgroundColor(.color(.blue))
    
    // Convenience methods
    .backgroundColorHex("FF0000")
    .backgroundColorSwiftUI(.blue)
    .transparentBackground()

RichText(html: htmlWithImages)
    .onMediaClick { media in
        switch media {
        case .image(let src):
            print("Image clicked: \(src)")
            // Handle image click (e.g., show full screen)
        case .video(let src):
            print("Video clicked: \(src)")
            // Handle video click (e.g., open player)
        }
    }

RichText(html: htmlContent)
    .onError { error in
        switch error {
        case .htmlLoadingFailed(let html):
            print("Failed to load HTML: \(html)")
        case .webViewConfigurationFailed:
            print("WebView configuration error")
        case .cssGenerationFailed:
            print("CSS generation error")
        case .mediaHandlingFailed(let media):
            print("Media handling error: \(media)")
        }
    }

RichText(html: htmlContent)
    .placeholder {
        VStack(spacing: 16) {
            ProgressView()
                .scaleEffect(1.2)
            
            Text("Loading Rich Content...")
                .font(.headline)
                .foregroundColor(.secondary)
            
            Text("Please wait while we render your content")
                .font(.caption)
                .foregroundColor(.tertiary)
                .multilineTextAlignment(.center)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(12)
    }

RichText(html: htmlContent)
    .loadingTransition(.fade)           // Fade transition
    .loadingTransition(.slide)          // Slide transition
    .loadingTransition(.scale)          // Scale transition
    .loadingTransition(.custom(.spring(response: 0.6, dampingFraction: 0.8)))

let advancedConfig = Configuration(
    customCSS: """
    body { 
        font-family: 'SF Pro Display', system-ui; 
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    }
    """,
    supportsDynamicType: true,
    fontType: .customName("SF Pro Display"),
    fontColor: ColorSet(light: "1a1a1a", dark: "f5f5f5"),
    lineHeight: 180,
    colorScheme: .auto,
    forceColorSchemeBackground: true,
    backgroundColor: .color(.clear),
    imageRadius: 12,
    linkOpenType: .Safari,
    linkColor: ColorSet(light: "0066cc", dark: "3399ff", isImportant: true),
    isColorsImportant: .all,
    transition: .easeInOut(duration: 0.4)
)

RichText(html: complexHtml, configuration: advancedConfig)
    .textColor(light: .primary, dark: .secondary)
    .linkColor(light: .blue, dark: .cyan)
    .imageRadius(16)
    .onMediaClick { media in /* handle clicks */ }
    .onError { error in /* handle errors */ }
    .placeholder {
        CustomLoadingView()
    }

extension WebView.Coordinator {
    @MainActor
    private func handleScriptMessage(_ message: WKScriptMessage) async {
        switch message.name {
        case RichTextConstants.heightNotificationHandler:
            await handleHeightUpdate(message.body)
        case RichTextConstants.mediaClickHandler:
            await handleMediaClick(message.body)
        default:
            webViewLogger.warning("Unknown script message: \(message.name)")
        }
    }
    
    @MainActor
    private func handleHeightUpdate(_ body: Any) async {
        guard let height = body as? NSNumber else {
            webViewLogger.error("Invalid height value received")
            return
        }
        
        let cgFloatHeight = CGFloat(height.doubleValue)
        guard cgFloatHeight != self.parent.dynamicHeight else { return }
        
        withAnimation(self.parent.conf.transition) {
            self.parent.dynamicHeight = cgFloatHeight
        }
        
        webViewLogger.debug("Height updated to: \(cgFloatHeight)")
    }
}

extension ColorSet: Equatable {
    public static func == (lhs: ColorSet, rhs: ColorSet) -> Bool {
        return lhs.light.lowercased() == rhs.light.lowercased() &&
               lhs.dark.lowercased() == rhs.dark.lowercased() &&
               lhs.isImportant == rhs.isImportant
    }
    
    public var isValid: Bool {
        return isValidHexColor(light) && isValidHexColor(dark)
    }
    
    private func isValidHexColor(_ hex: String) -> Bool {
        let cleanHex = hex.hasPrefix("#") ? String(hex.dropFirst()) : hex
        let hexPattern = "^[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$"
        return NSPredicate(format: "SELF MATCHES %@", hexPattern).evaluate(with: cleanHex)
    }
}

public struct Configuration {
    // Enhanced background color with enum support
    public var backgroundColor: BackgroundColor
    
    public func generateCompleteCSS(
        colorScheme: RichTextColorScheme? = nil, 
        alignment: TextAlignment = .leading
    ) -> String {
        let scheme = colorScheme ?? self.colorScheme
        
        switch scheme {
        case .light:
            return css(isLight: true, alignment: alignment) + "\n" + customCSS
        case .dark:
            return css(isLight: false, alignment: alignment) + "\n" + customCSS
        case .auto:
            return """
            @media (prefers-color-scheme: light) {
                \(css(isLight: true, alignment: alignment))
            }
            @media (prefers-color-scheme: dark) {
                \(css(isLight: false, alignment: alignment))
            }
            \(customCSS)
            """
        }
    }
}

@Suite("RichText All Tests")
struct RichTextAllTests {
    
    @Suite("Configuration Tests")
    struct ConfigurationTests {
        
        @Test("Configuration defaults are correct")
        func configurationDefaults() {
            let config = Configuration()
            
            #expect(config.customCSS == "")
            #expect(config.supportsDynamicType == false)
            #expect(config.lineHeight == RichTextConstants.defaultLineHeight)
            #expect(config.imageRadius == RichTextConstants.defaultImageRadius)
            #expect(config.backgroundColor == .transparent)
        }
        
        @Test("CSS Generation produces valid output", arguments: [
            (true, TextAlignment.leading, "text-align:left"),
            (false, TextAlignment.center, "text-align:center"),
            (true, TextAlignment.trailing, "text-align:right")
        ])
        func cssGeneration(isLight: Bool, alignment: TextAlignment, expectedAlignment: String) {
            let config = Configuration(lineHeight: 150, imageRadius: 5)
            let css = config.css(isLight: isLight, alignment: alignment)
            
            #expect(css.contains("border-radius: 5.0px"))
            #expect(css.contains("line-height: 150.0%"))
            #expect(css.contains(expectedAlignment))
        }
    }
    
    @Suite("Async/Await Modernization Tests")
    struct AsyncAwaitTests {
        
        @Test("WebView async operations work correctly")
        func webViewAsyncOperations() async {
            let html = "<p>Test HTML content</p>"
            let config = Configuration()
            
            #expect(config.errorHandler == nil)
            #expect(config.transition == nil)
            
            let richText = RichText(html: html, configuration: config)
            #expect(richText.html == html)
        }
    }
    
    @Suite("New Features Tests (v3.0.0)")
    struct NewFeaturesTests {
        
        @Test("Background color customization with enum types")
        func backgroundColorCustomization() {
            let transparentBg = RichText(html: "<p>Test</p>")
                .transparentBackground()
            
            switch transparentBg.configuration.backgroundColor {
            case .transparent:
                #expect(true)
            default:
                #expect(Bool(false), "Background should be transparent")
            }
            
            let hexBg = RichText(html: "<p>Test</p>")
                .backgroundColorHex("FF0000")
            
            switch hexBg.configuration.backgroundColor {
            case .hex(let hex):
                #expect(hex == "FF0000")
            default:
                #expect(Bool(false), "Background should be hex FF0000")
            }
        }
        
        @Test("Media click handling functionality")
        func mediaClickHandling() {
            var clickedMedia: MediaClickType?
            
            let richText = RichText(html: "<img src='test.jpg'>")
                .onMediaClick { media in
                    clickedMedia = media
                }
            
            #expect(richText.configuration.mediaClickHandler != nil)
            
            if let handler = richText.configuration.mediaClickHandler {
                handler(.image(src: "test.jpg"))
            }
            
            switch clickedMedia {
            case .image(let src):
                #expect(src == "test.jpg")
            default:
                #expect(Bool(false), "Media click handler should work correctly")
            }
        }
    }
}