repositories {
    mavenCentral()
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            // Core MVI components - if ViewModel integration is not required
            implementation("io.github.marcin-adamczewski:core:[libVersion]")
            
            // Core components + ViewModel integration
            implementation("io.github.marcin-adamczewski:viewmodel:[libVersion]")
            
            // Compose Multiplatform extensions
            implementation("io.github.marcin-adamczewski:compose:[libVersion]")

            // Test utils
            implementation("io.github.marcin-adamczewski:test:[libVersion]")
        }
    }
}

// State of your UI.
data class SongsState(
    val isLoading: Boolean = false,
    val error: UiError? = null,
    val songs: List<Song> = emptyList(),
) : MviState

// Actions that can be dispatched from the UI.
sealed interface SongsAction : MviAction {
    data class SearchQueryChanged(val query: String) : SongsAction
    data class SongSelected(val song: Song) : SongsAction
}

// Effects that are emitted from the MviContainer and observed by the UI.
// Usually those are navigation events, toast messages, etc.
sealed interface SongsEffect : MviEffect {
    data class OpenSongDetails(val songId: String) : SongsEffect
    data class OpenMediaPlayer(val songId: String) : SongsEffect
}

class SongsViewModel(
    private val repository: MusicRepository,
    private val errorManager: ErrorManager,
) : MviViewModel<SongsAction, SongsState, SongsEffect>(
    initialState = SongsState()
) {

    init {
        // onInit is called once, when the first subscriber connects to the state or effects.
        onInit { 
            // withProgress - Shows progress at the beggining of the block and hides it when completed 
            withProgress {
                repository.fetchSongs()
                    // setState - Updates state based on the current state
                    .onSuccess { setState { copy(songs = it, error = null) } }
            }
        }
    }

    override fun ActionsManager<SongsAction>.handleActions() {
        onAction<SongSelected> {
            setEffect { OpenSongDetails(it.song.id) }
        }

        onActionFlow<SearchQueryChanged> {
            debounce(300).map {
                setState { copy(query = it) }
            }
        }
    }
}

class SongsViewModel(
    private val repository: MusicRepository
) : ViewModel, MviContainerHost<SongsAction, SongsState, SongsEffect> {

    override val component = mviViewModel<SongsAction, SongsState, SongsEffect>(SongsState()) {
        onInit {
            // withProgress - Shows progress at the beggining of the block and hides it when completed
            withProgress {
                repository.fetchSongs()
                    // setState - Updates state based on the current state
                    .onSuccess {
                        setState { copy(songs = it, error = null) }
                    }
            }
        }

        actions {
            onAction<SongSelected> { action ->
                setEffect { OpenSongDetails(action.song.id) }
            }

            onActionFlow<SearchQueryChanged> {
                debounce(300).map { 
                    setState { copy(query = it) }
                }
            }
        }
    }
}

@Composable
fun SongsScreen(viewModel: SongsViewModel) {
    // Collect state with lifecycle awareness
    val state by viewModel.collectAsStateWithLifecycle()
    var searchQuery by rememberSavable { mutableStateOf("") }

    // Handle one-time events
    viewModel.ConsumeEffects { effect ->
        when (effect) {
            is SongsEffect.OpenSongDetails -> { /* navigate to details */ }
        }
    }

    Column {
        TextField(
            value = searchQuery,
            onValueChange = { 
                searchQuery = it
                // Send search query to the ViewModel
                viewModel.submitAction(SongsAction.SearchQueryChanged(it)) 
            }
        )
        
        state.songs.forEach { song ->
            SongItem(
                text = song.title,
                onClick = {
                    // Send song click event to the ViewModel
                    viewModel.submitAction(SongsAction.SongSelected(song)) 
                }
            )
        }
    }
}

// In your ViewModel
init {
    observeProgress { isLoading ->
        setState { copy(isLoading = isLoading) }
    }
}

// In handleActions
onAction<AddToFavoritesClicked> {
    // Automatically manage loading state during the block
    withProgress {
        val songs = repository.getSongs()
        setState { copy(songs = songs) }
    }
}

// Or using Flow transformers
onActionFlow<Init> {
    repository.getSongsFlow()
        .watchProgress() // Shows loading on start and hides when first value is received or Flow is completed
        .onSuccess { songs ->
            setState { copy(songs = songs) }
        }
}