enum class MarketplaceItemType(
    override val tag: String,
    val isListable: Boolean,      // Can be browsed in marketplace
    val isSubscribable: Boolean    // Can be subscribed/installed
) : Tagged {
    CONFIG("Config", false, false),
    SCRIPT("Script", true, true),
    THEME("Theme", true, true),
    OTHER("Other", false, false)
}

suspend fun subscribeToItem(item: MarketplaceItem) {
    MarketplaceManager.subscribe(item)
}

data class SubscribedItem(
    val name: String,
    val id: Int,
    val type: MarketplaceItemType,
    var installedRevisionId: Int?
)

.liquidbounce/
└── marketplace/
    └── items/
        └── {item_id}/
            └── {revision_id}/
                └── [extracted files]

fun getInstallationFolder(): File? {
    val revisionDir = itemDir.resolve(installedRevisionId.toString())
    
    // Returns the folder containing files
    // Could be revision root or a subdirectory like /dist
    return findFolderWithFiles(revisionDir)
}

suspend fun install(revisionId: Int, subTask: ResourceTask? = null) {
    // Download revision archive
    val revisionUrl = MarketplaceApi.downloadRevision(id, revisionId)
    download(revisionUrl, revisionArchiveFile, progressListener)
    
    // Extract to revision directory
    extractZip(revisionArchiveFile, revisionDir)
    
    // Update installed revision ID
    installedRevisionId = revisionId
    ConfigSystem.store(MarketplaceManager)
    
    // Clean up old revision
    previousRevisionDir?.deleteRecursively()
    
    // Reload the item type's manager
    type.reload()
}

suspend fun updateAll(task: Task? = null, command: Command? = null) {
    subscribedItems.toList().forEach { item ->
        update(item, task, command)
    }
}

suspend fun update(item: SubscribedItem) {
    // Check if update is available
    val updateRevisionId = item.checkUpdate() ?: return
    
    // Install the new revision
    item.install(updateRevisionId)
}

suspend fun checkUpdate(): Int? {
    val newestRevisionId = getNewestRevisionId()
    
    if (installedRevisionId == newestRevisionId) {
        return null  // Already up to date
    }
    
    return newestRevisionId
}

suspend fun getNewestRevisionId(): Int? {
    val item = MarketplaceApi.getMarketplaceItem(id)
    
    // Only update if item is still active
    if (item.status != MarketplaceItemStatus.ACTIVE) {
        return null
    }
    
    // Get first (newest) revision
    val revisions = MarketplaceApi.getMarketplaceItemRevisions(id, 1, 1)
    return revisions.items.firstOrNull()?.id
}

suspend fun unsubscribe(itemId: Int) {
    val item = subscribedItems.find { it.id == itemId }
        ?: error("Item $itemId not found")
    
    // Delete all item files
    check(item.itemDir.deleteRecursively()) {
        "Failed to delete item directory"
    }
    
    // Remove from subscriptions
    subscribedItems.remove(item)
    ConfigSystem.store(this)
    
    // Reload the item type's manager
    item.type.reload()
}

val scripts = MarketplaceManager.getSubscribedItemsOfType(
    MarketplaceItemType.SCRIPT
)

val themes = MarketplaceManager.getSubscribedItemsOfType(
    MarketplaceItemType.THEME
)

if (MarketplaceManager.isSubscribed(itemId)) {
    // Already subscribed
}

val item = MarketplaceManager.getItem(itemId)

val progressListener = OkHttpProgressInterceptor.ProgressListener { 
    bytesRead, contentLength, done ->
    subTask.update(bytesRead, contentLength)
}

download(url, file, progressListener = progressListener)

suspend fun reload() = when (this) {
    THEME -> ThemeManager.load()
    SCRIPT -> ScriptManager.reload()
    else -> { }
}

runCatching {
    item.install(updateRevisionId, subTask)
}.onFailure { e ->
    logger.error("Failed to update item ${item.id}", e)
    command?.chat(markAsError(
        translation("liquidbounce.command.marketplace.error.updateFailed",
            item.id, e.message ?: "Unknown error")
    ))
}