// build.gradle.kts (commonMain)
dependencies {
    // Photo — camera capture and gallery image picking
    implementation("io.github.ismoy:imagepickerkmp:1.1.0")

    // Video — video recording and gallery video picking
    implementation("io.github.ismoy:imagepickerkmp-video:1.1.0") // SOON

    // Audio — audio recording
    implementation("io.github.ismoy:imagepickerkmp-audio:1.1.0") // SOON

    // Audio Player — voice message and audio file playback
    implementation("io.github.ismoy:imagepickerkmp-audioplayer:1.1.0") // SOON

    // Scanner — live barcode and QR code scanning
    implementation("io.github.ismoy:imagepickerkmp-scanner:1.1.0") // SOON

    // Video Player — full-featured video playback
    implementation("io.github.ismoy:imagepickerkmp-videoplayer:1.1.0") // SOON
}

@Composable
fun PhotoScreen() {
    val picker = rememberImagePickerKMP(
        config = ImagePickerKMPConfig(
            galleryConfig = GalleryConfig(allowMultiple = true, selectionLimit = 10),
            cropConfig    = CropConfig(enabled = true)
        )
    )

    Button(onClick = { picker.launchCamera() }) { Text("Camera") }
    Button(onClick = { picker.launchGallery() }) { Text("Gallery") }

    when (val result = picker.result) {
        is ImagePickerResult.Success   -> result.photos.forEach { photo ->
            Image(painter = photo.loadPainter(), contentDescription = null)
        }
        is ImagePickerResult.Loading   -> CircularProgressIndicator()
        is ImagePickerResult.Error     -> Text("Error: ${result.exception.message}")
        is ImagePickerResult.Dismissed -> Unit
        is ImagePickerResult.Idle      -> Unit
    }
}

@Composable
fun VideoScreen() {
    val picker = rememberVideoPicker(
        config = VideoPickerConfig(
            audio = AudioConfig.Default,
            output = VideoOutputConfig(
                format = VideoOutputFormat.MP4,
                removeMetadata = false
            ),
            allowedMimeTypes = listOf(VideoMimeType.All)
        )
    )

    Button(onClick = { picker.launchCamera() })  { Text("Record") }
    Button(onClick = { picker.launchGallery() }) { Text("Pick Video") }

    when (val result = picker.result) {
        is VideoPickerState.Success -> Text("Duration: ${result.video.durationMs}ms")
        is VideoPickerState.Error   -> Text("Error: ${result.cause}")
        else -> Unit
    }
}

@Composable
fun ChatInputBar() {
    AudioRecorder(
        config   = AudioRecorderConfig(),
        onResult = { audioResult: AudioResult? ->
            if (audioResult != null) {
                println("Recorded: ${audioResult.uri}, ${audioResult.durationMs}ms")
            }
        }
    )
}

@Composable
fun AudioScreen() {
    val picker = rememberAudioPicker()

    Button(onClick = { picker.launchRecorder() }) { Text("Record") }
    Button(onClick = { picker.launchGallery() })  { Text("Pick Audio") }

    when (val state = picker.result) {
        is AudioPickerState.Success -> Text("Saved: ${state.audio.fileName}")
        else -> Unit
    }
}

@Composable
fun CustomPlayerScreen(audioUri: String) {
    val playerManager = rememberAudioPlayerManager()
    val state by playerManager.playbackState.collectAsState()

    LaunchedEffect(audioUri) { playerManager.prepare(audioUri) }

    LinearProgressIndicator(
        progress = {
            if (state.durationMs > 0) state.currentPositionMs.toFloat() / state.durationMs else 0f
        }
    )

    FloatingActionButton(
        onClick = {
            if (state.isPlaying) playerManager.pause()
            else playerManager.play(audioUri)
        }
    ) {
        Icon(
            imageVector = if (state.isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow,
            contentDescription = null
        )
    }
}

@Composable
fun ScannerScreen() {
    val scanner = rememberScannerPicker(
        config = ScannerPickerConfig(
            camera = ScannerCameraConfig(
                behavior = ScannerBehaviorConfig(
                    allowedFormats = listOf(BarcodeFormat.QR_CODE, BarcodeFormat.EAN_13)
                )
            )
        )
    )

    Button(onClick = { scanner.launchScanner() }) { Text("Scan") }

    when (val result = scanner.result) {
        is ScannerPickerState.Success -> Text("Scanned: ${result.result.code}")
        is ScannerPickerState.Error   -> Text("Error: ${result.error}")
        else -> Unit
    }
}

@Composable
fun VideoPlayerScreen(videoUrl: String) {
    ImagePickerVideoPlayer(
        source = VideoSource.Url(videoUrl),
        config = VideoPlayerConfig(
            behavior = VideoBehaviorConfig(autoPlay = true)
        )
    )
}

val player = rememberVideoPlayerState(source = VideoSource.Url(videoUrl))
ImagePickerVideoPlayer(state = player, config = VideoPlayerConfig())
player.seekTo(30_000L)

val photo: PhotoResult = result.photos.first()

// Compose UI
val painter = photo.loadPainter()       // Painter for Image()
val bitmap  = photo.loadImageBitmap()  // ImageBitmap for Canvas

// Raw data
val bytes  = photo.loadBytes()         // ByteArray
val base64 = photo.loadBase64()        // Base64-encoded string

// File system (kotlinx-io)
val path   = photo.asPath()            // kotlinx.io.files.Path
val exists = photo.exists()            // Boolean
val source = photo.asSource()          // Buffered Source

// Transfer
photo.transferToSink(mySink)           // Copy to RawSink