kotlin {
    sourceSets {
        commonMain.dependencies {
            // Core (required)
            implementation("com.helloanwar.mvvmate:core:<version>")

            // Optional modules — pick what you need
            implementation("com.helloanwar.mvvmate:network:<version>")
            implementation("com.helloanwar.mvvmate:actions:<version>")
            implementation("com.helloanwar.mvvmate:network-actions:<version>")
        }
    }
}

data class CounterState(
    val count: Int = 0,
    val isLoading: Boolean = false
) : UiState

sealed interface CounterAction : UiAction {
    data object Increment : CounterAction
    data object Decrement : CounterAction
    data object Reset : CounterAction
}

class CounterViewModel : BaseViewModel<CounterState, CounterAction>(
    initialState = CounterState()
) {
    override suspend fun onAction(action: CounterAction) {
        when (action) {
            CounterAction.Increment -> updateState { copy(count = count + 1) }
            CounterAction.Decrement -> updateState { copy(count = count - 1) }
            CounterAction.Reset -> updateState { copy(count = 0) }
        }
    }
}

@Composable
fun CounterScreen(viewModel: CounterViewModel = viewModel()) {
    val state by viewModel.state.collectAsState()

    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        Text("Count: ${state.count}", style = MaterialTheme.typography.headlineLarge)

        Row {
            Button(onClick = { viewModel.handleAction(CounterAction.Decrement) }) {
                Text("-")
            }
            Button(onClick = { viewModel.handleAction(CounterAction.Increment) }) {
                Text("+")
            }
        }

        TextButton(onClick = { viewModel.handleAction(CounterAction.Reset) }) {
            Text("Reset")
        }
    }
}

class LoginViewModel : BaseViewModelWithEffect<LoginState, LoginAction, LoginEffect>(
    initialState = LoginState()
) {
    override suspend fun onAction(action: LoginAction) {
        when (action) {
            is LoginAction.Submit -> {
                updateState { copy(isLoading = true) }
                val success = authRepo.login(action.email, action.password)
                updateState { copy(isLoading = false) }
                if (success) {
                    emitSideEffect(LoginEffect.NavigateToHome)
                } else {
                    emitSideEffect(LoginEffect.ShowError("Invalid credentials"))
                }
            }
        }
    }
}

kotlin {
    sourceSets {
        commonTest.dependencies {
            implementation("com.helloanwar.mvvmate:testing:<version>")
        }
    }
}

@Test
fun testCounterViewModel() = runTest {
    val viewModel = CounterViewModel()

    viewModel.test {
        // Automatically skips the initial emitted state or you can assert it:
        expectStateEquals(CounterState(count = 0))

        dispatchAction(CounterAction.Increment)
        expectStateEquals(CounterState(count = 1))

        dispatchAction(CounterAction.Decrement)
        expectState { it.count == 0 } // Assert lambda
    }
}

@Test
fun testLoginViewModel() = runTest {
    val viewModel = LoginViewModel()

    viewModel.testEffects {
        // Assert initial state
        expectState { !it.isLoading }

        // Start operation
        dispatchAction(LoginAction.Submit("test@test.com", "pass"))
        expectState { it.isLoading }

        // Wait for the simulated effect, assert exact type
        val effect = expectEffectClass<LoginEffect.NavigateToHome>()

        // Assert ending state
        expectState { !it.isLoading }
    }
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("com.helloanwar.mvvmate:forms:<version>")
        }
    }
}

data class RegistrationState(
    val email: FormField<String> = FormField(""),
    val age: FormField<String> = FormField(""),
    val isSubmitting: Boolean = false
) : UiState {
    val isFormValid: Boolean get() = email.isValid && age.isValid
}

class RegistrationViewModel : BaseViewModel<RegistrationState, RegistrationAction>(RegistrationState()) {
    override suspend fun onAction(action: RegistrationAction) {
        when (action) {
            is RegistrationAction.EmailChanged -> updateState {
                copy(email = email.setValue(
                    newValue = action.email, 
                    Validators.required(), 
                    Validators.email()
                ))
            }
            is RegistrationAction.AgeChanged -> updateState {
                copy(age = age.setValue(
                    newValue = action.age,
                    Validators.required(),
                    Validators.digitsRequired("Must be a valid number")
                ))
            }
            RegistrationAction.Submit -> {
                if (state.value.isFormValid) {
                    // Proceed with submission
                } else {
                    // Mark all fields as touched to show errors
                    updateState {
                        copy(
                            email = email.markTouched(Validators.required(), Validators.email()),
                            age = age.markTouched(Validators.required(), Validators.digitsRequired("Must be a valid number"))
                        )
                    }
                }
            }
        }
    }
}

class ProductsViewModel : BaseNetworkViewModel<ProductsState, ProductsAction>(
    initialState = ProductsState()
) {
    override suspend fun onAction(action: ProductsAction) {
        when (action) {
            ProductsAction.Load -> loadProducts()
        }
    }

    private suspend fun loadProducts() {
        performNetworkCallWithRetry<List<Product>>(
            retries = 3,
            isGlobal = true,
            onSuccess = { updateState { copy(products = it) } },
            onError = { error -> updateState { copy(error = error.message) } },
            networkCall = { api.getProducts() }
        )
    }

    override fun ProductsState.setGlobalLoadingState() = copy(isLoading = true)
    override fun ProductsState.resetGlobalLoadingState() = copy(isLoading = false)
}

// In your Application.onCreate() or main():
MvvMate.logger = PrintLogger  // Built-in console logger
MvvMate.isDebug = true         // Enable state change logging

val aiLogger = MvvMateAiLogger(
    delegate = PrintLogger, // also print to console
    maxHistorySize = 50,
    // Safely redacts emails, tokens, and credit cards from the final string output
    redactor = RegexPrivacyRedactor(RegexPrivacyRedactor.DefaultPatterns())
)
MvvMate.logger = aiLogger

// When a crash occurs:
val crashContextString = aiLogger.takeRedactedSnapshotString()

// 1. Define a security policy
val safePolicy = object : AiActionPolicy<MyState, MyAction> {
    override fun isActionAllowed(action: MyAction, currentState: MyState): Boolean {
        // AI is strictly FORBIDDEN from deleting accounts or checking out
        return action !is MyAction.DeleteAccount && action !is MyAction.Checkout
    }
}

// 2. Attach Bridge
val bridge = AiActionBridge(
    viewModel = myViewModel,
    policy = safePolicy,
    parser = MyJsonActionParser() // Convert LLM strings to UiAction
)

// 3. Receive LLM Command
// Example AI generated JSON: { "type": "Increment" }
bridge.dispatch(llmJsonOutput)