/*
    uploadui.js

    The transfer panel (#uploadTab): one row per upload task, a running total
    and the panel level controls.

    upload.js and download.js drive this file through a small API rather than
    reaching into the row markup themselves:

        appendUploadFileItem(name, size)   -> taskUUID, adds a pending row
        registerUploadTransfer(uuid, h)    -> hand over {abort, pause, resume}
        setUploadTaskProgress(uuid, l, t)  -> bytes moved, drives bar/ETA/total
        setUploadTaskState(uuid, state)    -> pending|uploading|processing|
                                              paused|done|failed
        setUploadTaskStatusText(uuid, s)   -> override the right hand label
        setUploadTaskPercentage(uuid, p)   -> progress of a task that reports a
                                              percentage rather than bytes
                                              (server side zipping)
        setUploadTaskDoneLink(uuid, ...)   -> put a text link on the finished
                                              row, for a download the browser
                                              may have blocked

    Part of the ArozOS File Manager. Loaded as a plain script from
    file_explorer.html - see the <script> block at the end of that file.
*/

function getUploadTaskByID(taskUUID){
    var task = undefined;
    $("#uploadTab").find(".uploadTask").each(function(){
        if ($(this).attr("taskid") == taskUUID){
            task = $(this);
        }
    });

    return task;
}

/*
    Row creation
*/

function appendUploadFileItem(filename, filesize){
    var newuuid = uuidv4();

    //A negative size means the total is not known up front (zip preparation,
    //where the server streams without announcing a length)
    var knownSize = !(filesize < 0 || isNaN(filesize));

    uploadTaskInfo.set(newuuid, {
        name: filename,
        size: knownSize ? filesize : -1,
        loaded: 0,
        state: "pending",
        speed: 0,
        lastLoaded: 0,
        lastTime: Date.now(),
        statusOverride: null,
        //Set instead of size/loaded by a task the server reports in percent
        percent: null,
        //{label, url, filename} shown in place of the completed tick
        doneLink: null
    });

    $("#uploadProgressList").append(`<div class="uploadTask pending" taskID="${newuuid}">
        <div class="uploadTaskName"></div>
        <div class="uploadTaskMeta">
            <span class="uploadTaskSize"></span>
            <span class="uploadTaskDoneLink" onclick="onUploadTaskDoneLink('${newuuid}');"></span>
            <span class="uploadTaskStatus"></span>
            <span class="uploadTaskRetry" onclick="onUploadTaskButton('${newuuid}');"></span>
        </div>
        <div class="uploadTaskActions">
            <div class="uploadTaskCancel" onclick="cancelUploadTask('${newuuid}');">${FSIcons.closeCircle}</div>
            <div class="uploadTaskAction" onclick="onUploadTaskButton('${newuuid}');"></div>
        </div>
        <div class="uploadTaskBar"><div class="uploadTaskBarFill"></div></div>
    </div>`);

    //Set as text, not html: a filename may legitimately contain angle brackets
    let row = getUploadTaskByID(newuuid);
    row.find(".uploadTaskName").text(filename).attr("title", filename);
    //Visibility is driven purely by the row's state class in CSS, so this
    //button never needs touching again - no per-tick DOM writes on it
    row.find(".uploadTaskCancel").attr("title", applocale.getString("upload/cancel", "Cancel"));

    //A new task brings the panel back, unless a dialog is holding that corner
    if (!$(".popup").is(":visible")){
        uploadPanelCollapsed = false;
    }
    renderUploadTask(newuuid);
    updateUploadFileCount();
    return newuuid;
}

/*
    Transfer handles

    A handle is {abort, pause, resume, pausable}. pause/resume are optional -
    the plain POST upload mode cannot suspend an in-flight XHR, so its rows
    offer cancel instead of pause.
*/

function registerUploadTransfer(taskUUID, handle){
    uploadTransferMap.set(taskUUID, handle);
    renderUploadTask(taskUUID);
}

function unregisterUploadTransfer(taskUUID){
    uploadTransferMap.delete(taskUUID);
}

/*
    Progress and state
*/

function setUploadTaskProgress(taskUUID, loaded, total){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }

    if (total !== undefined && total > 0){
        info.size = total;
    }
    info.loaded = loaded;

    //Exponentially smoothed throughput. A raw delta jumps around far too much
    //for a "time left" label that is meant to be readable.
    let now = Date.now();
    let dt = (now - info.lastTime) / 1000;
    if (dt >= 0.4){
        let instant = (loaded - info.lastLoaded) / dt;
        if (instant < 0){
            instant = 0;
        }
        info.speed = info.speed > 0 ? (info.speed * 0.7 + instant * 0.3) : instant;
        info.lastLoaded = loaded;
        info.lastTime = now;
    }

    if (info.state == "pending"){
        info.state = "uploading";
    }

    renderUploadTask(taskUUID);
    updateUploadSummary();
}

function setUploadTaskState(taskUUID, state){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }
    info.state = state;
    if (state == "done" && info.size > 0){
        info.loaded = info.size;
    }
    if (state != "processing"){
        info.statusOverride = null;
    }
    renderUploadTask(taskUUID);
    updateUploadFileCount();
}

function setUploadTaskStatusText(taskUUID, text){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }
    info.statusOverride = text;
    renderUploadTask(taskUUID);
}

/*
    Progress of a task whose total is not counted in bytes.

    Server side zipping reports how far it is as a percentage of the files it
    has packed, with no byte figure that would mean anything to the panel, so
    such a task carries a percentage instead of a loaded/total pair.
*/
function setUploadTaskPercentage(taskUUID, percent){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }
    if (!isFinite(percent)){
        return;
    }
    info.percent = Math.max(0, Math.min(100, percent));
    renderUploadTask(taskUUID);
    updateUploadSummary();
}

/*
    Put a text link on a completed task, in place of its tick.

    A download that starts on its own is exactly what pop-up blockers stop, and
    when they do the row would otherwise only say "Completed" with no way to get
    at the file. The link is that way out - it runs from a real click, which no
    browser blocks. It sits at the left of the status line, opposite the label,
    rather than in the button column where it would read as a stray word.
*/
function setUploadTaskDoneLink(taskUUID, label, url, filename){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }
    info.doneLink = {label: label, url: url, filename: filename};
    renderUploadTask(taskUUID);
}

function onUploadTaskDoneLink(taskUUID){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined || !info.doneLink){
        return;
    }
    generateDownloadFromURL(info.doneLink.url, info.doneLink.filename);
}

/*
    Rendering
*/

/*
    The shared bytesToSize() drops trailing zeros, so a panel showing several
    transfers ends up mixing "2 MB", "121.2 MB" and "52.32 MB". Every number in
    this panel is fixed at one decimal place instead so the columns line up.

    Units are the short forms ("MB", not "Megabytes") because each one is boxed
    at a fixed width below and a five character "Bytes" would reserve a visible
    gap on every row.
*/
function splitUploadBytes(bytes){
    var sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'];
    if (!(bytes > 0)){
        return {value: "0.0", unit: sizes[0]};
    }
    var i = Math.floor(Math.log(bytes) / Math.log(1024));
    if (i >= sizes.length){
        i = sizes.length - 1;
    }
    return {value: (bytes / Math.pow(1024, i)).toFixed(1), unit: sizes[i]};
}

/*
    A counter that reflows on every progress tick is unreadable, and a single
    fixed width box around the whole "121.2 MB" string does not fix it: the
    number still moves inside the box as it grows, and it drags the unit with
    it. So the number, the unit and the "/" each get their own fixed width cell
    - the number right aligned so its ones column never moves, the unit left
    aligned so it starts at the same x whatever the number did. Combined with
    tabular figures (in a proportional font "1" is narrower than "8"), every
    glyph position is then stable across updates.
*/
function formatUploadBytesHTML(bytes){
    let parts = splitUploadBytes(bytes);
    return '<span class="uploadNum">' + parts.value + '</span>' +
           '<span class="uploadUnit">' + parts.unit + '</span>';
}

function formatUploadEta(seconds){
    if (!isFinite(seconds) || seconds <= 0){
        return "";
    }
    if (seconds < 60){
        return applocale.getString("upload/eta/seconds", "%d sec left").replace("%d", Math.max(1, Math.round(seconds)));
    }
    if (seconds < 3600){
        return applocale.getString("upload/eta/minutes", "%d min left").replace("%d", Math.round(seconds / 60));
    }
    return applocale.getString("upload/eta/hours", "%d hr left").replace("%d", Math.round(seconds / 3600));
}

/*
    How far along a task is, in percent.

    Bytes where they are known, the server reported percentage otherwise, and a
    finished task is always a full bar - a zip whose last file was packed after
    the final progress report would otherwise stop just short of the end.
*/
function uploadTaskPercentage(info){
    if (info.state == "done"){
        return 100;
    }
    if (info.size > 0){
        return Math.min(100, info.loaded / info.size * 100);
    }
    if (info.percent !== null && info.percent !== undefined){
        return info.percent;
    }
    return 0;
}

function renderUploadTask(taskUUID){
    let info = uploadTaskInfo.get(taskUUID);
    let row = getUploadTaskByID(taskUUID);
    if (info === undefined || row === undefined){
        return;
    }

    let knownSize = info.size > 0;
    let hasPercent = info.percent !== null && info.percent !== undefined;
    let percentage = uploadTaskPercentage(info);

    //Only a task that reports neither bytes nor a percentage has nothing to
    //fill a bar with, and it sweeps instead
    let indeterminate = !knownSize && !hasPercent && info.state != "done" && info.state != "failed";
    let showDoneLink = info.state == "done" && info.doneLink != null;
    row.attr("class", "uploadTask " + info.state +
        (indeterminate ? " indeterminate" : "") +
        (showDoneLink ? " withDoneLink" : ""));
    row.find(".uploadTaskBarFill").css("width", indeterminate ? "" : percentage + "%");

    //Keep the list ordered: finished rows on top, in progress next, queued last
    let rank = uploadRowRank(info.state);
    if (row.attr("data-rank") != String(rank)){
        row.attr("data-rank", rank);
        placeUploadRow(row[0], rank);
    }

    //Byte counter. Without a known total there is nothing meaningful to divide by.
    let sizeHTML = "";
    if (knownSize){
        sizeHTML = formatUploadBytesHTML(info.loaded) +
                   '<span class="uploadSep">/</span>' +
                   formatUploadBytesHTML(info.size);
    }else if (info.loaded > 0){
        sizeHTML = formatUploadBytesHTML(info.loaded);
    }
    row.find(".uploadTaskSize").html(sizeHTML);

    //Right hand label
    let statusText = "";
    if (info.statusOverride){
        statusText = info.statusOverride;
    }else if (info.state == "done"){
        statusText = applocale.getString("upload/completed", "Completed");
    }else if (info.state == "failed"){
        statusText = applocale.getString("upload/failed", "Failed");
    }else if (info.state == "paused"){
        statusText = applocale.getString("upload/paused", "Paused");
    }else if (info.state == "pending"){
        statusText = applocale.getString("upload/waiting", "Waiting");
    }else if (info.state == "processing"){
        //"45%" says more than "Processing" once the server reports progress
        statusText = hasPercent ? Math.round(info.percent) + "%" :
                     applocale.getString("upload/processing", "Processing");
    }else if (knownSize && info.speed > 0){
        statusText = formatUploadEta((info.size - info.loaded) / info.speed);
    }
    row.find(".uploadTaskStatus").text(statusText);

    //A failed row offers a "Retry" text link after the status instead of a round button
    let retryEl = row.find(".uploadTaskRetry");
    let retryText = info.state == "failed" ? applocale.getString("upload/retry", "Retry") : "";
    if (retryEl.text() != retryText){
        retryEl.text(retryText);
    }

    //The other half of that line: the download link of a finished download.
    //Written only when it changes, for the same reason the glyph below is.
    let linkEl = row.find(".uploadTaskDoneLink");
    if (showDoneLink && linkEl.text() != info.doneLink.label){
        linkEl.text(info.doneLink.label);
    }

    /*
        Round button on the right, chosen from the state rather than the handle.

        A finished row has no control left to offer, and the tick that used to
        stand there said nothing the row's own label does not already say, so
        CSS hides the button on .done and nothing is drawn into it.
    */
    if (info.state == "done"){
        return;
    }

    let handle = uploadTransferMap.get(taskUUID);
    let iconName = "closeCircle";
    let btnTitle = applocale.getString("upload/cancel", "Cancel");
    if (info.state == "failed"){
        iconName = "refresh";
        btnTitle = applocale.getString("upload/retry", "Retry");
    }else if (info.state == "paused"){
        iconName = "playCircle";
        btnTitle = applocale.getString("upload/resume", "Resume");
    }else if (handle && handle.pausable){
        iconName = "pauseCircle";
        btnTitle = applocale.getString("upload/pause", "Pause");
    }
    /*
        Only touch the button when the glyph actually changes.

        This runs on every progress update - many times a second during a real
        upload - and rewriting the innerHTML destroys the <svg> the pointer is
        currently pressing. A click is only synthesised when mousedown and
        mouseup share a target, so a press that spans one of these rewrites is
        silently swallowed: the button appeared to work only every few clicks.

        The icon depends on state, not on bytes moved, so this is nearly always
        a no-op.
    */
    let actionBtn = row.find(".uploadTaskAction");
    if (actionBtn.attr("data-icon") != iconName){
        actionBtn.attr("data-icon", iconName).html(FSIcons[iconName]);
    }
    if (actionBtn.attr("title") != btnTitle){
        actionBtn.attr("title", btnTitle);
    }
}

/*
    Row ordering: 0 finished (done / failed), 1 in progress, 2 queued.

    Only the row whose group changed is moved, to the end of its new group, so
    a state change costs one scan rather than a re-sort of the whole list.
*/
function uploadRowRank(state){
    if (state == "done" || state == "failed"){
        return 0;
    }
    return state == "pending" ? 2 : 1;
}

function placeUploadRow(rowEl, rank){
    let list = document.getElementById("uploadProgressList");
    if (list == null || rowEl.parentNode !== list){
        return;
    }
    //Insert before the first row of a later group
    let before = null;
    if (rank < 2){
        for (var el = list.firstElementChild; el !== null; el = el.nextElementSibling){
            if (el !== rowEl && Number(el.getAttribute("data-rank")) > rank){
                before = el;
                break;
            }
        }
    }
    if (before === null){
        if (list.lastElementChild !== rowEl){
            list.appendChild(rowEl);
        }
    }else if (before !== rowEl.nextElementSibling){
        list.insertBefore(rowEl, before);
    }
}

/*
    Panel level chrome
*/

function updateUploadSummary(){
    let loaded = 0;
    let total = 0;
    let hasUnknown = false;
    let percentSum = 0;
    let taskCount = 0;
    uploadTaskInfo.forEach(function(info){
        loaded += info.loaded;
        if (info.size > 0){
            total += info.size;
        }else{
            hasUnknown = true;
        }
        percentSum += uploadTaskPercentage(info);
        taskCount++;
    });

    /*
        With every size known the overall figure is bytes moved over bytes in
        total, so the ring and the percentage agree with the byte counter next
        to them. A zip task has no size to weigh, so once one is in the list
        every task counts the same instead.
    */
    let bytesKnown = total > 0 && !hasUnknown;
    let overall = 0;
    if (bytesKnown){
        overall = Math.min(100, loaded / total * 100);
    }else if (taskCount > 0){
        overall = percentSum / taskCount;
    }
    setUploadSummaryRing(overall);

    //Floored, so 100% only ever shows once everything is actually through
    let pctHTML = '<span class="uploadPct">' + Math.floor(overall) + '%</span>';

    //The %s slots get the same boxed number markup as the rows. The literal
    //text around them comes from the locale file and never changes width.
    let html = "";
    if (bytesKnown){
        html = applocale.getString("upload/total", "Total: %s / %s")
                .replace("%s", formatUploadBytesHTML(loaded))
                .replace("%s", formatUploadBytesHTML(total)) + pctHTML;
    }else if (loaded > 0){
        html = formatUploadBytesHTML(loaded) + pctHTML;
    }else if (taskCount > 0){
        //Nothing to count in bytes - a zip task only ever reports a percentage
        html = Math.round(overall) + "%";
    }
    $("#uploadSummaryText").html(html);
}

/*
    The ring in the summary row.

    It replaces what used to be a cloud upload glyph: the panel carries server
    side tasks as well as uploads now, so the icon says how far the work is
    rather than what kind of work it is. The arc is the second circle of the
    taskProgress icon in shared/fsicons.js, drawn from its 12 o'clock position.
*/
function setUploadSummaryRing(percent){
    let arc = document.querySelector("#uploadSummaryIcon .taskProgressArc");
    if (arc == null){
        return;
    }
    //Circumference of the icon's r=9 circle in its 24x24 box
    let circumference = 56.5;
    let filled = Math.max(0, Math.min(100, percent)) / 100 * circumference;
    arc.setAttribute("stroke-dasharray", filled.toFixed(1) + " " + circumference);
}

function updateUploadFileCount(){
    let active = 0;
    uploadTaskInfo.forEach(function(info){
        if (info.state != "done" && info.state != "failed"){
            active++;
        }
    });

    //Uploads are not the only thing that rides this panel - a folder download
    //zips server side first - so the title names tasks rather than uploads
    let title = "";
    if (active > 0){
        title = applocale.getString("upload/title", "%d tasks in progress").replace("%d", active);
    }else{
        title = applocale.getString("upload/titleDone", "%d tasks completed").replace("%d", $(".uploadTask").length);
    }
    $("#uploadHeaderTitle").text(title);

    updateUploadSummary();
    trimFinishedUploadRows();
    applyUploadPanelVisibility();

    //Fired from here rather than from setUploadTaskProgress: this runs when a
    //task is added or changes state, which is exactly when the active row moves
    scrollActiveUploadIntoView();
}

/*
    Panel and its collapsed stand-in

    The panel and #fmUploadListBtn are two views of one thing, so both are
    resolved here from the task list rather than toggled at each call site.
    The button exists whenever there is anything to show - collapsing does not
    throw the list away, it just parks it in the status bar - and it pulses
    while a transfer is still moving so background progress stays noticeable.
*/
function applyUploadPanelVisibility(){
    let taskCount = $(".uploadTask").length;
    /*
        Paused counts as unfinished, not as idle: the tray button is the only
        reminder that a transfer is still open once the panel is collapsed, and
        an upload someone paused is exactly the one worth being reminded about.
    */
    let transferring = false;
    uploadTaskInfo.forEach(function(info){
        if (info.state == "uploading" || info.state == "processing" ||
            info.state == "pending" || info.state == "paused"){
            transferring = true;
        }
    });

    if (taskCount == 0){
        //Nothing left to show: the panel and its button both go away, and the
        //next batch opens as the full list again
        $("#uploadTab").hide();
        $("#fmUploadListBtn").hide();
        uploadPanelCollapsed = false;
        uploadPanelCompact = false;
        $("#uploadTab").removeClass("compact");
        return;
    }

    let expanded = !uploadPanelCollapsed;
    //The panel floats just above the status bar, whose height varies with the
    //layout (the narrow screen bar is shorter), so it is measured, not assumed
    let statusBarHeight = $("#fmStatusBar").is(":visible") ? $("#fmStatusBar").outerHeight() : 0;
    document.getElementById("uploadTab").style.setProperty("--fm-statusbar-h", statusBarHeight + "px");
    $("#uploadTab").toggleClass("compact", uploadPanelCompact);
    $("#uploadTab").toggle(expanded);
    $("#fmUploadListBtn").css("display", "");
    $("#fmUploadListBtn").toggleClass("active", expanded);
    $("#fmUploadListBtn").toggleClass("transferring", transferring);
}

/*
    A few thousand queued files used to be handled by fading each row out one
    second after it completed. The panel now keeps completed rows so they can
    be reviewed, so cap how many of them accumulate instead.
*/
function trimFinishedUploadRows(){
    let finished = $("#uploadProgressList").find(".uploadTask.done");
    let excess = finished.length - MAX_FINISHED_UPLOAD_ROWS;
    for (var i = 0; i < excess; i++){
        let row = $(finished[i]);
        forgetUploadTask(row.attr("taskid"));
        row.remove();
    }
}

function onUploadTaskButton(taskUUID){
    let info = uploadTaskInfo.get(taskUUID);
    if (info === undefined){
        return;
    }
    let handle = uploadTransferMap.get(taskUUID);

    if (info.state == "done"){
        //The glyph is a status indicator, not a button
        return;
    }else if (info.state == "failed"){
        retryUploadFile(taskUUID);
    }else if (info.state == "paused"){
        if (handle && handle.resume){
            handle.resume();
            setUploadTaskState(taskUUID, "uploading");
        }
    }else if (handle && handle.pausable && handle.pause){
        handle.pause();
        setUploadTaskState(taskUUID, "paused");
    }else{
        cancelUploadTask(taskUUID);
    }
}

function cancelUploadTask(taskUUID){
    let handle = uploadTransferMap.get(taskUUID);
    if (handle && handle.abort){
        handle.abort();
    }
    uploadTransferMap.delete(taskUUID);

    //Drop it from the pending queue if it never started
    for (var i = 0; i < uploadPendingList.length; i++){
        if (uploadPendingList[i].UUID == taskUUID){
            uploadPendingList.splice(i, 1);
            break;
        }
    }

    forgetUploadTask(taskUUID);
    let row = getUploadTaskByID(taskUUID);
    if (row !== undefined){
        row.fadeOut("fast", function(){
            $(this).remove();
            updateUploadFileCount();
        });
    }else{
        updateUploadFileCount();
    }
}

function retryUploadFile(taskUUID){
    let retryInfo = uploadRetryMap.get(taskUUID);
    if (!retryInfo){
        console.warn("[Upload] No retry info found for task " + taskUUID);
        return;
    }

    let info = uploadTaskInfo.get(taskUUID);
    if (info !== undefined){
        info.loaded = 0;
        info.speed = 0;
        info.lastLoaded = 0;
        info.lastTime = Date.now();
    }
    setUploadTaskState(taskUUID, "pending");

    //Re-queue the file for upload using the same task UUID
    uploadFile(retryInfo.file, taskUUID, retryInfo.targetDir);
}

/*
    Drop every trace of a task.

    A row is not the only thing a task owns: uploadTransferMap holds a closure
    over its socket and File, and uploadRetryMap holds the File itself so retry
    can work. Removing the row without these leaves both alive with nothing left
    that can reach them.
*/
function forgetUploadTask(taskUUID){
    uploadTaskInfo.delete(taskUUID);
    uploadTransferMap.delete(taskUUID);
    uploadRetryMap.delete(taskUUID);
}

function clearCompletedUploads(){
    $("#uploadProgressList").find(".uploadTask.done, .uploadTask.failed").each(function(){
        forgetUploadTask($(this).attr("taskid"));
        $(this).remove();
    });
    updateUploadFileCount();
}

function cancelAllUploads(){
    //Snapshot first: cancelUploadTask mutates both the map and the queue
    let ids = [];
    uploadTaskInfo.forEach(function(info, uuid){
        if (info.state != "done"){
            ids.push(uuid);
        }
    });
    uploadPendingList = [];
    ids.forEach(function(uuid){
        cancelUploadTask(uuid);
    });
}

/*
    Keep the in-flight transfer on screen

    Completed rows stay in the list, so in a long queue the active row keeps
    drifting downwards out of view. Called on state changes rather than on every
    progress tick: the active row only moves when a task starts or finishes, and
    scrolling on each tick would fight the user constantly.
*/
function bindUploadListScroll(){
    let list = document.getElementById("uploadProgressList");
    if (list == null){
        return;
    }
    list.addEventListener("scroll", function(){
        if (Math.abs(list.scrollTop - uploadListAutoScrollTop) < 1){
            //Where this file just scrolled to, so this event is its own
            return;
        }
        uploadListUserScrolledAt = Date.now();
    });
}

function scrollActiveUploadIntoView(){
    let list = document.getElementById("uploadProgressList");
    let panel = document.getElementById("uploadTab");
    if (list == null || panel == null){
        return;
    }
    //Nothing to bring into view while the panel is collapsed to the status bar
    if (getComputedStyle(panel).display == "none" || getComputedStyle(list).display == "none"){
        return;
    }
    if (Date.now() - uploadListUserScrolledAt < UPLOAD_FOLLOW_PAUSE_MS){
        //The user is reading the list - leave it alone
        return;
    }

    //The first row that has not finished is the one worth watching
    let active = null;
    let rows = list.querySelectorAll(".uploadTask");
    for (var i = 0; i < rows.length; i++){
        if (!rows[i].classList.contains("done") && !rows[i].classList.contains("failed")){
            active = rows[i];
            break;
        }
    }
    if (active == null){
        return;
    }

    //Rows are kept in finished / in progress / queued order, so this row is the
    //first in-progress one: line its top edge up with the top of the list
    let delta = active.getBoundingClientRect().top - list.getBoundingClientRect().top;
    if (Math.abs(delta) < 1){
        return;
    }

    /*
        scrollTop rather than scrollIntoView: the latter also scrolls every
        scrollable ancestor, which would drag the file list behind the panel.
    */
    list.scrollTop += delta;
    //Read back rather than reusing the requested value - the browser clamps it
    uploadListAutoScrollTop = list.scrollTop;
}

/*
    Park the panel in the tray while a dialog is open.

    A file operation dialog occupies the same bottom right corner, so the two
    would otherwise sit on top of each other. The transfers keep running and the
    status bar button keeps pulsing, so progress is still visible.
*/
function collapseUploadPanelForDialog(){
    if ($(".uploadTask").length == 0){
        return;
    }
    uploadPanelCollapsed = true;
    applyUploadPanelVisibility();
}

/*
    Minimize: shrink the panel in place to a compact card that keeps only the
    progress ring and the running total, with maximize and close beside them.
    The tasks keep running, and the choice sticks until the list empties, so
    reopening from the status bar or a new upload brings back the same view.
*/
function toggleUploadMinimize(){
    uploadPanelCompact = true;
    uploadPanelCollapsed = false;
    applyUploadPanelVisibility();
}

//Maximize: back from the compact card to the full task list
function restoreUploadPanel(){
    uploadPanelCompact = false;
    uploadPanelCollapsed = false;
    applyUploadPanelVisibility();
    //The list was hidden, so the in-flight row may be out of view
    uploadListUserScrolledAt = 0;
    scrollActiveUploadIntoView();
}

//The status bar button: expands the parked panel, or collapses it again
function toggleUploadPanel(){
    uploadPanelCollapsed = !uploadPanelCollapsed;
    applyUploadPanelVisibility();
    if (!uploadPanelCollapsed){
        //Re-expanded from the status bar - put the in-flight row back in sight
        uploadListUserScrolledAt = 0;
        scrollActiveUploadIntoView();
    }
}

/*
    Close. With every task completed there is nothing left to come back to, so
    the list is cleared and the panel goes away with its status bar button.
    Otherwise it hides to the status bar, where the transfers keep running. A
    failed task counts as unfinished: clearing it would throw away its Retry.
*/
function closeUploadTab(){
    let allCompleted = uploadTaskInfo.size > 0;
    uploadTaskInfo.forEach(function(info){
        if (info.state != "done"){
            allCompleted = false;
        }
    });

    if (allCompleted){
        clearCompletedUploads();
        return;
    }
    uploadPanelCollapsed = true;
    applyUploadPanelVisibility();
}

/*
    Kept for compatibility: older call sites remove a row by passing the clicked
    element. The task UUID is the part that actually matters.
*/
function removeThisTask(object, taskUUID){
    cancelUploadTask(taskUUID);
}


/*
    Reachable from outside this file: inline on* attributes in the markup,
    handlers generated in template strings, or another frame. Renaming any
    of these means updating those call sites too.
*/
window.removeThisTask = removeThisTask;
window.retryUploadFile = retryUploadFile;
window.toggleUploadMinimize = toggleUploadMinimize;
window.restoreUploadPanel = restoreUploadPanel;   // the compact card's maximize button
window.toggleUploadPanel = toggleUploadPanel;   // the status bar button
window.collapseUploadPanelForDialog = collapseUploadPanelForDialog;
window.closeUploadTab = closeUploadTab;
window.clearCompletedUploads = clearCompletedUploads;
window.cancelAllUploads = cancelAllUploads;
window.onUploadTaskButton = onUploadTaskButton;
window.onUploadTaskDoneLink = onUploadTaskDoneLink;   // the "Download again" link
window.cancelUploadTask = cancelUploadTask;   // the paused row's cancel button