theme-converter.osl

def checkNitrobolt(object themeJson) bool (
    array nitroBoltKeys = ["isGradient", "name", "primaryColor", "secondaryColor", "tertiaryColor"]
    boolean allKeysPresent = true
    for i nitroBoltKeys.len (
        if !themeJson.contains(nitroBoltKeys[i]) (
            allKeysPresent = false
        )
    )
    return allKeysPresent
)

def detectThemeSource(object themeJson) object (
    string detectedPlatform = ""
    
    if themeJson.contains("platform") (
        string platform = themeJson.platform.toStr().toLower()
        if isSupportedMod(platform) (
            detectedPlatform = platform
        )
    )
    
    if detectedPlatform == "" (
        if checkNitrobolt(themeJson) (
            detectedPlatform = "nitrobolt"
        )
    )
    
    if detectedPlatform == "" (
        return {ok: false, platform: "", error: "unable to detect theme source"}
    )
    
    return {ok: true, platform: detectedPlatform}
)

def getMistwarpSourceTheme(object themeJson) object (
    if themeJson.contains("themes") and typeof(themeJson.themes) == "array" (
        array themes = themeJson.themes.toArray()
        if themes.len > 0 (
            return themes[1].assert(object)
        )
    )
    return themeJson
)

def extractGradientColors(object accent) object (
    object result = {
        gradient: [{color: "#4c97ff", position: 0}, {color: "#9966ff", position: 100}],
        primary: "#4c97ff",
        secondary: "#9966ff",
        direction: 135
    }
    
    if !accent.contains("colors") (
        return result
    )
    
    array colors = accent.colors.toArray()
    if colors.len > 0 (
        result.gradient = colors
        object firstObj = colors[1]
        result.primary = prop(firstObj, "color")
    )
    if colors.len > 1 (
        object lastObj = colors[colors.len]
        result.secondary = prop(lastObj, "color")
    )
    if accent.contains("direction") (
        result.direction = accent.direction.toNum()
    )
    
    return result
)

def normalizeThemeToIntermediate(object themeJson, string platformId) object (
    object intermediate = {
        colors: {
            primary: "#4c97ff",
            secondary: "#9966ff",
            tertiary: "#4c97ff",
            gradient: [
                {color: "#4c97ff", position: 0},
                {color: "#9966ff", position: 100}
            ],
            gradientDirection: 135
        },
        wallpaper: {},
        fonts: {google: [], system: []},
        platformData: {}
    }
    
    platformId = platformId.toLower()
    
    if platformId == "mistwarp" (
        object sourceTheme = getMistwarpSourceTheme(themeJson)
        
        if sourceTheme.contains("accent") (
            object gradientInfo = extractGradientColors(sourceTheme.accent.assert(object))
            intermediate.colors.gradient = gradientInfo.gradient
            intermediate.colors.primary = gradientInfo.primary
            intermediate.colors.secondary = gradientInfo.secondary
            intermediate.colors.gradientDirection = gradientInfo.direction
        )
        
        if sourceTheme.contains("wallpaper") (
            intermediate.wallpaper = sourceTheme.wallpaper
        )
        
        if sourceTheme.contains("fonts") (
            intermediate.fonts = sourceTheme.fonts
        )
        
        object mistwarpData = {}
        if sourceTheme.contains("gui") (
            mistwarpData.gui = sourceTheme.gui
        )
        if sourceTheme.contains("blocks") (
            mistwarpData.blocks = sourceTheme.blocks
        )
        if sourceTheme.contains("menuBarAlign") (
            mistwarpData.menuBarAlign = sourceTheme.menuBarAlign
        )
        if sourceTheme.contains("createdAt") (
            mistwarpData.createdAt = sourceTheme.createdAt
        )
        
        if mistwarpData.contains("gui") or mistwarpData.contains("blocks") or mistwarpData.contains("menuBarAlign") (
            intermediate.platformData.mistwarp = mistwarpData
        )
    ) else if platformId == "nitrobolt" (
        if themeJson.contains("gradient") (
            object gradient = themeJson.gradient
            if gradient.contains("colors") (
                intermediate.colors.gradient = gradient.colors
                array colors = gradient.colors
                if colors.len > 0 (
                    object firstObj = colors[1]
                    intermediate.colors.primary = prop(firstObj, "color")
                )
                if colors.len > 1 (
                    object lastObj = colors[colors.len]
                    intermediate.colors.secondary = prop(lastObj, "color")
                )
            )
            if gradient.contains("direction") (
                intermediate.colors.gradientDirection = gradient.direction.toNum()
            )
        )
        
        if themeJson.contains("primaryColor") (
            intermediate.colors.primary = themeJson.primaryColor.toStr()
        )
        if themeJson.contains("secondaryColor") (
            intermediate.colors.secondary = themeJson.secondaryColor.toStr()
        )
        if themeJson.contains("tertiaryColor") (
            intermediate.colors.tertiary = themeJson.tertiaryColor.toStr()
        )
        
        object nitroboltData = {}
        if themeJson.contains("name") (
            nitroboltData.name = themeJson.name
        )
        if themeJson.contains("isGradient") (
            nitroboltData.isGradient = themeJson.isGradient
        )
        
        if nitroboltData.contains("name") or nitroboltData.contains("isGradient") (
            intermediate.platformData.nitrobolt = nitroboltData
        )
    )
    
    return {ok: true, intermediate: intermediate}
)

def convertIntermediateToOriginal(object intermediate, string platformId) object (
    string timeStr = time.Now().Format("2006-01-02T15:04:05.999Z").toStr()
    platformId = platformId.toLower()
    
    if platformId == "mistwarp" (
        object mistwarpTheme = {
            accent: {
                colors: intermediate.colors.gradient,
                direction: intermediate.colors.gradientDirection
            },
            createdAt: time.Now().Format("2006-01-02T15:04:05.999Z"),
            gui: "light",
            blocks: "three",
            menuBarAlign: "center"
        }
        
        if intermediate.platformData.contains("mistwarp") (
            object mistwarpData = intermediate.platformData.mistwarp
            if mistwarpData.contains("createdAt") (
                mistwarpTheme.createdAt = mistwarpData.createdAt
            )
            if mistwarpData.contains("gui") (
                mistwarpTheme.gui = mistwarpData.gui
            )
            if mistwarpData.contains("blocks") (
                mistwarpTheme.blocks = mistwarpData.blocks
            )
            if mistwarpData.contains("menuBarAlign") (
                mistwarpTheme.menuBarAlign = mistwarpData.menuBarAlign
            )
        )
        
        if typeof(intermediate.wallpaper) == "object" (
            mistwarpTheme.wallpaper = intermediate.wallpaper
        )
        
        if typeof(intermediate.fonts) == "object" (
            mistwarpTheme.fonts = intermediate.fonts
        )
        
        return {ok: true, theme: mistwarpTheme, platform: "mistwarp"}
    ) else if platformId == "nitrobolt" (
        object nitroboltTheme = {
            gradient: null,
            isGradient: intermediate.colors.gradient.len > 1,
            primaryColor: intermediate.colors.primary,
            secondaryColor: intermediate.colors.secondary,
            tertiaryColor: intermediate.colors.tertiary
        }

        object nitroboltData = intermediate.platformData.nitrobolt
        nitroboltTheme.name = nitroboltData.name ?? intermediate.name ?? ("Exported Theme At " ++ timeStr)

        if nitroboltTheme.isGradient (
            nitroboltTheme.gradient = {
                colors: intermediate.colors.gradient,
                direction: intermediate.colors.gradientDirection
            }
        )
        
        return {ok: true, theme: nitroboltTheme, platform: "nitrobolt"}
    )
    
    return {ok: false, error: "unsupported platform for conversion"}
)

def exportToPlatform(object intermediate, string targetPlatformId, object metadata) object (
    auto result = convertIntermediateToOriginal(intermediate, targetPlatformId)
    
    if !result.ok (
        return {ok: false, error: result.error}
    )
    
    object theme = result.theme
    
    if targetPlatformId.toLower() == "mistwarp" (
        object mistwarpExport = {
            version: metadata.version ?? "2.0",
            timestamp: metadata.timestamp ?? timestamp,
            themes: [],
            platform: "MistWarp"
        }
        
        object themeObj = theme
        if metadata.contains("uuid") (
            themeObj.uuid = metadata.uuid
        )
        if metadata.contains("createdAt") (
            themeObj.createdAt = metadata.createdAt
        )
        if metadata.contains("name") (
            themeObj.name = metadata.name
        )
        if metadata.contains("description") (
            themeObj.description = metadata.description
        )
        if metadata.contains("author") (
            themeObj.author = metadata.author
        )
        
        mistwarpExport.themes = [themeObj]
        
        return {ok: true, theme: mistwarpExport, platform: "mistwarp"}
    ) else if targetPlatformId.toLower() == "nitrobolt" (
        return {ok: true, theme: theme, platform: "nitrobolt"}
    )
    
    return {ok: false, error: "unsupported target platform"}
)

def convertOldMistwarpToIntermediate(object oldTheme) object (
    object intermediate = {
        colors: {
            primary: "#4c97ff",
            secondary: "#9966ff",
            tertiary: "#4c97ff",
            gradient: [
                {color: "#4c97ff", position: 0},
                {color: "#9966ff", position: 100}
            ],
            gradientDirection: 135
        },
        wallpaper: {},
        fonts: {google: [], system: []},
        platformData: {mistwarp: {}}
    }
    
    if oldTheme.contains("accent") (
        object gradientInfo = extractGradientColors(oldTheme.accent.assert(object))
        intermediate.colors.gradient = gradientInfo.gradient
        intermediate.colors.primary = gradientInfo.primary
        intermediate.colors.secondary = gradientInfo.secondary
        intermediate.colors.gradientDirection = gradientInfo.direction
    )
    
    object mistwarpData = intermediate.platformData.mistwarp.assert(object)
    
    if oldTheme.contains("gui") (
        mistwarpData.gui = oldTheme.gui
    )
    if oldTheme.contains("blocks") (
        mistwarpData.blocks = oldTheme.blocks
    )
    if oldTheme.contains("menuBarAlign") (
        mistwarpData.menuBarAlign = oldTheme.menuBarAlign
    )
    if oldTheme.contains("createdAt") (
        mistwarpData.createdAt = oldTheme.createdAt
    )
    
    if oldTheme.contains("wallpaper") (
        intermediate.wallpaper = oldTheme.wallpaper
    )
    
    if oldTheme.contains("fonts") (
        intermediate.fonts = oldTheme.fonts
    )
    
    intermediate.platformData.mistwarp = mistwarpData
    
    return {ok: true, intermediate: intermediate}
)