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
}