-- AD Runs Controller
-- Oversætter et run til AutoDrive-tilstand pr. traktor: validering, Start/Stop, status,
-- Auto-vareliste, og "hvilket run hører traktoren til". GUI'et kalder kun herind;
-- de eksisterende hooks (choosePickup, Wait-punkter) spørger getRunForVehicle/getRunIngredients.

ADRunsController = {}

ADRunsController.LOG_PREFIX = "ADSmartPickup: "
-- Længere væk fra vejnettet end dette kan AutoDrive ikke starte (samme grænse som AD's HUD).
ADRunsController.MAX_NETWORK_DISTANCE = 30

ADRunsController.store = ADRuns.newStore()

local function copyList(list)
    local copy = {}
    for index, value in ipairs(list or {}) do
        copy[index] = value
    end
    return copy
end

-- Stabil nøgle: FS25's uniqueId ("vehicle…"), ellers savegame-id. Navne bruges aldrig.
function ADRunsController.getVehicleId(vehicle)
    if vehicle.uniqueId ~= nil then
        return tostring(vehicle.uniqueId)
    end
    if vehicle.getUniqueId ~= nil then
        local id = vehicle:getUniqueId()
        if id ~= nil then
            return tostring(id)
        end
    end
    if vehicle.currentSavegameId ~= nil then
        return tostring(vehicle.currentSavegameId)
    end
    return nil
end

function ADRunsController.getFarmVehicles(adEnv)
    local farmId = g_currentMission:getFarmId()
    local result = {}
    for _, vehicle in pairs(adEnv.AutoDrive.getAllVehicles()) do
        -- kun motoriserede (traktorer, høstere); AD-spec'en sidder også på redskaber
        local isMotorized = vehicle.spec_motorized ~= nil or vehicle.spec_motorized == nil and vehicle.startAutoDrive ~= nil
        if vehicle.ad ~= nil and isMotorized and vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId then
            table.insert(result, vehicle)
        end
    end
    return result
end

-- Ét map pr. kald i stedet for at genscanne getFarmVehicles pr. vehicleId — startRun/stopRun/
-- getRunStatus/load slår flere id'er op pr. kald, og GUI'et kalder getRunStatus hvert sekund.
local function getFarmVehiclesById(adEnv)
    local byId = {}
    for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
        local id = ADRunsController.getVehicleId(vehicle)
        if id ~= nil then
            byId[id] = vehicle
        end
    end
    return byId
end

function ADRunsController.findVehicleById(adEnv, vehicleId)
    return getFarmVehiclesById(adEnv)[vehicleId]
end

function ADRunsController.getRunForVehicle(vehicle)
    local id = ADRunsController.getVehicleId(vehicle)
    return id ~= nil and ADRuns.findRunByVehicle(ADRunsController.store, id) or nil
end

-- ---- store-wrappers (erstatter altid hele store'en; modellen muterer aldrig) ----

function ADRunsController.createRun(name)
    local store, run = ADRuns.createRun(ADRunsController.store, name)
    ADRunsController.store = store
    return run
end

function ADRunsController.deleteRun(runId, adEnv)
    local run = ADRuns.getRun(ADRunsController.store, runId)
    if run ~= nil and adEnv ~= nil then
        for _, vehicleId in ipairs(run.vehicleIds) do
            ADRunsController.stopIfRunning(ADRunsController.findVehicleById(adEnv, vehicleId), "run slettet")
        end
    end
    ADRunsController.store = ADRuns.deleteRun(ADRunsController.store, runId)
end

-- Hver ændring logges, så et klik der ikke når modellen kan ses i log.txt.
function ADRunsController.updateRun(runId, changes)
    ADRunsController.store = ADRuns.updateRun(ADRunsController.store, runId, changes)
    local run = ADRuns.getRun(ADRunsController.store, runId)
    local parts = {}
    for key, value in pairs(changes) do
        table.insert(parts, string.format("%s=%s", tostring(key), type(value) == "table" and table.concat(value, " ") or tostring(value)))
    end
    table.sort(parts)
    Logging.info(ADRunsController.LOG_PREFIX .. "run '%s': %s", run ~= nil and tostring(run.name) or tostring(runId), table.concat(parts, ", "))
end

function ADRunsController.assignVehicle(runId, vehicle)
    local id = ADRunsController.getVehicleId(vehicle)
    if id == nil then
        return nil
    end
    local store, previousRunId = ADRuns.assignVehicle(ADRunsController.store, runId, id)
    ADRunsController.store = store
    return previousRunId
end

function ADRunsController.unassignVehicle(vehicle)
    local id = ADRunsController.getVehicleId(vehicle)
    if id ~= nil then
        ADRunsController.store = ADRuns.unassignVehicle(ADRunsController.store, id)
        ADRunsController.stopIfRunning(vehicle, "fjernet fra run")
    end
end

-- ---- varer ----

function ADRunsController.getCarriableFillTypes(adEnv, vehicle)
    return adEnv.AutoDrive.getSupportedFillTypesOfAllUnitsAlphabetically(vehicle) or {}
end

-- Auto-listen: det vognen kan bære, som målet også tager. Er målet en fabrik, indsnævrer
-- findSupplyPickup selv til de ønskede produktioners inputs bagefter.
-- Run'ets mål som liste (flere stalde pr. run); gamle runs har kun targetWayPointId.
function ADRunsController.getRunTargets(run)
    if run.targetWayPointIds ~= nil and #run.targetWayPointIds > 0 then
        return run.targetWayPointIds
    end
    return run.targetWayPointId ~= nil and {run.targetWayPointId} or {}
end

local function getTargetStations(adEnv, run, farmId)
    local stations = {}
    for _, wayPointId in ipairs(ADRunsController.getRunTargets(run)) do
        local station = ADSmartPickup.getUnloadStationAtWayPointId(adEnv, wayPointId, farmId)
        if station ~= nil then
            table.insert(stations, {wayPointId = wayPointId, station = station})
        end
    end
    return stations
end

function ADRunsController.getTargetFillTypes(adEnv, run, vehicle)
    local farmId = ADSmartPickup.getFarmId(vehicle)
    -- En kørende traktor følger AD's eget mål (stateModule:getSecondMarker(), det samme
    -- choosePickup/findSupplyPickup bruger) indtil næste tur — IKKE run'ets gemte mål.
    -- Redigerer brugeren run'ets Mål mens tildelte traktorer kører, skal Auto-listen derfor
    -- følge det LIVE mål, ellers kan den blive tom og fejlagtigt smide traktoren over i
    -- mappe-logikken midt i turen. Inaktiv: union over alle run'ets mål.
    local stations = {}
    local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
    if stateModule ~= nil and stateModule.isActive ~= nil and stateModule:isActive() and stateModule.getSecondMarker ~= nil then
        local secondMarker = stateModule:getSecondMarker()
        local station = secondMarker ~= nil and secondMarker.id ~= nil and ADSmartPickup.getUnloadStationAtWayPointId(adEnv, secondMarker.id, farmId) or nil
        if station ~= nil then
            stations = {{wayPointId = secondMarker.id, station = station}}
        end
    end
    if #stations == 0 then
        stations = getTargetStations(adEnv, run, farmId)
    end
    local result, seen = {}, {}
    for _, fillType in ipairs(ADRunsController.getCarriableFillTypes(adEnv, vehicle)) do
        for _, entry in ipairs(stations) do
            if not seen[fillType] and ADSmartPickup.getStationLevelAndCapacity(entry.station, fillType, farmId) ~= nil then
                seen[fillType] = true
                table.insert(result, fillType)
            end
        end
    end
    table.sort(result)
    return result
end

function ADRunsController.getRunIngredients(adEnv, run, vehicle)
    if run.ingredientMode == "manual" then
        local result = {}
        for _, name in ipairs(run.ingredients) do
            local index = g_fillTypeManager:getFillTypeIndexByName(name)
            if index ~= nil then
                table.insert(result, index)
            end
        end
        return result
    end
    return ADRunsController.getTargetFillTypes(adEnv, run, vehicle)
end

-- Alle varer målet tager (uanset vogn) — afkrydsningslisten i GUI'et. {index, name, title}, sorteret på titel.
function ADRunsController.getTargetAcceptedFillTypes(adEnv, run)
    local farmId = g_currentMission:getFarmId()
    local stations = getTargetStations(adEnv, run, farmId)
    if #stations == 0 then
        return {}
    end
    local fillTypes = g_fillTypeManager.getFillTypes ~= nil and g_fillTypeManager:getFillTypes() or g_fillTypeManager.fillTypes or {}
    local result = {}
    for _, fillType in ipairs(fillTypes) do
        if fillType.index ~= nil then
            for _, entry in ipairs(stations) do
                if ADSmartPickup.getStationLevelAndCapacity(entry.station, fillType.index, farmId) ~= nil then
                    table.insert(result, {index = fillType.index, name = fillType.name, title = fillType.title or fillType.name})
                    break
                end
            end
        end
    end
    table.sort(result, function(a, b) return tostring(a.title) < tostring(b.title) end)
    return result
end

-- Flere mål: den stald der mangler mest lige nu (bedste rangerede behov pr. mål; et FULDT
-- læs der passer vinder). nil uden mål. Ét mål = det.
function ADRunsController.chooseTarget(adEnv, run, vehicle)
    local targets = ADRunsController.getRunTargets(run)
    if #targets <= 1 then
        return targets[1]
    end
    local farmId = ADSmartPickup.getFarmId(vehicle)
    local ingredients = ADRunsController.getRunIngredients(adEnv, run, vehicle)
    local bestId, bestNeed = nil, nil
    for _, entry in ipairs(getTargetStations(adEnv, run, farmId)) do
        local ranked = ADSmartPickup.getTargetNeedsRanked(entry.station, ingredients, farmId)
        local need = ranked[1]
        if need ~= nil and need.freeSpace >= (ADSupplyPlanner.MIN_FREE_LITERS or 1000) then
            local isBetter = bestNeed == nil
                or (need.fits == true and bestNeed.fits ~= true)
                or (need.fits == bestNeed.fits and need.score > bestNeed.score)
            if isBetter then
                bestId, bestNeed = entry.wayPointId, need
            end
        end
    end
    return bestId or targets[1]
end

-- Fire traktorer kan hedde det samme; løbenummeret er pladsen i farmens AD-køretøjsliste.
function ADRunsController.getVehicleLabel(adEnv, vehicle)
    for index, candidate in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
        if candidate == vehicle then
            return string.format("%s (#%d)", tostring(vehicle:getName()), index)
        end
    end
    return tostring(vehicle:getName())
end

-- ---- validering ----

local function getLoadCapacity(adEnv, vehicle)
    local trailers = adEnv.AutoDrive.getAllUnits(vehicle)
    if trailers == nil then
        return nil
    end
    local _, capacity = adEnv.AutoDrive.getAllFillLevels(trailers)
    return capacity ~= nil and capacity > 0 and capacity or nil
end

local function intersects(listA, listB)
    for _, a in ipairs(listA) do
        for _, b in ipairs(listB) do
            if a == b then
                return true
            end
        end
    end
    return false
end

-- reason: "noTarget" | "noTrailer" | "cannotCarry" | "farFromNetwork" (l10n-nøgler i GUI'et).
function ADRunsController.validateVehicle(adEnv, run, vehicle)
    local carriable = ADRunsController.getCarriableFillTypes(adEnv, vehicle)
    local result = {ok = false, carriable = carriable, capacity = getLoadCapacity(adEnv, vehicle)}
    local hasTarget = false
    for _, wayPointId in ipairs(ADRunsController.getRunTargets(run)) do
        if adEnv.ADGraphManager:getMapMarkerByWayPointId(wayPointId) ~= nil then
            hasTarget = true
        end
    end
    if not hasTarget then
        result.reason = "noTarget"
        return result
    end
    if result.capacity == nil then
        result.reason = "noTrailer"
        return result
    end
    if not intersects(ADRunsController.getRunIngredients(adEnv, run, vehicle), carriable) then
        result.reason = "cannotCarry"
        return result
    end
    -- AD's getDistanceFromNetwork kalder vehicle:getClosestWayPoint(), som ikke alle
    -- AD-køretøjer har (set in-game på en høster) — uden metoden springes tjekket over.
    local distance = 0
    if vehicle.getClosestWayPoint ~= nil and adEnv.ADGraphManager.getDistanceFromNetwork ~= nil then
        local ok, value = pcall(adEnv.ADGraphManager.getDistanceFromNetwork, adEnv.ADGraphManager, vehicle)
        distance = ok and value or 0
    end
    if distance == nil or distance > ADRunsController.MAX_NETWORK_DISTANCE then
        result.reason = "farFromNetwork"
        return result
    end
    result.ok = true
    return result
end

-- Vognens last som INGEN af run'ets mål tager -> {marker, fillType, liters} for en silo der gør
-- (plads >= resten, vejnet til siloen og fra siloen til målet); nil når lasten passer eller
-- ingen silo findes (så kører AD som normalt og Wait-logikken tager over).
function ADRunsController.findWrongCargoDump(adEnv, run, vehicle, targetId)
    if ADUnloadWait == nil or ADUnloadWait.getRestLoad == nil or ADLoadSwap == nil or ADLoadSwap.findDumpMarker == nil then
        return nil
    end
    local fillType, liters = ADUnloadWait.getRestLoad(adEnv, vehicle)
    if fillType == nil or liters < 100 then
        return nil
    end
    local farmId = ADSmartPickup.getFarmId(vehicle)
    for _, entry in ipairs(getTargetStations(adEnv, run, farmId)) do
        if ADSmartPickup.getStationLevelAndCapacity(entry.station, fillType, farmId) ~= nil then
            return nil
        end
    end
    local isReachable = function(markerId)
        return ADUnloadWait.hasRouteTo == nil or ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId)
    end
    local marker, why = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, liters, targetId, isReachable)
    local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
    if marker == nil then
        Logging.warning(ADRunsController.LOG_PREFIX .. "run '%s': '%s' har %.0f l %s på vognen, som målet ikke tager — %s; AutoDrive starter som normalt", tostring(run.name), tostring(vehicle:getName()), liters, tostring(fillTypeName), tostring(why))
        return nil
    end
    Logging.info(ADRunsController.LOG_PREFIX .. "run '%s': '%s' læsser først %.0f l %s af i %s (markør %s) — målet tager ikke varen", tostring(run.name), tostring(vehicle:getName()), liters, tostring(fillTypeName), tostring(marker.name), tostring(marker.markerIndex or marker.id))
    return {marker = marker, fillType = fillType, liters = liters}
end

-- ---- Start / Stop ----

-- AD gemmer indstillinger som INDEKS i values; useFolders er global, rotateTargets pr. køretøj.
-- Er indstillingen køretøjs-specifik, men køretøjet mangler sin egen settings-tabel, skrives
-- der IKKE til den globale tabel — det ville ødelægge AD's globale default for alle køretøjer.
local function setSetting(adEnv, vehicle, settingName, value)
    local global = adEnv.AutoDrive.settings[settingName]
    if global == nil then
        return
    end
    local setting = global
    if global.isVehicleSpecific then
        if vehicle.ad.settings == nil or vehicle.ad.settings[settingName] == nil then
            return
        end
        setting = vehicle.ad.settings[settingName]
    end
    for index, candidate in ipairs(setting.values) do
        if candidate == value then
            setting.current = index
            setting.new = index
            return
        end
    end
end

-- Nærmeste markør med en læssestation: kun en gyldig start — moden vælger den reelle kilde pr. tur.
local function findNearestLoadMarker(adEnv, vehicle, farmId)
    local x, _, z = getWorldTranslation(vehicle.rootNode)
    local best, bestDistance = nil, math.huge
    for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
        if ADSmartPickup.getLoadStationAtWayPointId(adEnv, marker.id, farmId) ~= nil then
            local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id)
            -- En stale markør uden waypoint skal springes over — ellers fejler Start med "error"
            -- for ALLE tildelte traktorer, ikke kun den der ramte den ugyldige markør.
            if wayPoint ~= nil then
                local dx, dz = wayPoint.x - x, wayPoint.z - z
                local distance = dx * dx + dz * dz
                if distance < bestDistance then
                    best, bestDistance = marker, distance
                end
            end
        end
    end
    return best
end

local function applyRunToVehicle(adEnv, run, vehicle, ingredients)
    local stateModule = vehicle.ad.stateModule
    local farmId = ADSmartPickup.getFarmId(vehicle)
    stateModule:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
    -- Forkert last på vognen (fx halm fra et tidligere run, mål = sukkerfabrik): første stop
    -- bliver en silo der tager varen; næste tur sætter choosePickup målet tilbage til run'ets.
    local targetId = ADRunsController.chooseTarget(adEnv, run, vehicle) or run.targetWayPointId
    local dump = ADRunsController.findWrongCargoDump(adEnv, run, vehicle, targetId)
    stateModule:setSecondMarkerByWayPointId(dump ~= nil and dump.marker.id or targetId)
    local loadMarker = findNearestLoadMarker(adEnv, vehicle, farmId)
    if loadMarker ~= nil then
        stateModule:setFirstMarkerByWayPointId(loadMarker.id)
    end
    stateModule.selectedFillTypes = copyList(ingredients)
    stateModule:setFillType(ingredients[1])
    stateModule.loopCounter = run.loops
    stateModule:setLoopsDone(0)
    setSetting(adEnv, vehicle, "useFolders", true)
    setSetting(adEnv, vehicle, "rotateTargets", adEnv.AutoDrive.RT_ONLYPICKUP)
    stateModule:raiseDirtyFlag()
end

local function isVehicleActive(vehicle)
    local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
    return stateModule ~= nil and stateModule.isActive ~= nil and stateModule:isActive()
end

-- Anvend run-tilstand OG start traktoren i ét pcall'et kald: kaster vehicle:startAutoDrive()
-- (fx AD's egen validering), skal den ene traktor fejle uden at hele startRun-loopet
-- afbrydes — ellers når de øvrige tildelte traktorer aldrig at blive startet.
-- Start præcis som AD's HUD (ADInputManager:input_start_stop): det er MODE'ens start(),
-- der opretter køreopgaverne og selv kalder startAutoDrive — startAutoDrive alene sætter
-- kun "aktiv", og traktoren bliver holdende.
local function applyAndStart(adEnv, run, vehicle, ingredients)
    applyRunToVehicle(adEnv, run, vehicle, ingredients)
    if isVehicleActive(vehicle) then
        return
    end
    local stateModule = vehicle.ad.stateModule
    local farmId = ADSmartPickup.getFarmId(vehicle)
    if stateModule.setActualFarmId ~= nil and farmId ~= nil then
        stateModule:setActualFarmId(farmId)
    end
    stateModule:setLoopsDone(0)
    local mode = stateModule.getCurrentMode ~= nil and stateModule:getCurrentMode() or nil
    if mode ~= nil and mode.start ~= nil then
        mode:start(adEnv.AutoDrive.USER_PLAYER or 1)
    else
        vehicle:startAutoDrive()
    end
    if vehicle.isServer and SpecializationUtil ~= nil and SpecializationUtil.raiseEvent ~= nil then
        SpecializationUtil.raiseEvent(vehicle, "onUpdate", 16, false, false, false)
    end
end

-- Pr. tildelt traktor: validér, skriv AD-tilstand, start. ✖-traktorer springes over.
function ADRunsController.startRun(adEnv, runId)
    local run = ADRuns.getRun(ADRunsController.store, runId)
    local results = {}
    if run == nil then
        return results
    end
    local vehiclesById = getFarmVehiclesById(adEnv)
    for _, vehicleId in ipairs(run.vehicleIds) do
        local vehicle = vehiclesById[vehicleId]
        if vehicle ~= nil then
            local validation = ADRunsController.validateVehicle(adEnv, run, vehicle)
            local result = {vehicle = vehicle, ok = validation.ok, reason = validation.reason}
            if validation.ok then
                local ingredients = ADRunsController.getRunIngredients(adEnv, run, vehicle)
                local ok, err = pcall(applyAndStart, adEnv, run, vehicle, ingredients)
                if ok then
                    Logging.info(ADRunsController.LOG_PREFIX .. "run '%s': '%s' startet mod markør %s", tostring(run.name), tostring(vehicle:getName()), tostring(run.targetWayPointId))
                else
                    result.ok, result.reason = false, "error"
                    Logging.warning(ADRunsController.LOG_PREFIX .. "run '%s': kunne ikke starte '%s': %s", tostring(run.name), tostring(vehicle:getName()), tostring(err))
                end
            end
            table.insert(results, result)
        end
    end
    return results
end

-- Som ADInputManager:input_start_stop: loops nulstilles og AD stoppes.
local function stopVehicle(vehicle)
    local stateModule = vehicle.ad.stateModule
    if stateModule.setLoopsDone ~= nil then
        stateModule:setLoopsDone(0)
    end
    vehicle:stopAutoDrive()
end

-- En kørende traktor der fjernes fra sit run (eller hvis run slettes) kører run'ets job —
-- den stoppes, så den ikke fortsætter uden run. Returnerer true hvis den blev stoppet.
function ADRunsController.stopIfRunning(vehicle, reason)
    if vehicle == nil or vehicle.ad == nil or not isVehicleActive(vehicle) then
        return false
    end
    stopVehicle(vehicle)
    Logging.info(ADRunsController.LOG_PREFIX .. "'%s' stoppet (%s)", tostring(vehicle:getName()), tostring(reason))
    return true
end

function ADRunsController.stopRun(adEnv, runId)
    local run = ADRuns.getRun(ADRunsController.store, runId)
    local stopped = 0
    if run == nil then
        return stopped
    end
    local vehiclesById = getFarmVehiclesById(adEnv)
    for _, vehicleId in ipairs(run.vehicleIds) do
        local vehicle = vehiclesById[vehicleId]
        if vehicle ~= nil and isVehicleActive(vehicle) then
            stopVehicle(vehicle)
            stopped = stopped + 1
            Logging.info(ADRunsController.LOG_PREFIX .. "run '%s': '%s' stoppet", tostring(run.name), tostring(vehicle:getName()))
        end
    end
    return stopped
end

function ADRunsController.getRunStatus(adEnv, run)
    local running = 0
    local vehiclesById = getFarmVehiclesById(adEnv)
    for _, vehicleId in ipairs(run.vehicleIds) do
        local vehicle = vehiclesById[vehicleId]
        if vehicle ~= nil and isVehicleActive(vehicle) then
            running = running + 1
        end
    end
    return {running = running, total = #run.vehicleIds}
end

-- ---- overblik ----

-- Hvad laver traktoren lige nu? {kind = "stopped"|"waiting"|"loaded"|"empty", fillType, liters, place}
-- place = Wait-markør, aflæsningsmål eller den silo moden valgte. Kun eksisterende data bruges.
function ADRunsController.getVehicleActivity(adEnv, vehicle)
    if not isVehicleActive(vehicle) then
        return {kind = "stopped"}
    end
    local wait = ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) or nil
    if wait ~= nil then
        return {kind = "waiting", fillType = wait.fillType, liters = wait.rest, place = wait.markerName}
    end
    local fillType, liters = nil, 0
    if ADUnloadWait ~= nil and ADUnloadWait.getRestLoad ~= nil then
        fillType, liters = ADUnloadWait.getRestLoad(adEnv, vehicle)
    end
    local stateModule = vehicle.ad.stateModule
    if fillType ~= nil and liters >= 100 then
        local target = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
        return {kind = "loaded", fillType = fillType, liters = liters, place = target ~= nil and target.name or nil}
    end
    local pickup = ADSmartPickup.getActivePickup ~= nil and ADSmartPickup.getActivePickup(vehicle) or nil
    if pickup ~= nil then
        return {kind = "empty", fillType = pickup.fillType, place = pickup.markerName}
    end
    local first = stateModule.getFirstMarker ~= nil and stateModule:getFirstMarker() or nil
    return {kind = "empty", place = first ~= nil and first.name or nil}
end

-- Niveauer pr. mål for run'ets varer: {{wayPointId, name, levels = {{fillType, level, capacity, free}}}}
-- i samme rangering som valget bruger (trug som én trang, fodervægt som prioritet); fulde sidst.
function ADRunsController.getTargetsLevels(adEnv, run)
    local farmId = g_currentMission:getFarmId()
    local fillTypes = {}
    if run.ingredientMode == "manual" then
        for _, name in ipairs(run.ingredients) do
            local index = g_fillTypeManager:getFillTypeIndexByName(name)
            if index ~= nil then table.insert(fillTypes, index) end
        end
    else
        for _, fillType in ipairs(ADRunsController.getTargetAcceptedFillTypes(adEnv, run)) do
            table.insert(fillTypes, fillType.index)
        end
    end
    local result = {}
    for _, entry in ipairs(getTargetStations(adEnv, run, farmId)) do
        local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(entry.wayPointId)
        local levels = {}
        for _, need in ipairs(ADSmartPickup.getTargetNeedsRanked(entry.station, fillTypes, farmId)) do
            table.insert(levels, {fillType = need.fillType, level = need.level, capacity = need.capacity, free = need.freeSpace})
        end
        table.insert(result, {wayPointId = entry.wayPointId, name = marker ~= nil and tostring(marker.name) or tostring(entry.wayPointId), levels = levels})
    end
    return result
end

-- ---- opslag til dropdowns ----

-- Mål er steder der SKAL holdes fyldt: stalde (1) og fabrikker (2). Siloer tager alt og
-- er kilder, ikke mål. Returnerer markører sorteret efter type, dernæst navn.
local function getTargetKind(station)
    local placeable = station.owningPlaceable
    if placeable == nil then
        return nil
    end
    if placeable.getHusbandryFillLevel ~= nil then
        return 1
    end
    if placeable.spec_productionPoint ~= nil then
        return 2
    end
    return nil
end

function ADRunsController.getTargetMarkers(adEnv, farmId)
    local entries = {}
    for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
        local station = ADSmartPickup.getUnloadStationAtWayPointId(adEnv, marker.id, farmId)
        local kind = station ~= nil and getTargetKind(station) or nil
        if kind ~= nil then
            table.insert(entries, {marker = marker, kind = kind})
        end
    end
    table.sort(entries, function(a, b)
        if a.kind ~= b.kind then
            return a.kind < b.kind
        end
        return tostring(a.marker.name) < tostring(b.marker.name)
    end)
    local result = {}
    for index, entry in ipairs(entries) do
        result[index] = entry.marker
    end
    return result
end

function ADRunsController.getWaitPools(adEnv)
    local counts = {}
    for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
        if ADSupplyPlanner.isWaitMarker(marker) then
            counts[marker.group] = (counts[marker.group] or 0) + 1
        end
    end
    local result = {}
    for group, count in pairs(counts) do
        table.insert(result, {group = group, count = count})
    end
    table.sort(result, function(a, b) return a.group < b.group end)
    return result
end

-- ---- gem / indlæs ----

function ADRunsController.save()
    local ok, saved = pcall(ADRunsStorage.save, ADRunsController.store)
    if not ok then
        Logging.warning(ADRunsController.LOG_PREFIX .. "kunne ikke gemme runs: %s", tostring(saved))
        return false
    end
    return saved
end

-- Køretøjs-referencer der ikke findes (solgt, andet savegame) logges; run'et beholdes.
function ADRunsController.load(adEnv)
    local ok, store = pcall(ADRunsStorage.load)
    if not ok then
        Logging.warning(ADRunsController.LOG_PREFIX .. "kunne ikke indlæse runs: %s", tostring(store))
        return
    end
    ADRunsController.store = store
    local vehiclesById = getFarmVehiclesById(adEnv)
    for _, run in ipairs(store.runs) do
        for _, vehicleId in ipairs(run.vehicleIds) do
            if vehiclesById[vehicleId] == nil then
                Logging.info(ADRunsController.LOG_PREFIX .. "run '%s': køretøj %s findes ikke (endnu) i dette savegame", tostring(run.name), tostring(vehicleId))
            end
        end
    end
end

function ADRunsController.installSaveHook()
    if ItemSystem == nil or ItemSystem.save == nil or Utils == nil then
        return
    end
    ItemSystem.save = Utils.prependedFunction(ItemSystem.save, function()
        ADRunsController.save()
    end)
end