import { ActionReducer, StateAction } from "../StateManager.js";
import StateManager from "../StateManager.js";
import { getRemovedRecords } from "./RemovedRecordsSlice.js";
import { Action } from "../action/DataUnitAction.js";
import { Record, SavedRecord } from "../../interfaces/dataUnit.js";


class RecordsReducerImpl implements ActionReducer {

    public sliceName: string = "records";

    public reduce(stateManager: StateManager, currentState: Array<Record>, action: StateAction): Array<Record> {
        switch (action.type) {

            case Action.DATA_LOADED:
                return action.payload ? action.payload.records : [];
            case Action.RECORDS_REMOVED:
                
                const {records, buffered} = action.payload;
                if(!buffered){
                    return currentState.filter(r=>!records.includes(r.__record__id__));
                }
                return currentState;
                
            case Action.DATA_SAVED:

                const recordsMap: Map<string, Record> = new Map();
                const currentRecords = getRecords(stateManager);

                if (currentRecords.length) {
                    const removed: Array<string> = getRemovedRecords(stateManager) || [];
                    currentRecords.forEach(r => {
                        if (!removed.includes(r.__record__id__)) {
                            recordsMap.set(r.__record__id__, r);
                        }
                    });
                }

                const newRecords: Array<Record> = [];
                const savedRecords: Array<SavedRecord> = action.payload.records;
                savedRecords.forEach(sr => {
                    const recordId = sr.__old__id__ || sr.__record__id__;
                    const newRecord: Record = { ...sr };
                    delete newRecord["__old__id__"];
                    if(recordsMap.has(recordId)){
                        recordsMap.set(recordId, newRecord);
                    } else {
                        newRecords.push(newRecord);
                    }
                });
                return Array.from(recordsMap.values()).concat(newRecords);

            case Action.RECORD_LOADED:
                action.payload.forEach((record: any) => {
                    for(let i = 0; i < currentState.length; i++){                        
                        if(currentState[i].__record__id__ === record.__record__id__){
                            currentState[i] = record;
                        }
                    }
                });
        }
        return currentState;
    }
}

export const RecordsReducer = new RecordsReducerImpl();

export const getRecords = (stateManager: StateManager): Array<Record> => {
    return stateManager.select(RecordsReducer.sliceName, (state: Array<Record>) => state) ?? [];
};