import { call, put, select } from 'redux-saga/effects'
import { goDownOneInteractionLevel } from '../actions/interaction-level'
import {
    addIdToStoreObjectListProp,
    addPropToStoreObject,
    addToStore,
    removeIdFromStoreObjectListProp,
} from '../actions/objects'
import {
    cancelNewRoomConstructionSucceeded,
    setCurrentDatacenter,
    startNewRoomConstructionSucceeded,
} from '../actions/topology/building'
import { addRoomToDatacenter } from '../api/routes/datacenters'
import { addTileToRoom, deleteRoom, updateRoom } from '../api/routes/rooms'
import {
    addMachineToRackOnTile,
    addRackToTile,
    deleteMachineInRackOnTile,
    deleteRackFromTile,
    deleteTile,
    updateMachineInRackOnTile,
    updateRackOnTile,
} from '../api/routes/tiles'
import {
    DEFAULT_RACK_POWER_CAPACITY,
    DEFAULT_RACK_SLOT_CAPACITY,
    MAX_NUM_UNITS_PER_MACHINE,
} from '../components/app/map/MapConstants'
import {
    fetchAndStoreAllCPUs,
    fetchAndStoreAllGPUs,
    fetchAndStoreAllMemories,
    fetchAndStoreAllStorages,
    fetchAndStoreCoolingItem,
    fetchAndStoreCPU,
    fetchAndStoreDatacenter,
    fetchAndStoreGPU,
    fetchAndStoreMachinesOfTile,
    fetchAndStoreMemory,
    fetchAndStorePath,
    fetchAndStorePathsOfSimulation,
    fetchAndStorePSU,
    fetchAndStoreRackOnTile,
    fetchAndStoreRoomsOfDatacenter,
    fetchAndStoreSectionsOfPath,
    fetchAndStoreStorage,
    fetchAndStoreTilesOfRoom,
} from './objects'

export function* fetchLatestDatacenter(simulationId) {
    try {
        const paths = yield fetchAndStorePathsOfSimulation(simulationId)
        const latestPath = paths[paths.length - 1]
        const sections = yield fetchAndStoreSectionsOfPath(latestPath.id)
        const latestSection = sections[sections.length - 1]
        yield fetchAllUnitSpecifications()
        yield fetchDatacenter(latestSection.datacenterId)
        yield put(setCurrentDatacenter(latestSection.datacenterId))
    } catch (error) {
        console.error(error)
    }
}

export function* fetchAllDatacentersOfExperiment(experiment) {
    try {
        const path = yield fetchAndStorePath(experiment.pathId)
        const sections = yield fetchAndStoreSectionsOfPath(path.id)
        path.sectionIds = sections.map(section => section.id)
        yield fetchAllUnitSpecifications()

        for (let i in sections) {
            yield fetchDatacenter(sections[i].datacenterId)
        }
        yield put(setCurrentDatacenter(sections[0].datacenterId))
    } catch (error) {
        console.error(error)
    }
}

function* fetchDatacenter(datacenterId) {
    try {
        yield fetchAndStoreDatacenter(datacenterId)
        const rooms = yield fetchAndStoreRoomsOfDatacenter(datacenterId)
        yield put(
            addPropToStoreObject('datacenter', datacenterId, {
                roomIds: rooms.map(room => room.id),
            }),
        )

        for (let index in rooms) {
            yield fetchRoom(rooms[index].id)
        }
    } catch (error) {
        console.error(error)
    }
}

function* fetchAllUnitSpecifications() {
    try {
        yield fetchAndStoreAllCPUs()
        yield fetchAndStoreAllGPUs()
        yield fetchAndStoreAllMemories()
        yield fetchAndStoreAllStorages()
    } catch (error) {
        console.error(error)
    }
}

function* fetchRoom(roomId) {
    const tiles = yield fetchAndStoreTilesOfRoom(roomId)
    yield put(
        addPropToStoreObject('room', roomId, {
            tileIds: tiles.map(tile => tile.id),
        }),
    )

    for (let index in tiles) {
        yield fetchTile(tiles[index])
    }
}

function* fetchTile(tile) {
    if (!tile.objectType) {
        return
    }

    switch (tile.objectType) {
        case 'RACK':
            const rack = yield fetchAndStoreRackOnTile(tile.objectId, tile.id)
            yield put(addPropToStoreObject('tile', tile.id, { rackId: rack.id }))
            yield fetchMachinesOfRack(tile.id, rack)
            break
        case 'COOLING_ITEM':
            const coolingItem = yield fetchAndStoreCoolingItem(tile.objectId)
            yield put(
                addPropToStoreObject('tile', tile.id, { coolingItemId: coolingItem.id }),
            )
            break
        case 'PSU':
            const psu = yield fetchAndStorePSU(tile.objectId)
            yield put(addPropToStoreObject('tile', tile.id, { psuId: psu.id }))
            break
        default:
            console.warn('Unknown rack type encountered while fetching tile objects')
    }
}

function* fetchMachinesOfRack(tileId, rack) {
    const machines = yield fetchAndStoreMachinesOfTile(tileId)
    const machineIds = new Array(rack.capacity).fill(null)
    machines.forEach(machine => (machineIds[machine.position - 1] = machine.id))

    yield put(addPropToStoreObject('rack', rack.id, { machineIds }))

    for (let index in machines) {
        for (let i in machines[index].cpuIds) {
            yield fetchAndStoreCPU(machines[index].cpuIds[i])
        }
        for (let i in machines[index].gpuIds) {
            yield fetchAndStoreGPU(machines[index].gpuIds[i])
        }
        for (let i in machines[index].memoryIds) {
            yield fetchAndStoreMemory(machines[index].memoryIds[i])
        }
        for (let i in machines[index].storageIds) {
            yield fetchAndStoreStorage(machines[index].storageIds[i])
        }
    }
}

export function* onStartNewRoomConstruction() {
    try {
        const datacenterId = yield select(state => state.currentDatacenterId)
        const room = yield call(addRoomToDatacenter, {
            id: -1,
            datacenterId,
            roomType: 'SERVER',
        })
        const roomWithEmptyTileList = Object.assign({}, room, { tileIds: [] })
        yield put(addToStore('room', roomWithEmptyTileList))
        yield put(
            addIdToStoreObjectListProp('datacenter', datacenterId, 'roomIds', room.id),
        )
        yield put(startNewRoomConstructionSucceeded(room.id))
    } catch (error) {
        console.error(error)
    }
}

export function* onCancelNewRoomConstruction() {
    try {
        const datacenterId = yield select(state => state.currentDatacenterId)
        const roomId = yield select(
            state => state.construction.currentRoomInConstruction,
        )
        yield call(deleteRoom, roomId)
        yield put(
            removeIdFromStoreObjectListProp(
                'datacenter',
                datacenterId,
                'roomIds',
                roomId,
            ),
        )
        yield put(cancelNewRoomConstructionSucceeded())
    } catch (error) {
        console.error(error)
    }
}

export function* onAddTile(action) {
    try {
        const roomId = yield select(
            state => state.construction.currentRoomInConstruction,
        )
        const tile = yield call(addTileToRoom, {
            roomId,
            positionX: action.positionX,
            positionY: action.positionY,
        })
        yield put(addToStore('tile', tile))
        yield put(addIdToStoreObjectListProp('room', roomId, 'tileIds', tile.id))
    } catch (error) {
        console.error(error)
    }
}

export function* onDeleteTile(action) {
    try {
        const roomId = yield select(
            state => state.construction.currentRoomInConstruction,
        )
        yield call(deleteTile, action.tileId)
        yield put(
            removeIdFromStoreObjectListProp('room', roomId, 'tileIds', action.tileId),
        )
    } catch (error) {
        console.error(error)
    }
}

export function* onEditRoomName(action) {
    try {
        const roomId = yield select(state => state.interactionLevel.roomId)
        const room = Object.assign(
            {},
            yield select(state => state.objects.room[roomId]),
        )
        room.name = action.name
        yield call(updateRoom, room)
        yield put(addPropToStoreObject('room', roomId, { name: action.name }))
    } catch (error) {
        console.error(error)
    }
}

export function* onDeleteRoom() {
    try {
        const datacenterId = yield select(state => state.currentDatacenterId)
        const roomId = yield select(state => state.interactionLevel.roomId)
        yield call(deleteRoom, roomId)
        yield put(goDownOneInteractionLevel())
        yield put(
            removeIdFromStoreObjectListProp(
                'datacenter',
                datacenterId,
                'roomIds',
                roomId,
            ),
        )
    } catch (error) {
        console.error(error)
    }
}

export function* onEditRackName(action) {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        const rackId = yield select(
            state => state.objects.tile[state.interactionLevel.tileId].objectId,
        )
        const rack = Object.assign(
            {},
            yield select(state => state.objects.rack[rackId]),
        )
        rack.name = action.name
        yield call(updateRackOnTile, tileId, rack)
        yield put(addPropToStoreObject('rack', rackId, { name: action.name }))
    } catch (error) {
        console.error(error)
    }
}

export function* onDeleteRack() {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        yield call(deleteRackFromTile, tileId)
        yield put(goDownOneInteractionLevel())
        yield put(addPropToStoreObject('tile', tileId, { objectType: undefined }))
        yield put(addPropToStoreObject('tile', tileId, { objectId: undefined }))
    } catch (error) {
        console.error(error)
    }
}

export function* onAddRackToTile(action) {
    try {
        const rack = yield call(addRackToTile, action.tileId, {
            id: -1,
            name: 'Rack',
            capacity: DEFAULT_RACK_SLOT_CAPACITY,
            powerCapacityW: DEFAULT_RACK_POWER_CAPACITY,
        })
        rack.machineIds = new Array(rack.capacity).fill(null)
        yield put(addToStore('rack', rack))
        yield put(
            addPropToStoreObject('tile', action.tileId, { objectId: rack.id }),
        )
        yield put(
            addPropToStoreObject('tile', action.tileId, { objectType: 'RACK' }),
        )
    } catch (error) {
        console.error(error)
    }
}

export function* onAddMachine(action) {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        const rackId = yield select(
            state => state.objects.tile[state.interactionLevel.tileId].objectId,
        )
        const rack = yield select(state => state.objects.rack[rackId])

        const machine = yield call(addMachineToRackOnTile, tileId, {
            id: -1,
            rackId,
            position: action.position,
            tags: [],
            cpuIds: [],
            gpuIds: [],
            memoryIds: [],
            storageIds: [],
        })
        yield put(addToStore('machine', machine))

        const machineIds = [...rack.machineIds]
        machineIds[machine.position - 1] = machine.id
        yield put(addPropToStoreObject('rack', rackId, { machineIds }))
    } catch (error) {
        console.error(error)
    }
}

export function* onDeleteMachine() {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        const position = yield select(state => state.interactionLevel.position)
        const rack = yield select(
            state => state.objects.rack[state.objects.tile[tileId].objectId],
        )
        yield call(deleteMachineInRackOnTile, tileId, position)
        const machineIds = [...rack.machineIds]
        machineIds[position - 1] = null
        yield put(goDownOneInteractionLevel())
        yield put(addPropToStoreObject('rack', rack.id, { machineIds }))
    } catch (error) {
        console.error(error)
    }
}

export function* onAddUnit(action) {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        const position = yield select(state => state.interactionLevel.position)
        const machine = yield select(
            state =>
                state.objects.machine[
                    state.objects.rack[state.objects.tile[tileId].objectId].machineIds[
                    position - 1
                        ]
                    ],
        )

        if (machine[action.unitType + 'Ids'].length >= MAX_NUM_UNITS_PER_MACHINE) {
            return
        }

        const units = [...machine[action.unitType + 'Ids'], action.id]
        const updatedMachine = Object.assign({}, machine, {
            [action.unitType + 'Ids']: units,
        })

        yield call(updateMachineInRackOnTile, tileId, position, updatedMachine)

        yield put(
            addPropToStoreObject('machine', machine.id, {
                [action.unitType + 'Ids']: units,
            }),
        )
    } catch (error) {
        console.error(error)
    }
}

export function* onDeleteUnit(action) {
    try {
        const tileId = yield select(state => state.interactionLevel.tileId)
        const position = yield select(state => state.interactionLevel.position)
        const machine = yield select(
            state =>
                state.objects.machine[
                    state.objects.rack[state.objects.tile[tileId].objectId].machineIds[
                    position - 1
                        ]
                    ],
        )
        const unitIds = machine[action.unitType + 'Ids'].slice()
        unitIds.splice(action.index, 1)
        const updatedMachine = Object.assign({}, machine, {
            [action.unitType + 'Ids']: unitIds,
        })

        yield call(updateMachineInRackOnTile, tileId, position, updatedMachine)
        yield put(
            addPropToStoreObject('machine', machine.id, {
                [action.unitType + 'Ids']: unitIds,
            }),
        )
    } catch (error) {
        console.error(error)
    }
}