/* eslint-disable @typescript-eslint/consistent-indexed-object-style */
/* A number of these types have been used exactly or adapted from MIT licensed @reduxjs/toolkit */

export type Action<T extends string = string> = {
    type: T
}

export interface UnknownAction extends Action {
    [key: string]: unknown
}

export interface AnyAction extends Action {
    [key: string]: any
}

export type CaseReducer<
    S = any,
    A extends Action = AnyAction,
    R = S | undefined,
> = (state: S, action: A) => R

export type PayloadAction<P = void, T extends string = string> = {
    payload: P
    type: T
}

type SliceCaseReducer<TState> = Record<
    string,
    CaseReducer<TState, PayloadAction<any, any>>
>

export type CreateReducerParams<TState = any> = {
    initialState: TState
    reducers: SliceCaseReducer<TState>
}

export type CreateReducerReturn<TState> = {
    initialState: TState
    reducer: CaseReducer<TState, PayloadAction<any>, TState>
}

export function createReducer<
    TState,
    TParams extends CreateReducerParams<TState> = CreateReducerParams<TState>,
>({ initialState, reducers }: TParams): CreateReducerReturn<TState> {
    const actions = new Map(Object.entries(reducers))

    const reducer = (state: TState, action: PayloadAction<any>) => {
        if (actions.has(action.type)) {
            const handler = actions.get(action.type)
            if (handler) {
                const newState = handler(state, action)
                if (newState !== undefined && newState !== state) {
                    return newState
                }
            }
        }
        return state
    }

    return {
        initialState,
        reducer,
    }
}