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
}

// Side 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.
        // Use it for initilization or create an Init action and dispatch it manually whenever you want.
        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) } }
                    .onError { errorManager.addError(it.toLongError()) }
            }
        }

        // Optional - Handle all errors in one place using ErrorManager
        observeError(errorManager) { error ->
            setState { copy(error = error) }
        }

        // Optional - Handle all loading events in one place using ProgressManager
        observeProgress { isLoading ->
            setState { copy(isLoading = isLoading) }
        }
    }

    override fun ActionsManager<SongsAction>.handleActions() {
        // Instead of using onInit block, you can dispatch Init action manually whenever you want.
        onActionSingle<Init> {
            // Initialization logic here
        }
        
        // When song was selected in UI, emit navigation effect OpenSongDetails
        onAction<SongSelected> {
            analytics.trackSongSelected(it.song.id)
            setEffect { OpenSongDetails(it.song.id) }
        }
        
        // onActionFlow is very powerful and allows to act on UI actions using Flow transformers.
        // In this example we debounce every search text change so the search doesn't run on every keystroke.
        // This flow is automatically collected.
        onActionFlow<SearchQueryChanged> { action ->
            debounce(300)
                .distinctUntilChanged()
                .map { repository.searchSongs(action.query) }
                .onSuccess { setState { copy(songs = it, error = null) } }
                .onError { errorManager.addError(it.toLongError()) }
        }
    }
}

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

    // Handle one-time side effects
    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) }
        }
}