// build.gradle.kts
dependencies {
    implementation("in.sitharaj:redux-kmp:1.0.0")
}

data class CounterState(
    val count: Int = 0,
    val loading: Boolean = false
) : State

sealed interface CounterAction : Action {
    data object Increment : CounterAction
    data object Decrement : CounterAction
    data class SetCount(val value: Int) : CounterAction
}

val counterReducer = reducer<CounterState> {
    on<CounterAction.Increment> { state, _ ->
        state.copy(count = state.count + 1)
    }
    on<CounterAction.Decrement> { state, _ ->
        state.copy(count = state.count - 1)
    }
    on<CounterAction.SetCount> { state, action ->
        state.copy(count = action.value)
    }
}

val store = createStore(
    initialState = CounterState(),
    reducer = counterReducer,
    scope = CoroutineScope(Dispatchers.Main)
) {
    addMiddleware(ThunkMiddleware())
    addMiddleware(LoggingMiddleware(tag = "Counter"))
}

store.dispatch(CounterAction.Increment)

// Observe state
store.state.collect { state ->
    println("Count: ${state.count}")
}

@Composable
fun CounterScreen() {
    val state by store.state.collectAsState()
    
    Column {
        Text("Count: ${state.count}")
        Button(onClick = { store.dispatch(CounterAction.Increment) }) {
            Text("Increment")
        }
    }
}

val selectCount = selector<AppState, Int> { it.counter }

val selectDoubleCount = createSelector(selectCount) { count ->
    count * 2  // Only recomputes when count changes
}

// Multiple inputs
val selectTotal = createSelector(
    { state: CartState -> state.items },
    { state: CartState -> state.taxRate }
) { items, taxRate ->
    items.sumOf { it.price } * (1 + taxRate)
}

val fetchUser = createAsyncThunk<String, User, AppState>(
    typePrefix = "users/fetchById"
) { userId, thunkApi ->
    api.getUser(userId)
}

// Handle in reducer
val userReducer = reducer<UserState> {
    on<AsyncThunkPending<String>> { state, _ ->
        state.copy(loading = true)
    }
    on<AsyncThunkFulfilled<String, User>> { state, action ->
        state.copy(loading = false, user = action.payload)
    }
    on<AsyncThunkRejected<String>> { state, action ->
        state.copy(loading = false, error = action.error.message)
    }
}

val usersAdapter = createEntityAdapter<User> { it.id }

data class UsersState(
    val users: EntityState<User> = usersAdapter.getInitialState()
) : State

// CRUD operations
usersAdapter.addOne(state.users, newUser)
usersAdapter.updateOne(state.users, id) { it.copy(name = "New") }
usersAdapter.removeOne(state.users, id)

// Selectors
val allUsers = usersAdapter.selectAll(state.users)
val user = usersAdapter.selectById(state.users, "123")

val listenerMiddleware = createListenerMiddleware<AppState>()

listenerMiddleware.addListener<UserAction.Login> { action, api ->
    api.dispatch(AnalyticsAction.Track("login"))
    
    api.fork {
        delay(1000)
        api.dispatch(NotificationAction.Show("Welcome!"))
    }
}

val counterSlice = createSlice<CounterState>(
    name = "counter",
    initialState = CounterState()
) {
    reduce("increment") { state, _ ->
        state.copy(count = state.count + 1)
    }
    
    reduce<Int>("addAmount") { state, payload ->
        state.copy(count = state.count + payload)
    }
}

// Use
val reducer = counterSlice.reducer
store.dispatch(counterSlice.actions.invoke("increment"))