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


class InvalidFieldsReducerImpl implements ActionReducer{
    
    public sliceName: string = "hist::invalidFields";
        
    public reduce(_stateManager:StateManager, currentState: Map<string, Map<string, string>>, action: StateAction): Map<string, Map<string, string>>|undefined {

        switch(action.type){
            case Action.FIELD_INVALIDATED:
                return makeInvalid(currentState, action.payload);
            case Action.INVALIDATE_CLEAN:
                return clearRecord(currentState, action.payload);
            case Action.EDITION_CANCELED:
                return undefined;
        }

        return currentState;
    }
}

export const InvalidFieldsReducer = new InvalidFieldsReducerImpl();

export const getInvalidFields = (stateManager: StateManager):  Map<string, Map<string, string>> => {
    return stateManager.select(InvalidFieldsReducer.sliceName, (state: Map<string, Map<string, string>>) => state);
};

export const getInvalidFieldMessage = (stateManager: StateManager, fieldName: string, recordId: string): string | undefined => {
    const invalidFields = getInvalidFields(stateManager);
    if(invalidFields){
        const recordInvalidFields = invalidFields.get(recordId);
        if(recordInvalidFields){
            return recordInvalidFields.get(fieldName);
        }
    }
    return undefined;
}

const clearRecord = (currentState:Map<string, Map<string, string>>, payload: any): Map<string, Map<string, string>>|undefined => {

    const {recordId, fieldName} = payload;

    if(recordId == undefined){
        return undefined;
    }

    if(currentState){
        const recordInvalidFields = currentState.get(recordId);
        if(recordInvalidFields){
            const newState: Map<string, Map<string, string>> = new Map(currentState);
            if(fieldName == undefined){
                newState.delete(recordId);
            } else {
                const newRecorcInvalidFields: Map<string, string> = new Map(recordInvalidFields);
                newRecorcInvalidFields.delete(fieldName);
                if(newRecorcInvalidFields.size > 0){
                    newState.set(recordId, newRecorcInvalidFields);
                } else {
                    newState.delete(recordId);
                }
                return newState;
            }
        }

        return currentState;
    }

    return undefined;
}

const makeInvalid = (currentState:Map<string, Map<string, string>>, payload: any): Map<string, Map<string, string>>|undefined => {

    const {recordId, message, fieldName} = payload;
    
    const recordInvalidFields = new Map(currentState?.get(recordId));
    recordInvalidFields.set(fieldName, message);

    const newState = new Map(currentState);
    newState.set(recordId, recordInvalidFields);

    return newState;
}