import { WaitingChange } from "../../interfaces/dataUnit.js";
import { Action } from "../action/DataUnitAction.js";
import StateManager, { ActionReducer, StateAction } from "../StateManager.js";

class WaitingCheangesReducerImpl implements ActionReducer{
    
    public sliceName: string = "waitingChanges";

    public reduce(stateManager:StateManager, currentState: Map<string, WaitingChange>, action: StateAction): Map<string, WaitingChange>|undefined {
        let newState: Map<string, WaitingChange>;
        switch(action.type){

            case Action.CHANGING_DATA: 
                newState = new Map(currentState);
                Object.entries(action.payload).forEach(([key, value]) => {
                    newState.set(key, value as WaitingChange);
                });

                return newState;

            case Action.WAITING_CHANGE_CANCELED: 
                newState = new Map(currentState);
                newState.delete(action.payload.fieldName);

                return newState.size === 0 ? undefined : newState;

            case Action.DATA_CHANGED:
                newState = new Map(currentState);
                Object.entries(action.payload).forEach(([key]) => {
                    newState.delete(key);
                });

                return newState.size === 0 ? undefined : newState;

            case Action.DATA_SAVED:
            case Action.EDITION_CANCELED:
                return undefined;
        } 
        return currentState;
    }

}

export const WaitingChangesReducer = new WaitingCheangesReducerImpl();

export const getWaitingChanges = (stateManager: StateManager): Map<string, WaitingChange>|undefined => {
    return stateManager.select(WaitingChangesReducer.sliceName, (state: Map<string, WaitingChange>) => state);
}

export const isWaiting = (stateManager: StateManager, fieldName: string): boolean => {
    const allWC = getWaitingChanges(stateManager);
    return allWC ? allWC.has(fieldName) : false;
}

export const getBlockingWaitingChanges = (stateManager: StateManager): Map<string, WaitingChange>|undefined => {
    const allWC = getWaitingChanges(stateManager);
    if(allWC){
        return new Map(
            Array.from(allWC.entries())
                 .filter(entry=>entry[1].blocking)
                 .map(entry=>[entry[0], entry[1]])
        );
    }
}

export const getWaitingChangePromisses = (stateManager: StateManager): (Promise<any>|undefined)[]|undefined => {
    const allWC = getWaitingChanges(stateManager);
    if(allWC){
        return Array.from(allWC.values())
            .filter(wc=>!wc.blocking)
            .map(wc=>wc.promise);
    }
}