application/download.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "download.h"

#include "davcontroller.h"
#include "window.h"

#include <cx/printf.h>

#include "config.h"

#include "system.h"
#include "common/context.h"

#include <libidav/config.h>
#include <libidav/utils.h>


static int uithr_download_update_progress(void *data) {
    DavFileDownload *download = data;
    if(download->cancel) {
        return 1;
    }
    
    time_t t = time(NULL);
    
    char *sz_total = util_size_str(FALSE, download->progress.total_bytes);
    char *sz_downloaded = util_size_str2(FALSE, download->progress.transferred_bytes, download->progress.total_bytes, 2);
    char *sz_downloaded_end = strchr(sz_downloaded, ' ');
    if (sz_downloaded_end) {
        *sz_downloaded_end = 0;
    }
    
    if (download->progress.total_bytes > 0) {
        double progress = ((double)download->progress.transferred_bytes / (double)download->progress.total_bytes)*100;
        ui_set(download->progressbar, progress);
        download->trans.progress = progress;
        /*
        if(t > download->trans.last_update + 2) {
            snprintf(download->trans.label+download->trans.label_len, 12, " %d%%", (int)progress);
            application_update_transferlist();
            download->trans.last_update = t;
        }
        */
    }
    

    cxmutstr label1;
    if (download->progress.total_files + download->progress.total_directories > 1) {
        label1 = cx_asprintf(
            "%s/%s   %zu/%zu files",
            sz_downloaded,
            sz_total,
            download->progress.transferred_files+download->progress.transferred_directories,
            download->progress.total_files+download->progress.total_directories);
    } else {
        label1 = cx_asprintf(
            "%s/%s",
            sz_downloaded,
            sz_total);
    }
    ui_set(download->label_top_left, label1.ptr);

    free(sz_total);
    free(label1.ptr);
    
    time_t start = download->progress.speedtest_start;
    if(t >= download->progress.speedtest_start + 4) {
        uint64_t bytesPerSeconds = dav_transfer_speed(&download->progress, t);
        if(start > 0) {
            char *szps = util_size_str(FALSE, bytesPerSeconds);
            cxmutstr label3 = cx_asprintf("%s/s", szps);
            free(szps);
            ui_set(download->label_bottom_left, label3.ptr);
            free(label3.ptr);
        }
    }

    return 1;
}

static size_t ddfile_write(const void *buf, size_t size, size_t count, void *stream) {
    DDFile *file = stream;
    if(file->download->cancel) {
        return 0;
    }

    size_t w = fwrite(buf, size, count, file->fd);
    file->download->progress.current_file_transferred += w;

    file->download->progress.transferred_bytes += w;

    if (file->download->progress.current_file_transferred > file->download->progress.current_file_size) {
        size_t diff = file->download->progress.current_file_transferred - file->download->progress.current_file_size;
        file->download->progress.current_file_size = file->download->progress.current_file_transferred;
        file->download->progress.total_bytes += diff;
    }

    ui_call_mainthread(uithr_download_update_progress, file->download);

    return w;
}

static int qthr_download_resource(void *data) {
    DDFile *file = data;
    if(file->download->cancel) {
        return 0;
    }

    file->download->progress.current_file_transferred = 0;
    file->download->progress.current_file_size = file->size;

    FILE *f = sys_fopen(file->to, "wb");
    if (!f) {
        return 0;
    }
    file->fd = f;

    DavResource *res = dav_resource_new(file->download->download_sn, file->path);
    dav_get_content(res, file, (dav_write_func)ddfile_write);

    file->download->progress.transferred_files++;

    ui_call_mainthread(uithr_download_update_progress, file->download);

    dav_resource_free(res);

    fclose(f);

    free(file->path);
    free(file->to);
    free(file);

    return 0;
}

static int qthr_download_finished(void *data) {
    return 0;
}

static void uithr_download_finished(UiEvent *event, void *data) {
    DavFileDownload *download = data;
    if(download->cancel) {
        ui_set(download->label_bottom_left, "Canceled");
    }
    if(download->dialog->ref > 1) {
        ui_close(download->dialog);
    }
    ui_object_unref(download->dialog);
}


typedef struct DlStackElm {
    DavResource *resource;
    char *sub_path;
} DlStackElm;

static int jobthr_download_scan(void *data) {
    DavFileDownload *download = data;

    // check if the specified local location is a directory
    SYS_STAT s;
    if (!sys_stat(download->local_path, &s)) {
        if (S_ISDIR(s.st_mode)) {
            download->isdirectory = TRUE;
        }
    }

    CxList *stack = cxLinkedListCreateSimple(sizeof(DlStackElm));

    // add selected files to the download queue
    DavResource *res = download->reslist;
    while (res) {
        DlStackElm elm;
        elm.resource = res;
        elm.sub_path = strdup(res->name);
        cxListAdd(stack, &elm);

        res = res->next;
    }

    while (cxListSize(stack) > 0 && !download->cancel) {
        DlStackElm *elm = cxListAt(stack, 0);
        DavResource *res = elm->resource;
        char *sub_path = elm->sub_path;
        cxListRemove(stack, 0);

        if (res->iscollection) {
            if (dav_load(res)) {
                // TODO: handle error
                continue;
            }

            // update ui
            ui_call_mainthread(uithr_download_update_progress, download);
            
            char *path = util_concat_path(download->local_path, sub_path);
            int err = sys_mkdir(path);
            free(path);
            if (err) {
                // TODO: handle error
            }

            DavResource *child = res->children;
            while (child) {
                char *child_path = util_concat_path(sub_path, child->name);
                DlStackElm childelm;
                childelm.resource = child;
                childelm.sub_path = child_path;
                cxListAdd(stack, &childelm);

                child = child->next;
            }
        } else {
            // add the file to the download queue
            DDFile *file = malloc(sizeof(DDFile));
            file->download = download;
            file->path = strdup(res->path);
            file->size = res->contentlength;
            if (download->isdirectory) {
                file->to = util_concat_path(download->local_path, sub_path);
            } else {
                file->to = strdup(download->local_path);
            }

            // stats
            download->progress.total_files++;
            download->progress.total_bytes += res->contentlength;

            // update ui
            ui_call_mainthread(uithr_download_update_progress, download);

            ui_threadpool_job(download->queue, download->dialog, qthr_download_resource, file, NULL, NULL);
        } 
    }
    
    ui_threadpool_job(download->queue, download->dialog, qthr_download_finished, download, uithr_download_finished, download);

    cxListDestroy(stack);

    return 0;
}

static void uithr_download_scan_finished(UiEvent *event, void *data) {
    DavFileDownload *download = data;

}

void action_download_cancel(UiEvent *event, void *data) {
    DavFileDownload *download = event->window;
    if(!download->cancel) {
        ui_set(download->label_bottom_left, "Cancel...");
        download->cancel = TRUE;
    }
}

static void dav_file_download_cleanup(DavFileDownload *download) {
    application_remove_transfer(&download->trans);
    ui_object_unref(download->browser->window);
}

DavFileDownload* dav_download_create(DavBrowser *browser, UiObject *dialog, DavResource *reslist, const char *local_path) {
    UiContext *ctx = dialog->ctx;
    CxMempool *mp = ui_cx_mempool(ctx);
    DavFileDownload *download = ui_malloc(ctx, sizeof(DavFileDownload));
    memset(download, 0, sizeof(DavFileDownload));
    download->dialog = dialog;
    dialog->window = download;
    ui_object_ref(dialog);
    ui_object_ref(browser->window);
    
    size_t label_len = strlen(reslist->name) + 16;
    download->trans.label = cxCalloc(mp->allocator, label_len, 1);
    download->trans.label_len = snprintf(download->trans.label, label_len, "< %s%s", reslist->name, reslist->next ? " ..." : "");
    download->trans.window = dialog;
    
    download->browser = browser;
    download->sn = reslist->session;
    download->download_sn = dav_session_clone(download->sn);
    download->reslist = reslist; // TODO: is this safe or do we need a copy?
    download->local_path = ui_strdup(dialog->ctx, local_path);

    download->queue = ui_threadpool_create(1);
    
    cxMempoolRegister(mp, download->download_sn, (cx_destructor_func)dav_session_destroy);
    cxMempoolRegister(mp, download->queue, (cx_destructor_func)ui_threadpool_destroy);
    cxMempoolSetDestructor(download, (cx_destructor_func)dav_file_download_cleanup);
    
    download->progressbar = ui_double_new(ctx, "progressbar");
    download->label_top_left = ui_string_new(ctx, "label_top_left");
    download->label_top_right = ui_string_new(ctx, "label_top_right");
    download->label_bottom_left = ui_string_new(ctx, "label_bottom_left");
    download->label_bottom_right = ui_string_new(ctx, "label_bottom_right");
    
    ui_set(download->label_top_left, "");
    ui_set(download->label_top_right, "");
    ui_set(download->label_bottom_left, "");
    ui_set(download->label_bottom_right, "");
    ui_set(download->progressbar, 0);
    
    return download;
}

void dav_download_start(DavFileDownload *download) {
    ui_show(download->dialog);
    ui_job(download->dialog, jobthr_download_scan, download, uithr_download_scan_finished, download);
}