// import com.ldartools.ktus.createAndUploadTus
// import com.ldartools.ktus.okio.OkioTusFile

val file = OkioTusFile(filePath)

httpClient.createAndUploadTus(createUrl = url, file = file, metadata = mapOf("filename" to file.name)) { 
    // optional per-request configuration
    setAuthorizationHeader(anonymous = false)
}

// import com.ldartools.ktus.createTus
// import com.ldartools.ktus.uploadTus
// import com.ldartools.ktus.okio.OkioTusFile

val file = OkioTusFile(filePath)

// 1) Create the upload on the server and get the upload URL
val uploadUrl = httpClient.createTus(createUrl = url, file = file, metadata = mapOf("filename" to file.name))

// 2) Upload the file to the returned upload URL
httpClient.uploadTus(uploadUrl = uploadUrl, file = file) {
    // optional per-request configuration
    setAuthorizationHeader(anonymous = false)
}

// import com.ldartools.ktus.TusUploadOptions
// import com.ldartools.ktus.RetryOptions

val options = TusUploadOptions(
    checkServerCapabilities = true,
    chunkSize = 4 * 1024 * 1024, // 4 MB
    useFileLock = false,
    retryOptions = RetryOptions(
        maxRetries = 5,
        initialDelayMillis = 1_000L,
        maxDelayMillis = 60_000L,
        factor = 2.0
    )
)

httpClient.createAndUploadTus(createUrl = url, file = file, options = options, onProgress = { sent, total ->
    println("Uploaded $sent / $total")
})

// Persist the uploadUrl after creation
val uploadUrl = httpClient.createTus(createUrl = url, file = file)
saveToLocalStore("pendingUploadUrl", uploadUrl)

// Later (possibly after app restart) retrieve and resume
val persisted = loadFromLocalStore("pendingUploadUrl")
if (persisted != null) {
    httpClient.uploadTus(uploadUrl = persisted, file = file)
}

httpClient.createAndUploadTus(createUrl = url, file = file, onCreate = { uploadUrl ->
    // Persist the upload URL so you can resume later if needed
    saveToLocalStore("pendingUploadUrl", uploadUrl)
}, onProgress = { sent, total ->
    println("Uploaded $sent / $total")
})

//import kotlinx.coroutines.*

val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
var persistedUploadUrl: String? = null
lateinit var uploadJob: Job

// Start (create + upload) and persist uploadUrl immediately via onCreate
fun startUpload(httpClient: HttpClient, createUrl: String, file: ITusFile, options: TusUploadOptions) {
    uploadJob = scope.launch {
        try {
            httpClient.createAndUploadTus(
                createUrl = createUrl,
                file = file,
                options = options,
                onProgress = { sent, total -> println("Uploaded $sent / $total") },
                onCreate = { url ->
                    // persist the url to disk/db if you want durable resume across restarts
                    persistedUploadUrl = url
                }
            )
        } catch (e: CancellationException) {
            // paused by caller — safe to ignore or log
        } catch (t: Throwable) {
            // handle other errors
        }
    }
}

// Pause (cancel the running job)
suspend fun pauseUpload() {
    if (::uploadJob.isInitialized && uploadJob.isActive) {
        uploadJob.cancelAndJoin() // stops the upload coroutine and waits for cleanup
    }
}

// Resume (use persistedUploadUrl)
fun resumeUpload(httpClient: HttpClient, file: ITusFile, options: TusUploadOptions) {
    val url = persistedUploadUrl ?: throw IllegalStateException("No persisted upload URL")
    scope.launch {
        try {
            httpClient.uploadTus(
                uploadUrl = url,
                file = file,
                options = options,
                onProgress = { sent, total -> println("Uploaded $sent / $total") }
            )
        } catch (e: CancellationException) {
            // paused again
        } catch (t: Throwable) {
            // handle other errors
        }
    }
}

commonMain.dependencies {
    //...
    implementation(libs.ktus)
    implementation(libs.ktus.okio)
}

/**
 * An interface abstracting the source of a file to be uploaded via TUS.
 * This allows the upload logic to be independent of whether the file is on disk,
 * in memory, or from another source.
 */
interface ITusFile {
    /** The total size of the file in bytes. */
    val size: Long

    /** The name of the file, which may be used for metadata. */
    val name: String

    /**
     * Reads a specific range of the file into a ByteReadChannel.
     * Implementations should ensure this operation is efficient and does not load
     * the entire file into memory, especially for large files.
     *
     * @param offset The byte offset to start reading from.
     * @param length The number of bytes to read.
     * @return A ByteReadChannel containing the specified section of the file.
     */
    suspend fun readSection(offset: Long, length: Long): ByteReadChannel

    /**
     * Creates a read lock on the file that will be closed when the upload is complete.
     * This is optional and helps prevent the file from being modified during an upload.
     * The returned AutoCloseable will be invoked at the end of the upload process.
     */
    suspend fun fileReadLock(): AutoCloseable
}