dependencies: [
    .package(url: "https://github.com/melonamin/SwiftKEF.git", from: "1.1.0")
]

import SwiftKEF
import AsyncHTTPClient

// Create HTTP client
let httpClient = HTTPClient(eventLoopGroupProvider: .singleton)
defer {
    try await httpClient.shutdown()
}

// Initialize speaker with known IP
let speaker = KEFSpeaker(host: "192.168.1.100", httpClient: httpClient)

// Discover speakers on the network
let speakers = try await KEFSpeaker.discover(httpClient: httpClient, timeout: 5.0)
for discovered in speakers {
    print("Found: \(discovered.name) at \(discovered.host)")
    
    // Create speaker instance from discovery
    let speaker = KEFSpeaker.from(discovered: discovered, httpClient: httpClient)
}

// Or use real-time discovery stream
for await discovered in KEFSpeaker.discoverStream(httpClient: httpClient) {
    print("Discovered: \(discovered.name) at \(discovered.host)")
    
    // Optional: Check model and MAC address
    if let model = discovered.model {
        print("Model: \(model)")
    }
}

// Set volume (0-100)
try await speaker.setVolume(50)

// Get current volume
let volume = try await speaker.getVolume()
print("Current volume: \(volume)")

// Mute
try await speaker.mute()

// Unmute
try await speaker.unmute()

// Turn on
try await speaker.powerOn()

// Turn off (standby)
try await speaker.shutdown()

// Check power status
let status = try await speaker.getStatus()
if status == .powerOn {
    print("Speaker is on")
}

// Set input source
try await speaker.setSource(.bluetooth)
try await speaker.setSource(.optic)

// Get current source
let source = try await speaker.getSource()
print("Current source: \(source.rawValue)")

// Available sources
for source in KEFSource.allCases {
    print(source.rawValue)
}

// Toggle play/pause
try await speaker.togglePlayPause()

// Next track
try await speaker.nextTrack()

// Previous track
try await speaker.previousTrack()

// Check if playing
let isPlaying = try await speaker.isPlaying()

// Get track information
if isPlaying {
    let songInfo = try await speaker.getSongInformation()
    print("Now playing: \(songInfo.title ?? "Unknown")")
    print("Artist: \(songInfo.artist ?? "Unknown")")
    print("Album: \(songInfo.album ?? "Unknown")")
    
    // Get active music quality information (when available)
    // This is parsed from `trackRoles.mediaData.activeResource`
    let quality = try await speaker.getSongQuality()
    if quality.codec != nil || quality.bitRate != nil {
        print("Codec: \(quality.codec ?? "Unknown")")
        if let bitRate = quality.bitRate {
            print("Bitrate: \(Int(Double(bitRate) / 1000)) kbps")
        }
        if let sampleFrequency = quality.sampleFrequency, let bitsPerSample = quality.bitsPerSample {
            print("Format: \(bitsPerSample)-bit / \(sampleFrequency) Hz")
        }
        if let channels = quality.nrAudioChannels {
            print("Channels: \(channels)")
        }
    }

    // Get playback position
    if let position = try await speaker.getSongPosition(),
       let duration = try await speaker.getSongDuration() {
        let progress = Double(position) / Double(duration)
        print("Progress: \(Int(progress * 100))%")
    }
}

let quality = try await speaker.getSongQuality()

print("Codec: \(quality.codec ?? "Unknown")")
print("Bitrate: \(quality.bitRate.map { "\($0) bps" } ?? "Unknown")")
print("Sample frequency: \(quality.sampleFrequency.map(String.init) ?? "Unknown")")
print("Bits per sample: \(quality.bitsPerSample.map(String.init) ?? "Unknown")")
print("Channels: \(quality.nrAudioChannels.map(String.init) ?? "Unknown")")

// Get speaker name
let name = try await speaker.getSpeakerName()

// Get MAC address
let mac = try await speaker.getMacAddress()

// Get firmware info
let firmware = try await speaker.getFirmwareVersion()
print("Model: \(firmware.model)")
print("Version: \(firmware.version)")

do {
    try await speaker.setVolume(75)
} catch KEFError.networkError(let message) {
    print("Network error: \(message)")
} catch KEFError.speakerNotResponding {
    print("Speaker is not responding")
} catch {
    print("Error: \(error)")
}

// Single poll for current events
let event = try await speaker.pollSpeaker(timeout: 10)
if let volume = event.volume {
    print("Volume changed to: \(volume)")
}

// Continuous polling stream
let eventStream = await speaker.startPolling(
    pollInterval: 10,      // Check for events every 10 seconds
    pollSongStatus: true   // Include real-time song position updates
)

for try await event in eventStream {
    // Handle volume changes
    if let volume = event.volume {
        print("Volume: \(volume)")
    }
    
    // Handle source changes
    if let source = event.source {
        print("Source: \(source.rawValue)")
    }
    
    // Handle playback updates
    if let state = event.playbackState {
        print("Playback: \(state.rawValue)")
    }
    
    // Track position updates (when pollSongStatus is true)
    if let position = event.songPosition,
       let duration = event.songDuration {
        let progress = Double(position) / Double(duration)
        print("Progress: \(Int(progress * 100))%")
    }
}

import SwiftUI
import SwiftKEF
import AsyncHTTPClient

struct ContentView: View {
    @State private var volume: Int = 0
    @State private var isPlaying = false

    let speaker: KEFSpeaker

    var body: some View {
        VStack {
            Text("Volume: \(volume)")

            Slider(value: Binding(
                get: { Double(volume) },
                set: { newValue in
                    Task {
                        try await speaker.setVolume(Int(newValue))
                    }
                }
            ), in: 0...100)

            Button(isPlaying ? "Pause" : "Play") {
                Task {
                    try await speaker.togglePlayPause()
                    isPlaying.toggle()
                }
            }
        }
        .task {
            volume = try await speaker.getVolume()
            isPlaying = try await speaker.isPlaying()
        }
    }
}