import AVKit
import NitroModules
import UIKit

/**
 * HybridAirPlayButton — A Nitro HybridView wrapping AVRoutePickerView.
 *
 * Renders the system AirPlay route picker on iOS. Tapping shows the
 * system sheet for selecting AirPlay devices (Apple TV, HomePod, etc.).
 *
 * Supports tintColor and activeTintColor via CSS hex color strings.
 */
class HybridAirPlayButton: HybridAirPlayButtonSpec, RecyclableView {
    // MARK: - HybridView

    let view: UIView
    private let routePicker: AVRoutePickerView

    // MARK: - Props

    private var _tintColor: String = ""
    var tintColor: String {
        get { _tintColor }
        set {
            _tintColor = newValue
            DispatchQueue.main.async { [weak self] in
                guard let self else { return }
                if let color = UIColor(cssString: newValue) {
                    routePicker.tintColor = color
                }
            }
        }
    }

    private var _activeTintColor: String = ""
    var activeTintColor: String {
        get { _activeTintColor }
        set {
            _activeTintColor = newValue
            DispatchQueue.main.async { [weak self] in
                guard let self else { return }
                if let color = UIColor(cssString: newValue) {
                    routePicker.activeTintColor = color
                }
            }
        }
    }

    // MARK: - Init

    override init() {
        let picker = AVRoutePickerView()
        picker.prioritizesVideoDevices = true
        routePicker = picker
        view = picker
        super.init()
    }

    // MARK: - RecyclableView

    /// Reset the button to a pristine state so Fabric can reuse it for a
    /// different logical instance without stale tint colors bleeding across.
    func prepareForRecycle() {
        _tintColor = ""
        _activeTintColor = ""
        DispatchQueue.main.async { [weak self] in
            guard let self else { return }
            routePicker.tintColor = nil
            routePicker.activeTintColor = nil
        }
    }
}

// MARK: - UIColor CSS hex string extension

extension UIColor {
    /**
     * Parse a CSS hex color string (#RGB, #RRGGBB, or #RRGGBBAA).
     * Returns nil for invalid or empty strings.
     */
    convenience init?(cssString: String) {
        let hex = cssString.trimmingCharacters(in: .whitespacesAndNewlines)
        guard hex.hasPrefix("#") else { return nil }

        let chars = Array(hex.dropFirst())
        let r, g, b, a: CGFloat

        switch chars.count {
        case 3: // #RGB
            guard let rv = Self.hexVal(chars[0]),
                  let gv = Self.hexVal(chars[1]),
                  let bv = Self.hexVal(chars[2])
            else { return nil }
            r = CGFloat(rv * 17) / 255.0
            g = CGFloat(gv * 17) / 255.0
            b = CGFloat(bv * 17) / 255.0
            a = 1.0

        case 6: // #RRGGBB
            guard let rv = Self.hexByte(chars[0], chars[1]),
                  let gv = Self.hexByte(chars[2], chars[3]),
                  let bv = Self.hexByte(chars[4], chars[5])
            else { return nil }
            r = CGFloat(rv) / 255.0
            g = CGFloat(gv) / 255.0
            b = CGFloat(bv) / 255.0
            a = 1.0

        case 8: // #RRGGBBAA
            guard let rv = Self.hexByte(chars[0], chars[1]),
                  let gv = Self.hexByte(chars[2], chars[3]),
                  let bv = Self.hexByte(chars[4], chars[5]),
                  let av = Self.hexByte(chars[6], chars[7])
            else { return nil }
            r = CGFloat(rv) / 255.0
            g = CGFloat(gv) / 255.0
            b = CGFloat(bv) / 255.0
            a = CGFloat(av) / 255.0

        default:
            return nil
        }

        self.init(red: r, green: g, blue: b, alpha: a)
    }

    private static func hexVal(_ c: Character) -> Int? {
        Int(String(c), radix: 16)
    }

    private static func hexByte(_ h: Character, _ l: Character) -> Int? {
        guard let hi = hexVal(h), let lo = hexVal(l) else { return nil }
        return hi * 16 + lo
    }
}