val discovery = NetworkDiscovery()

discovery.discover().collect { device ->
    println("${device.name} — ${device.address}:${device.port}")
}

discovery.close()

// build.gradle.kts (your KMP module)
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.waclabs:wac-discovery:0.2.2")
        }
    }
}

data class DiscoveredDevice(
    val name: String,                      // e.g. "Samsung-Linux/4.1, UPnP/1.0"
    val address: String,                   // e.g. "192.168.50.190"
    val port: Int,                         // e.g. 9197
    val protocol: DiscoveryProtocol,       // SSDP or MDNS
    val properties: Map<String, String>,   // parsed headers / TXT records
    val rawData: String,                   // full raw response for custom parsing
    val deviceInfo: DeviceInfo?,           // rich info (null until resolved)
)

discovery.discover(
    DiscoveryConfig(
        protocols = setOf(DiscoveryProtocol.SSDP, DiscoveryProtocol.MDNS),
        timeout = 10.seconds,
    )
)

discovery.discover(
    DiscoveryConfig(
        resolveDeviceInfo = true,           // fetch UPnP device description
        resolveTimeout = 3.seconds,         // HTTP timeout per device (default: 5s)
    )
).collect { device ->
    device.deviceInfo?.let { info ->
        println("📺 ${info.friendlyName}")       // "Living Room TV"
        println("🏭 ${info.manufacturer}")        // "Samsung Electronics"
        println("📱 ${info.modelName}")            // "UN55TU7000"
        println("🔑 ${info.serialNumber}")         // "ABC123XYZ"
        println("🖼️  ${info.iconUrl}")              // "http://192.168.50.190:9197/icon_LRG.png"
    }
}

discovery.discover().collect { device ->
    // Only resolve devices you care about
    if ("samsung" in device.name.lowercase()) {
        val resolved = device.resolveDeviceInfo(timeoutMs = 3000)
        println(resolved.deviceInfo?.friendlyName)
    }
}

// Samsung TVs only
discovery.discover(
    DiscoveryConfig(filter = DeviceFilters.SAMSUNG_TV)
).collect { println(it.name) }

// Smart TVs that are NOT LG
val filter = DeviceFilters.SMART_TV and !DeviceFilters.LG
discovery.discover(DiscoveryConfig(filter = filter))

// Samsung OR Sony
val filter = DeviceFilters.SAMSUNG or DeviceFilters.SONY
discovery.discover(DiscoveryConfig(filter = filter))

// Match by keyword (case-insensitive, searches name + address + properties)
val filter = DeviceFilter.byKeyword("my-custom-brand", "variant-2")

// Simple string match
val filter = DeviceFilter.byString("obscure-device-v3")

val filter = DeviceFilter.custom { device ->
    device.port == 8080 && device.address.startsWith("192.168.1.")
}

// Match by SSDP search target
DeviceFilter.bySearchTarget("urn:schemas-upnp-org:device:MediaRenderer:1")

// Match by IP pattern
DeviceFilter.byAddress(Regex("192\\.168\\.50\\..*"))

discovery.discover(
    DiscoveryConfig(
        protocols = setOf(DiscoveryProtocol.SSDP, DiscoveryProtocol.MDNS),
        timeout = 15.seconds,              // discovery duration
        resolveDeviceInfo = true,           // fetch UPnP descriptions
        resolveTimeout = 3.seconds,         // HTTP timeout per device
        ssdpSearchTarget = SsdpSearchTargets.ROOT_DEVICE,
        ssdpMx = 5,
    )
)

discovery.discover(
    DiscoveryConfig(
        protocols = setOf(DiscoveryProtocol.SSDP),
        timeout = 15.seconds,
        ssdpSearchTarget = SsdpSearchTargets.ROOT_DEVICE,
        ssdpMx = 5,
    )
)

discovery.discover(
    DiscoveryConfig(
        protocols = setOf(DiscoveryProtocol.MDNS),
        timeout = 12.seconds,
        mdnsServiceTypes = listOf(
            MdnsServiceTypes.SAMSUNG_SMART_VIEW,
            MdnsServiceTypes.GOOGLE_CAST,
            MdnsServiceTypes.APPLE_AIRPLAY,
        ),
    )
)

class DevicesViewModel : ViewModel() {
    private val discovery = NetworkDiscovery()

    val devices = discovery.discover(
        DiscoveryConfig(resolveDeviceInfo = true)
    )
        .scan(emptyList<DiscoveredDevice>()) { acc, device -> acc + device }
        .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())

    override fun onCleared() {
        discovery.close()
    }
}

discovery.discover().collect { device ->
    // Parse the raw SSDP response yourself
    val raw = device.rawData
    val customField = raw.lines()
        .find { it.startsWith("X-CUSTOM-HEADER:") }
        ?.substringAfter(":")?.trim()
}

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        MdnsContextHolder.init(applicationContext)
    }
}

val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
val lock = wifiManager.createMulticastLock("discovery").apply {
    setReferenceCounted(true)
    acquire()
}
// ... run discovery ...
lock.release()