// build.gradle.kts
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.mohamadkaramidarabi:uploader-api:0.1.8")
        }
    }
}

import ir.sharif.drive.uploader.api.IUploader
import ir.sharif.drive.uploader.models.*
import ir.sharif.drive.uploader.models.CloudPath.Companion.cloudPath
import ir.sharif.drive.uploader.models.FileName.Companion.fileName
import ir.sharif.drive.uploader.models.FilePath.Companion.filePath
import ir.sharif.drive.uploader.models.FileSize.Companion.fileSize

// 1. Initialize (once)
val uploader = IUploader.init(
    startUpload = { size, metaData ->
        // Call your backend → return upload id, key, chunk size, signed URLs
        myApi.startUpload(size, metaData)
    },
    putChunk = { signedUrl, chunkData, contentLength ->
        // PUT chunk to signed URL → return ETag (without quotes)
        myApi.putChunk(signedUrl, chunkData, contentLength)
    },
    completeUpload = { request ->
        // Tell your backend all parts are uploaded
        myApi.completeUpload(request)
    },
    cancelUpload = { uploadInfo ->
        // Optional: notify backend to abort multipart upload
        myApi.cancelUpload(uploadInfo)
    },
    fileReaderContext = platformContext, // see Platform setup below
)

// 2. Enqueue files
uploader.upload(
    listOf(
        UploadRequest(
            fileName = "photo.jpg".fileName,
            filePath = "/path/or/uri".filePath,
            fileSize = 5_242_880L.fileSize,
            folderId = null,
            cloudPath = "/uploads".cloudPath,
            versionGroup = null,
            metaData = null,
        ),
    ),
)

// 3. Observe uploads
uploader.getAllUploadInfos().collect { uploads ->
    uploads.forEach { info ->
        println("${info.name.value}: ${info.state}")
    }
}

data class StartUploadResponse(
    val uploadId: String,
    val key: String,
    val chunkSize: Long,
    val links: List<String>, // signed PUT URLs, one per chunk
)

data class UploadRequest(
    val fileName: FileName,   // display name
    val filePath: FilePath,   // platform-specific path (see Platform setup)
    val fileSize: FileSize,   // total bytes
    val folderId: FolderId?, // destination folder on cloud (optional)
    val cloudPath: CloudPath,  // logical cloud path
    val versionGroup: String?,
    val metaData: String?,     // passed to startUpload
)

"file.pdf".fileName
"/storage/emulated/0/Download/file.pdf".filePath
contentUri.toString().filePath          // Android
"web-file://1".filePath                 // Web
1_048_576L.fileSize
"/drive/folder".cloudPath

uploader.getAllUploadInfos().collect { uploads ->
    uploads.forEach { info ->
        val total = info.chunkCount?.value ?: return@forEach
        val done = info.links.count { it.state == States.Link.State.SUCCESS }
        println("${info.name.value}: $done / $total chunks")
    }
}

IUploader.init(
    // ...
    fileReaderContext = applicationContext,
)

UploadRequest(
    filePath = contentUri.toString().filePath,
    // ...
)

import ir.sharif.drive.uploader.api.ensureUploadNotificationsEnabled
import ir.sharif.drive.uploader.upload.UploadNotificationPermissionHost
import ir.sharif.drive.uploader.upload.UploadNotificationPermissions

// In Activity.onCreate:
UploadNotificationPermissionHost.activity = this
UploadNotificationPermissionHost.launcher = permissionLauncher
UploadNotificationPermissions.requestIfNeeded(this, permissionLauncher)

// Before starting uploads:
ensureUploadNotificationsEnabled()

fileReaderContext = Any()

UploadRequest(
    filePath = "/Users/me/Documents/file.zip".filePath,
    // ...
)

import ir.sharif.drive.uploader.source.file.WebFileRegistry

val path = WebFileRegistry.register(browserFile) // returns "web-file://1"

UploadRequest(
    filePath = path.filePath,
    fileName = browserFile.name.fileName,
    fileSize = browserFile.browserSize().fileSize,
    // ...
)

fileReaderContext = Any()

fileReaderContext = Any()

UploadRequest(
    filePath = nativePath.filePath,
    // ...
)

val uploader = IUploader.init(
    startUpload = { size, metaData ->
        val response = uploadApi.startUpload(size)
        StartUploadResponse(
            uploadId = response.uploadId,
            key = response.key,
            chunkSize = response.chunkSize,
            links = response.signedUrls,
        )
    },
    putChunk = { url, chunkData, contentLength ->
        uploadApi.putChunk(url, chunkData, contentLength) ?: ""
    },
    completeUpload = { request ->
        // request is ir.sharif.drive.uploader.models.CompleteUploadRequest
        // Map fields to your backend API as needed
        uploadApi.completeUpload(request)
    },
    cancelUpload = { /* optional remote cancel */ },
    fileReaderContext = applicationContext,
)

// Enqueue
uploader.upload(
    listOf(
        UploadRequest(
            fileName = "report.pdf".fileName,
            filePath = uri.toString().filePath,
            fileSize = fileSize.fileSize,
            folderId = null,
            cloudPath = "/".cloudPath,
            versionGroup = null,
            metaData = null,
        ),
    ),
)

// Control
lifecycleScope.launch { uploader.pause(uploadId) }
lifecycleScope.launch { uploader.resume(uploadId) }
lifecycleScope.launch { uploader.cancel(uploadId) }
lifecycleScope.launch { uploader.retry(uploadId) }