import {call, put, select} from "redux-saga/effects";
import {addToStore} from "../actions/objects";
import {getDatacenter, getRoomsOfDatacenter} from "../api/routes/datacenters";
import {getPath, getSectionsOfPath} from "../api/routes/paths";
import {getTilesOfRoom} from "../api/routes/rooms";
import {getAllSchedulers} from "../api/routes/schedulers";
import {getSection} from "../api/routes/sections";
import {getPathsOfSimulation, getSimulation} from "../api/routes/simulations";
import {
    getAllCPUs,
    getAllGPUs,
    getAllMemories,
    getAllStorages,
    getCoolingItem,
    getCPU,
    getFailureModel,
    getGPU,
    getMemory,
    getPSU,
    getStorage
} from "../api/routes/specifications";
import {getMachinesOfRackByTile, getRackByTile} from "../api/routes/tiles";
import {getAllTraces} from "../api/routes/traces";
import {getUser} from "../api/routes/users";

export const OBJECT_SELECTORS = {
    simulation: state => state.objects.simulation,
    user: state => state.objects.user,
    authorization: state => state.objects.authorization,
    failureModel: state => state.objects.failureModel,
    cpu: state => state.objects.cpu,
    gpu: state => state.objects.gpu,
    memory: state => state.objects.memory,
    storage: state => state.objects.storage,
    machine: state => state.objects.machine,
    rack: state => state.objects.rack,
    coolingItem: state => state.objects.coolingItem,
    psu: state => state.objects.psu,
    tile: state => state.objects.tile,
    room: state => state.objects.room,
    datacenter: state => state.objects.datacenter,
    section: state => state.objects.section,
    path: state => state.objects.path,
};

function* fetchAndStoreObject(objectType, id, apiCall) {
    const objectStore = yield select(OBJECT_SELECTORS[objectType]);
    let object = objectStore[id];
    if (!object) {
        object = yield apiCall;
        yield put(addToStore(objectType, object));
    }
    return object;
}

function* fetchAndStoreObjects(objectType, apiCall) {
    const objects = yield apiCall;
    for (let index in objects) {
        yield put(addToStore(objectType, objects[index]));
    }
    return objects;
}

export const fetchAndStoreSimulation = (id) =>
    fetchAndStoreObject("simulation", id, call(getSimulation, id));

export const fetchAndStoreUser = (id) =>
    fetchAndStoreObject("user", id, call(getUser, id));

export const fetchAndStoreFailureModel = (id) =>
    fetchAndStoreObject("failureModel", id, call(getFailureModel, id));

export const fetchAndStoreAllCPUs = () =>
    fetchAndStoreObjects("cpu", call(getAllCPUs));

export const fetchAndStoreCPU = (id) =>
    fetchAndStoreObject("cpu", id, call(getCPU, id));

export const fetchAndStoreAllGPUs = () =>
    fetchAndStoreObjects("gpu", call(getAllGPUs));

export const fetchAndStoreGPU = (id) =>
    fetchAndStoreObject("gpu", id, call(getGPU, id));

export const fetchAndStoreAllMemories = () =>
    fetchAndStoreObjects("memory", call(getAllMemories));

export const fetchAndStoreMemory = (id) =>
    fetchAndStoreObject("memory", id, call(getMemory, id));

export const fetchAndStoreAllStorages = () =>
    fetchAndStoreObjects("storage", call(getAllStorages));

export const fetchAndStoreStorage = (id) =>
    fetchAndStoreObject("storage", id, call(getStorage, id));

export const fetchAndStoreMachinesOfTile = (tileId) =>
    fetchAndStoreObjects("machine", call(getMachinesOfRackByTile, tileId));

export const fetchAndStoreRackOnTile = (id, tileId) =>
    fetchAndStoreObject("rack", id, call(getRackByTile, tileId));

export const fetchAndStoreCoolingItem = (id) =>
    fetchAndStoreObject("coolingItem", id, call(getCoolingItem, id));

export const fetchAndStorePSU = (id) =>
    fetchAndStoreObject("psu", id, call(getPSU, id));

export const fetchAndStoreTilesOfRoom = (roomId) =>
    fetchAndStoreObjects("tile", call(getTilesOfRoom, roomId));

export const fetchAndStoreRoomsOfDatacenter = (datacenterId) =>
    fetchAndStoreObjects("room", call(getRoomsOfDatacenter, datacenterId));

export const fetchAndStoreDatacenter = (id) =>
    fetchAndStoreObject("datacenter", id, call(getDatacenter, id));

export const fetchAndStoreSection = (id) =>
    fetchAndStoreObject("section", id, call(getSection, id));

export const fetchAndStoreSectionsOfPath = (pathId) =>
    fetchAndStoreObjects("section", call(getSectionsOfPath, pathId));

export const fetchAndStorePath = (id) =>
    fetchAndStoreObject("path", id, call(getPath, id));

export const fetchAndStorePathsOfSimulation = (simulationId) =>
    fetchAndStoreObjects("path", call(getPathsOfSimulation, simulationId));

export const fetchAndStoreAllTraces = () =>
    fetchAndStoreObjects("trace", call(getAllTraces));

export const fetchAndStoreAllSchedulers = function* () {
    const objects = yield call(getAllSchedulers);
    for (let index in objects) {
        objects[index].id = objects[index].name;
        yield put(addToStore("scheduler", objects[index]));
    }
    return objects;
};