const formatMessage = require('format-message');
const BlockType = require('../../extension-support/block-type');
const ArgumentType = require('../../extension-support/argument-type');
const BufferUtil = new (require('../../util/array buffer'));
const Cast = require('../../util/cast');
const Color = require('../../util/color');

// ShovelUtils
let fps = 0;

/**
 * Class for Runtime blocks
 * @constructor
 */
class JgRuntimeBlocks {
    constructor(runtime) {
        /**
         * The runtime instantiating this block package.
         * @type {Runtime}
         */
        this.runtime = runtime;

        // SharkPool
        this.pausedScripts = Object.create(null);

        // ShovelUtils
        // Based on from https://www.growingwiththeweb.com/2017/12/fast-simple-js-fps-counter.html
        const times = [];
        fps = this.runtime.frameLoop.framerate;
        this.runtime.on('RUNTIME_STEP_START', () => {
            const now = performance.now();
            while (times.length > 0 && times[0] <= now - 1000) { times.shift() }
            times.push(now);
            fps = times.length;
        });
        this.runtime.on('PROJECT_STOP_ALL', () => { this.pausedScripts = Object.create(null) });
    }

    _typeIsBitmap(type) {
        return (
            type === 'image/png' || type === 'image/bmp' || type === 'image/jpg' || type === 'image/jpeg' || 
            type === 'image/jfif' || type === 'image/webp' || type === 'image/gif'
        );
    }

    /**
     * @returns {object} metadata for this extension and its blocks.
     */
    getInfo() {
        return {
            id: 'jgRuntime',
            name: 'Runtime',
            color1: '#777777',
            color2: '#6a6a6a',
            blocks: [
                {
                    opcode: 'addSpriteUrl',
                    text: 'add sprite from [URL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        URL: {
                            type: ArgumentType.STRING,
                            defaultValue: `https://corsproxy.io/?${encodeURIComponent('https://penguinmod.com/Sprite1.pms')}`
                        }
                    }
                },
                {
                    opcode: 'addCostumeUrl',
                    text: 'add costume [name] from [URL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        URL: {
                            type: ArgumentType.STRING,
                            defaultValue: `https://corsproxy.io/?${encodeURIComponent('https://penguinmod.com/navicon.png')}`
                        },
                        name: {
                            type: ArgumentType.STRING,
                            defaultValue: 'penguinmod'
                        }
                    }
                },
                {
                    opcode: 'addCostumeUrlForceMime',
                    text: 'add [costtype] costume [name] from [URL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        costtype: {
                            type: ArgumentType.STRING,
                            menu: "costumeMimeType"
                        },
                        URL: {
                            type: ArgumentType.STRING,
                            defaultValue: `https://corsproxy.io/?${encodeURIComponent('https://penguinmod.com/navicon.png')}`
                        },
                        name: {
                            type: ArgumentType.STRING,
                            defaultValue: 'penguinmod'
                        }
                    }
                },
                {
                    opcode: 'addSoundUrl',
                    text: 'add sound [NAME] from [URL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        URL: {
                            type: ArgumentType.STRING,
                            defaultValue: 'https://extensions.turbowarp.org/meow.mp3'
                        },
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: 'Meow'
                        }
                    }
                },
                {
                    opcode: 'loadProjectDataUrl',
                    text: 'load project from [URL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        URL: {
                            type: ArgumentType.STRING,
                            defaultValue: ''
                        }
                    }
                },
                {
                    opcode: 'getIndexOfCostume',
                    text: 'get costume index of [costume]',
                    blockType: BlockType.REPORTER,
                    arguments: {
                        costume: {
                            type: ArgumentType.STRING,
                            defaultValue: "costume1"
                        }
                    }
                },
                {
                    opcode: 'getIndexOfSound',
                    text: 'get sound index of [NAME]',
                    blockType: BlockType.REPORTER,
                    arguments: {
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "Pop"
                        }
                    }
                },
                {
                    opcode: 'getProjectDataUrl',
                    text: 'get data url of project',
                    blockType: BlockType.REPORTER,
                    disableMonitor: true
                },
                '---',
                {
                    opcode: 'setStageSize',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.setStageSize',
                        default: 'set stage width: [WIDTH] height: [HEIGHT]',
                        description: 'Sets the width and height of the stage.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        WIDTH: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 480
                        },
                        HEIGHT: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 360
                        }
                    }
                },
                {
                    opcode: 'getStageWidth',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getStageWidth',
                        default: 'stage width',
                        description: 'Block that returns the width of the stage.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getStageHeight',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getStageHeight',
                        default: 'stage height',
                        description: 'Block that returns the height of the stage.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                '---',
                {
                    opcode: 'updateRuntimeConfig',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.updateRuntimeConfig',
                        default: 'set [OPTION] to [ENABLED]',
                        description: 'Block that enables or disables configuration on the runtime like high quality pen or turbo mode.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.COMMAND,
                    arguments: {
                        OPTION: {
                            menu: 'runtimeConfig'
                        },
                        ENABLED: {
                            menu: 'onoff'
                        }
                    }
                },
                {
                    opcode: 'changeRenderingCapping',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.changeRenderingCapping',
                        default: 'change render setting [OPTION] to [CAPPED]',
                        description: 'Block that updates configuration on the renderer like resolution for certain content.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.COMMAND,
                    arguments: {
                        OPTION: {
                            menu: 'renderConfigCappable'
                        },
                        CAPPED: {
                            menu: 'cappableSettings'
                        }
                    }
                },
                {
                    opcode: 'setRenderingNumber',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.setRenderingNumber',
                        default: 'set render setting [OPTION] to [NUM]',
                        description: 'Block that sets configuration on the renderer like resolution for certain content.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.COMMAND,
                    arguments: {
                        OPTION: {
                            menu: 'renderConfigNumber'
                        },
                        NUM: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 0
                        }
                    }
                },
                {
                    opcode: 'runtimeConfigEnabled',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.runtimeConfigEnabled',
                        default: '[OPTION] enabled?',
                        description: 'Block that returns whether a runtime option like Turbo Mode is enabled on the project or not.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.BOOLEAN,
                    arguments: {
                        OPTION: {
                            menu: 'runtimeConfig'
                        }
                    }
                },
                {
                    opcode: 'turboModeEnabled',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.turboModeEnabled',
                        default: 'turbo mode enabled?',
                        description: 'Block that returns whether Turbo Mode is enabled on the project or not.'
                    }),
                    disableMonitor: false,
                    hideFromPalette: true,
                    blockType: BlockType.BOOLEAN
                },
                '---',
                {
                    opcode: 'setMaxClones',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.setMaxClones',
                        default: 'set max clones to [MAX]',
                        description: 'Block that enables or disables configuration on the runtime like high quality pen or turbo mode.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.COMMAND,
                    arguments: {
                        MAX: {
                            menu: 'cloneLimit',
                            defaultValue: 300
                        }
                    }
                },
                {
                    opcode: 'maxAmountOfClones',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.maxAmountOfClones',
                        default: 'max clone count',
                        description: 'Block that returns the maximum amount of clones that may exist.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'amountOfClones',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.amountOfClones',
                        default: 'clone count',
                        description: 'Block that returns the amount of clones that currently exist.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getIsClone',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getIsClone',
                        default: 'is clone?',
                        description: 'Block that returns whether the sprite is a clone or not.'
                    }),
                    disableMonitor: true,
                    blockType: BlockType.BOOLEAN
                },
                '---',
                {
                    opcode: 'setMaxFrameRate',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.setMaxFrameRate',
                        default: 'set max framerate to: [FRAMERATE]',
                        description: 'Sets the max allowed framerate.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        FRAMERATE: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 30
                        }
                    }
                },
                {
                    opcode: 'getMaxFrameRate',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getMaxFrameRate',
                        default: 'max framerate',
                        description: 'Block that returns the amount of FPS allowed.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getFrameRate',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getFrameRate',
                        default: 'framerate',
                        description: 'Block that returns the amount of FPS.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                '---',
                {
                    opcode: 'setBackgroundColor',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.setBackgroundColor',
                        default: 'set stage background color to [COLOR]',
                        description: 'Sets the background color of the stage.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        COLOR: {
                            type: ArgumentType.COLOR
                        }
                    }
                },
                {
                    opcode: 'getBackgroundColor',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getBackgroundColor',
                        default: 'stage background color',
                        description: 'Block that returns the stage background color in HEX.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                "---",
                {
                    opcode: "pauseScript",
                    blockType: BlockType.COMMAND,
                    text: "pause this script using name: [NAME]",
                    arguments: {
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "my script",
                        },
                    }
                },
                {
                    opcode: "unpauseScript",
                    blockType: BlockType.COMMAND,
                    text: "unpause script named: [NAME]",
                    arguments: {
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "my script",
                        },
                    }
                },
                {
                    opcode: "isScriptPaused",
                    blockType: BlockType.BOOLEAN,
                    text: "is script named [NAME] paused?",
                    arguments: {
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "my script",
                        },
                    }
                },
                "---",
                {
                    opcode: 'variables_createVariable',
                    text: 'create variable named [NAME] for [SCOPE]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "my variable" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableScope" }
                    }
                },
                {
                    opcode: 'variables_createCloudVariable',
                    text: 'create cloud variable named [NAME]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "cloud variable" },
                    }
                },
                {
                    opcode: 'variables_createList',
                    text: 'create list named [NAME] for [SCOPE]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "list" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableScope" }
                    }
                },
                {
                    opcode: 'variables_getVariable',
                    text: 'get value of variable named [NAME] in [SCOPE]',
                    disableMonitor: true,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "my variable" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableTypes" }
                    }
                },
                {
                    opcode: 'variables_getList',
                    text: 'get array of list named [NAME] in [SCOPE]',
                    disableMonitor: true,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "list" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableScope" }
                    }
                },
                {
                    opcode: 'variables_existsVariable',
                    text: 'variable named [NAME] exists in [SCOPE]?',
                    disableMonitor: true,
                    blockType: BlockType.BOOLEAN,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "my variable" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableTypes" }
                    }
                },
                {
                    opcode: 'variables_existsList',
                    text: 'list named [NAME] exists in [SCOPE]?',
                    disableMonitor: true,
                    blockType: BlockType.BOOLEAN,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "list" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableScope" }
                    }
                },
                "---",
                {
                    opcode: 'getDataOption',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getDataOption',
                        default: 'get binary data of [OPTION] named [NAME]',
                        description: 'Block that returns the binary data of a sprite, sound or costume.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        OPTION: {
                            type: ArgumentType.STRING,
                            menu: "objectType"
                        },
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "Sprite1"
                        }
                    }
                },
                {
                    opcode: 'getDataUriOption',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.getDataUriOption',
                        default: 'get data uri of [OPTION] named [NAME]',
                        description: 'Block that returns the data URI of a sprite, sound or costume.'
                    }),
                    disableMonitor: false,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        OPTION: {
                            type: ArgumentType.STRING,
                            menu: "objectType"
                        },
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "Sprite1"
                        }
                    }
                },
                "---",
                {
                    opcode: 'getAllSprites',
                    text: 'get all sprites',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getAllCostumes',
                    text: 'get all costumes',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getAllSounds',
                    text: 'get all sounds',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                {
                    opcode: 'getAllFonts',
                    text: 'get all fonts',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER
                },
                "---",
                {
                    opcode: 'getAllVariables',
                    text: 'get all variables [ALLSCOPE]',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        ALLSCOPE: {
                            type: ArgumentType.STRING,
                            menu: "allVariableType"
                        }
                    }
                },
                {
                    opcode: 'getAllLists',
                    text: 'get all lists [ALLSCOPE]',
                    disableMonitor: false,
                    blockType: BlockType.REPORTER,
                    arguments: {
                        ALLSCOPE: {
                            type: ArgumentType.STRING,
                            menu: "allVariableScope"
                        }
                    }
                },
                "---",
                {
                    blockType: BlockType.LABEL,
                    text: "Potentially Dangerous"
                },
                {
                    opcode: 'deleteCostume',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.deleteCostume',
                        default: 'delete costume at index [COSTUME]',
                        description: 'Deletes a costume at the specified index.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        COSTUME: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 1
                        }
                    }
                },
                {
                    opcode: 'deleteSound',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.deleteSound',
                        default: 'delete sound at index [SOUND]',
                        description: 'Deletes a sound at the specified index.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        SOUND: {
                            type: ArgumentType.NUMBER,
                            defaultValue: 1
                        }
                    }
                },
                "---",
                {
                    opcode: 'variables_deleteVariable',
                    text: 'delete variable named [NAME] in [SCOPE]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "my variable" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableTypes" }
                    }
                },
                {
                    opcode: 'variables_deleteList',
                    text: 'delete list named [NAME] in [SCOPE]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: { type: ArgumentType.STRING, defaultValue: "list" },
                        SCOPE: { type: ArgumentType.STRING, menu: "variableScope" }
                    }
                },
                "---",
                {
                    opcode: 'deleteSprite',
                    text: formatMessage({
                        id: 'jgRuntime.blocks.deleteSprite',
                        default: 'delete sprite named [NAME]',
                        description: 'Deletes a sprite with the specified name.'
                    }),
                    blockType: BlockType.COMMAND,
                    arguments: {
                        NAME: {
                            type: ArgumentType.STRING,
                            defaultValue: "Sprite1"
                        }
                    }
                },
            ],
            menus: {
                objectType: {
                    acceptReporters: true,
                    items: [
                        "sprite", "costume", "sound"
                    ].map(item => ({ text: item, value: item }))
                },
                variableScope: {
                    acceptReporters: true,
                    items: [
                        "all sprites", "this sprite"
                    ].map(item => ({ text: item, value: item }))
                },
                allVariableScope: {
                    acceptReporters: true,
                    items: [
                        "for all sprites", "in every sprite", "in this sprite"
                    ].map(item => ({ text: item, value: item }))
                },
                allVariableType: {
                    acceptReporters: true,
                    items: [
                        "for all sprites", "in every sprite",
                        "in this sprite", "in the cloud"
                    ].map(item => ({ text: item, value: item }))
                },
                variableTypes: {
                    acceptReporters: true,
                    items: [
                        "all sprites", "this sprite", "cloud"
                    ].map(item => ({ text: item, value: item }))
                },
                cloneLimit: {
                    items: [
                        '100', '128', '300', '500',
                        '1000', '1024', '5000',
                        '10000', '16384', 'Infinity'
                    ],
                    isTypeable: true,
                    isNumeric: true
                },
                runtimeConfig: {
                    acceptReporters: true,
                    items: [
                        "turbo mode",
                        "high quality pen",
                        "offscreen sprites",
                        "remove miscellaneous limits",
                        "disable offscreen rendering",
                        "interpolation",
                        "warp timer"
                    ]
                },
                renderConfigCappable: {
                    acceptReporters: true,
                    items: ["animated text resolution"]
                },
                renderConfigNumber: {
                    acceptReporters: true,
                    items: ["animated text resolution"]
                },
                onoff: ["on", "off"],
                costumeMimeType: ["png", "bmp", "jpg", "jpeg", "jfif", "webp", "gif", "vector"],
                cappableSettings: ["uncapped", "capped", "fixed"]
            }
        };
    }
    // utils
    _generateScratchId() {
        const soup = "!#%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        const id = [];
        for (let i = 0; i < 20; i++) { id[i] = soup.charAt(Math.random() * soup.length) }
        return id.join("");
    }

    // blocks
    addCostumeUrl(args, util) {
        const targetId = util.target.id;
        return new Promise(resolve => {
            fetch(args.URL, { method: 'GET' }).then(x => x.blob().then(blob => {
                const costumeHasForcedMime = !!args.costtype;
                const costumeForcedMimeBitmap = args.costtype !== "vector";
                if (!(
                    (this._typeIsBitmap(blob.type)) || (blob.type === 'image/svg+xml')
                ) && !costumeHasForcedMime) {
                    resolve();
                    throw new Error(`Invalid mime type: "${blob.type}"`);
                }
                const assetType = (costumeHasForcedMime ? costumeForcedMimeBitmap : this._typeIsBitmap(blob.type)) ? this.runtime.storage.AssetType.ImageBitmap : this.runtime.storage.AssetType.ImageVector;
                const dataType = costumeHasForcedMime ? (costumeForcedMimeBitmap ? args.costtype : 'svg') : (blob.type === 'image/svg+xml' ? 'svg' : blob.type.split('/')[1]);
                blob.arrayBuffer().then(buffer => {
                    const data = costumeHasForcedMime ? (!costumeForcedMimeBitmap ? buffer : new Uint8Array(buffer)) : (dataType === 'image/svg+xml'
                        ? buffer : new Uint8Array(buffer));
                    const asset = this.runtime.storage.createAsset(assetType, dataType, data, null, true);
                    const name = `${asset.assetId}.${asset.dataFormat}`;
                    const spriteJson = { asset: asset, md5ext: name, name: args.name };
                    const request = vm.addCostume(name, spriteJson, targetId);
                    if (request.then) request.then(resolve);
                    else resolve();
                })
                .catch(err => {
                    console.error(`Failed to Load Costume: ${err}`);
                    resolve();
                });
            }));
        });
    }
    addCostumeUrlForceMime(args, util) {
        this.addCostumeUrl(args, util);
    }
    deleteCostume(args, util) {
        const index = Math.round(Cast.toNumber(args.COSTUME)) - 1;
        if (index < 0) return;
        util.target.deleteCostume(index);
    }
    deleteSound(args, util) {
        const index = Math.round(Cast.toNumber(args.SOUND)) - 1;
        if (index < 0) return;
        util.target.deleteSound(index);
    }
    getIndexOfCostume(args, util) { return util.target.getCostumeIndexByName(args.costume) + 1 }
    getIndexOfSound(args, util) {
        let index = 0;
        const sounds = util.target.getSounds();
        for (let i = 0; i < sounds.length; i++) {
            if (sounds[i].name === args.NAME) index = i + 1;
        }
        return index;
    }
    setStageSize(args) {
        if (vm) vm.setStageSize(
            Math.max(1, Cast.toNumber(args.WIDTH)), Math.max(1, Cast.toNumber(args.HEIGHT))
        );
    }
    turboModeEnabled() { return this.runtime.turboMode }
    amountOfClones() { return this.runtime._cloneCounter }
    getStageWidth() { return this.runtime.stageWidth }
    getStageHeight() { return this.runtime.stageHeight }
    getMaxFrameRate() { return this.runtime.frameLoop.framerate }
    getIsClone(_, util) { return !(util.target.isOriginal) }

    changeRenderingCapping(args) {
        const option = Cast.toString(args.OPTION).toLowerCase();
        const capping = Cast.toString(args.CAPPED).toLowerCase();
        switch (option) {
            case "animated text resolution": {
                this.runtime.renderer.customRenderConfig.textCostumeResolution.fixed = false;
                this.runtime.renderer.customRenderConfig.textCostumeResolution.capped = false;
                if (capping === "fixed") this.runtime.renderer.customRenderConfig.textCostumeResolution.fixed = true;
                else if (capping === "capped") this.runtime.renderer.customRenderConfig.textCostumeResolution.capped = true;
                break;
            }
        }
        this.runtime.renderer.dirty = true;
        this.runtime.requestRedraw();
    }
    setRenderingNumber(args) {
        const option = Cast.toString(args.OPTION).toLowerCase();
        const number = Cast.toNumber(args.NUM);
        switch (option) {
            case "animated text resolution": {
                this.runtime.renderer.customRenderConfig.textCostumeResolution.value = number;
                break;
            }
            case "max texture scale for new svg images": {
                this.runtime.renderer.setMaxTextureDimension(number);
                break;
            }
        }
        this.runtime.renderer.dirty = true;
        this.runtime.requestRedraw();
    }

    updateRuntimeConfig(args) {
        const enabled = Cast.toString(args.ENABLED).toLowerCase() === 'on';
        switch (Cast.toString(args.OPTION).toLowerCase()) {
        case 'turbo mode': return vm.setTurboMode(enabled);
        case "high quality pen": return this.runtime.renderer.setUseHighQualityRender(enabled);
        case "offscreen sprites": return this.runtime.setRuntimeOptions({ fencing: !enabled });
        case "remove miscellaneous limits": return this.runtime.setRuntimeOptions({ miscLimits: !enabled });
        case "disable offscreen rendering": return this.runtime.setRuntimeOptions({ disableOffscreenRendering: enabled });
        case "interpolation": return vm.setInterpolation(enabled);
        case "warp timer": return this.runtime.setCompilerOptions({ warpTimer: enabled });
        }
    }
    runtimeConfigEnabled(args) {
        switch (Cast.toString(args.OPTION).toLowerCase()) {
        case 'turbo mode': return this.runtime.turboMode;
        case "high quality pen": return this.runtime.renderer.useHighQualityRender;
        case "offscreen sprites": return !this.runtime.runtimeOptions.fencing;
        case "remove miscellaneous limits": return !this.runtime.runtimeOptions.miscLimits;
        case "disable offscreen rendering": return this.runtime.runtimeOptions.disableOffscreenRendering;
        case "interpolation": return this.runtime.interpolationEnabled;
        case "warp timer": return this.runtime.compilerOptions.warpTimer;
        default: return false;
        }
    }
    setMaxClones(args) {
        const limit = Math.round(Cast.toNumber(args.MAX));
        this.runtime.vm.setRuntimeOptions({ maxClones: limit });
    }
    maxAmountOfClones() { return this.runtime.runtimeOptions.maxClones }
    setBackgroundColor(args) {
        let RGB;
        if (typeof args.COLOR === "number") {
            RGB = Cast.toRgbColorObject(args.COLOR);
            this.runtime.renderer.setBackgroundColor(RGB.r / 255, RGB.g / 255, RGB.b / 255);
        } else {
            RGB = Cast.toString(args.COLOR);
            RGB = RGB.startsWith("#") ? RGB.slice(1) : RGB;
            this.runtime.renderer.setBackgroundColor(
                parseInt(RGB.slice(0, 2), 16) / 255,
                parseInt(RGB.slice(2, 4), 16) / 255,
                parseInt(RGB.slice(4, 6), 16) / 255,
                RGB.length === 8 ? parseInt(RGB.slice(6, 8), 16) / 255 : 1
            )
        }
    }
    getBackgroundColor() {
        const colorArray = this.runtime.renderer._backgroundColor3b;
        const colorObject = {
            r: Math.round(Cast.toNumber(colorArray[0])),
            g: Math.round(Cast.toNumber(colorArray[1])),
            b: Math.round(Cast.toNumber(colorArray[2]))
        };
        const hex = Color.rgbToHex(colorObject);
        return hex;
    }

    // SharkPool, edited by JeremyGamer13
    pauseScript(args, util) {
        const scriptName = Cast.toString(args.NAME);
        const state = util.stackFrame.pausedScript;
        if (!state) {
            this.pausedScripts[scriptName] = true;
            util.stackFrame.pausedScript = scriptName;
            util.yield();
        } else if (state in this.pausedScripts) {
            util.yield();
        }
    }
    unpauseScript(args) {
        const scriptName = Cast.toString(args.NAME);
        if (scriptName in this.pausedScripts) {
            delete this.pausedScripts[scriptName];
        }
    }
    isScriptPaused(args) {
        const scriptName = Cast.toString(args.NAME);
        return scriptName in this.pausedScripts;
    }

    setMaxFrameRate(args) {
        let frameRate = Cast.toNumber(args.FRAMERATE);
        this.runtime.frameLoop.setFramerate(frameRate);
    }
    deleteSprite(args) {
        const target = this.runtime.getSpriteTargetByName(args.NAME);
        if (!target) return;
        vm.deleteSpriteInternal(target.id);
    }

    getDataOption(args, util) {
        switch (args.OPTION) {
            case "sprite": {
                const sprites = this.runtime.targets.filter(target => target.isOriginal);
                const sprite = sprites.filter(sprite => sprite.sprite.name === args.NAME)[0];
                if (!sprite) return "[]";
                return new Promise(resolve => {
                    vm.exportSprite(sprite.id).then(blob => {
                        blob.arrayBuffer().then(arrayBuffer => {
                            const array = BufferUtil.bufferToArray(arrayBuffer);
                            const stringified = JSON.stringify(array);
                            resolve(stringified);
                        }).catch(() => resolve("[]"));
                    }).catch(() => resolve("[]"));
                });
            }
            case "costume": {
                const costumes = util.target.getCostumes();
                const index = util.target.getCostumeIndexByName(args.NAME);
                if (!costumes[index]) return "[]";
                const costume = costumes[index];
                const data = costume.asset.data;
                const array = BufferUtil.bufferToArray(data.buffer);
                return JSON.stringify(array);
            }
            case "sound": {
                const sounds = util.target.getSounds();
                const index = this.getIndexOfSound(args, util) - 1;
                if (!sounds[index]) return "[]";
                const sound = sounds[index];
                const data = sound.asset.data;
                const array = BufferUtil.bufferToArray(data.buffer);
                return JSON.stringify(array);
            }
            default: return "[]";
        }
    }
    getDataUriOption(args, util) {
        switch (args.OPTION) {
            case "sprite": {
                const sprites = this.runtime.targets.filter(target => target.isOriginal);
                const sprite = sprites.filter(sprite => sprite.sprite.name === args.NAME)[0];
                if (!sprite) return "";
                return new Promise(resolve => {
                    vm.exportSprite(sprite.id).then(blob => {
                        const reader = new FileReader();
                        reader.onload = () => resolve(reader.result);
                        reader.onerror = () => resolve("");
                        reader.onabort = () => resolve("");
                        reader.readAsDataURL(blob);
                    }).catch(() => resolve(""));
                });
            }
            case "costume": {
                const costumes = util.target.getCostumes();
                const index = util.target.getCostumeIndexByName(args.NAME);
                if (!costumes[index]) return "";
                const costume = costumes[index];
                return costume.asset.encodeDataURI();
            }
            case "sound": {
                const sounds = util.target.getSounds();
                const index = this.getIndexOfSound(args, util) - 1;
                if (!sounds[index]) return "";
                const sound = sounds[index];
                return sound.asset.encodeDataURI();
            }
            default: return "";
        }
    }
    getAllSprites() {
        return JSON.stringify(this.runtime.targets.filter(target => target.isOriginal && !target.isStage).map(target => target.sprite.name));
    }
    getAllCostumes(_, util) {
        const costumes = util.target.getCostumes();
        return JSON.stringify(costumes.map(costume => costume.name));
    }
    getAllSounds(_, util) {
        const sounds = util.target.getSounds();
        return JSON.stringify(sounds.map(sound => sound.name));
    }
    getAllFonts() {
        const fonts = this.runtime.fontManager.getFonts();
        return JSON.stringify(fonts.map(font => font.name));
    }

    loadProjectDataUrl(args) {
        const url = Cast.toString(args.URL);
        if (typeof ScratchBlocks !== "undefined") {
            // We are in the editor. Ask before loading a new project to avoid unrecoverable data loss.
            if (!confirm(`Runtime Extension - Editor: Are you sure you want to load a new project?\nEverything in the current project will be permanently deleted.`)) {
                return;
            }
        }
        console.log("Loading project from custom source...");
        fetch(url)
            .then((r) => r.arrayBuffer())
            .then((buffer) => vm.loadProject(buffer))
            .then(() => {
                console.log("Loaded project!");
                vm.greenFlag();
            })
            .catch((error) => {
                console.log("Error loading custom project;", error);
            });
    }
    getProjectDataUrl() {
        return new Promise((resolve) => {
            const failingUrl = 'data:application/octet-stream;base64,';
            vm.saveProjectSb3().then(blob => {
                const fileReader = new FileReader();
                fileReader.onload = () => { resolve(fileReader.result); };
                fileReader.onerror = () => { resolve(failingUrl) }
                fileReader.readAsDataURL(blob);
            }).catch(() => { resolve(failingUrl) });
        });
    }

    getAllVariables(args, util) {
        switch (args.ALLSCOPE) {
            case "for all sprites": {
                const stage = this.runtime.getTargetForStage();
                if (!stage) return "[]";
                const variables = stage.variables;
                if (!variables) return "[]";
                return JSON.stringify(Object.values(variables).filter(v => v.type !== "list").map(v => v.name));
            }
            case "in every sprite": {
                const targets = this.runtime.targets;
                if (!targets) return "[]";
                const variables = targets.filter(t => t.isOriginal).map(t => t.variables);
                if (!variables) return "[]";
                return JSON.stringify(variables.map(v => Object.values(v)).map(v => v.filter(v => v.type !== "list").map(v => v.name)).flat(1));
            }
            case "in this sprite": {
                const target = util.target;
                if (!target) return "[]";
                const variables = target.variables;
                if (!variables) return "[]";
                return JSON.stringify(Object.values(variables).filter(v => v.type !== "list").map(v => v.name));
            }
            case "in the cloud": {
                const stage = this.runtime.getTargetForStage();
                if (!stage) return "[]";
                const variables = stage.variables;
                if (!variables) return "[]";
                return JSON.stringify(Object.values(variables).filter(v => v.type !== "list").filter(v => v.isCloud === true).map(v => v.name));
            }
            default: return "[]";
        }
    }
    getAllLists(args, util) {
        switch (args.ALLSCOPE) {
            case "for all sprites": {
                const stage = this.runtime.getTargetForStage();
                if (!stage) return "[]";
                const variables = stage.variables;
                if (!variables) return "[]";
                return JSON.stringify(Object.values(variables).filter(v => v.type === "list").map(v => v.name));
            }
            case "in every sprite": {
                const targets = this.runtime.targets;
                if (!targets) return "[]";
                const variables = targets.filter(t => t.isOriginal).map(t => t.variables);
                if (!variables) return "[]";
                return JSON.stringify(variables.map(v => Object.values(v)).map(v => v.filter(v => v.type === "list").map(v => v.name)).flat(1));
            }
            case "in this sprite": {
                const target = util.target;
                if (!target) return "[]";
                const variables = target.variables;
                if (!variables) return "[]";
                return JSON.stringify(Object.values(variables).filter(v => v.type === "list").map(v => v.name));
            }
            default: return "[]";
        }
    }

    // ShovelUtils
    getFrameRate() { return fps }
    addSoundUrl(args, util) {
        const targetId = util.target.id;
        return new Promise((resolve) => {
            fetch(args.URL)
                .then((r) => r.arrayBuffer())
                .then((arrayBuffer) => {
                    const storage = this.runtime.storage;
                    const asset = new storage.Asset(
                        storage.AssetType.Sound, null, storage.DataFormat.MP3,
                        new Uint8Array(arrayBuffer), true
                    );
                    resolve(vm.addSound({
                        md5: asset.assetId + '.' + asset.dataFormat,
                        asset: asset, name: args.NAME
                    }, targetId));
                }).catch(resolve);
        })
    }

    // GameUtils
    addSpriteUrl(args) {
        return new Promise((resolve) => {
            fetch(args.URL).then(response => {
                response.arrayBuffer().then(arrayBuffer => {
                    vm.addSprite(arrayBuffer).finally(resolve);
                }).catch(resolve);
            }).catch(resolve);
        });
    }

    // variables
    variables_createVariable(args, util) {
        const variableName = args.NAME;
        switch (args.SCOPE) {
            case "all sprites": return this.runtime.createNewGlobalVariable(variableName);
            case "this sprite": return util.target.createVariable(this._generateScratchId(), variableName, "");
        }
    }
    variables_createCloudVariable(args) {
        const variableName = `☁ ${args.NAME}`;
        const stage = this.runtime.getTargetForStage();
        if (!stage) return;
        const id = this._generateScratchId();
        stage.createVariable(id, variableName, "", true);
    }
    variables_createList(args, util) {
        const variableName = args.NAME;
        switch (args.SCOPE) {
            case "all sprites": return this.runtime.createNewGlobalVariable(variableName, null, "list");
            case "this sprite": return util.target.createVariable(this._generateScratchId(), variableName, "list");
        }
    }
    variables_getVariable(args, util) {
        const variableName = args.NAME;
        let target;
        let isCloud = false;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else if (args.SCOPE === "cloud") {
            target = this.runtime.getTargetForStage();
            isCloud = true;
        } else return "";
        const variables = Object.values(target.variables).filter(variable => variable.type !== "list").filter(variable => {
            if (variable.isCloud) return String(variable.name).replace("☁ ", "") === variableName;
            if (isCloud) return false; // above check should have already told us its a cloud variable
            return variable.name === variableName;
        });
        if (!variables) return "";
        const variable = variables[0];
        if (!variable) return "";
        return variable.value;
    }
    variables_getList(args, util) {
        const variableName = args.NAME;
        let target;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else return "[]";
        const variables = Object.values(target.variables).filter(v => v.type === "list").filter(v => v.name === variableName);
        if (!variables) return "[]";
        const variable = variables[0];
        if (!variable) return "[]";
        return JSON.stringify(variable.value);
    }
    variables_deleteVariable(args, util) {
        const variableName = args.NAME;
        let target, isCloud = false;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else if (args.SCOPE === "cloud") {
            target = this.runtime.getTargetForStage();
            isCloud = true;
        } else return;
        const variables = Object.values(target.variables).filter(v => v.type !== "list").filter(variable => {
            if (variable.isCloud) return String(variable.name).replace("☁ ", "") === variableName;
            if (isCloud) return false; // above check should have already told us its a cloud variable
            return variable.name === variableName;
        });
        if (!variables) return;
        const variable = variables[0];
        if (!variable) return;
        return target.deleteVariable(variable.id);
    }
    variables_deleteList(args, util) {
        const variableName = args.NAME;
        let target;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else return;
        const variables = Object.values(target.variables).filter(v => v.type === "list").filter(v => v.name === variableName);
        if (!variables) return;
        const variable = variables[0];
        if (!variable) return;
        return target.deleteVariable(variable.id);
    }
    variables_existsVariable(args, util) {
        const variableName = args.NAME;
        let target, isCloud = false;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else if (args.SCOPE === "cloud") {
            target = this.runtime.getTargetForStage();
            isCloud = true;
        } else return false;
        const variables = Object.values(target.variables).filter(v => v.type !== "list").filter(variable => {
            if (variable.isCloud) return String(variable.name).replace("☁ ", "") === variableName;
            if (isCloud) return false; // above check should have already told us its a cloud variable
            return variable.name === variableName;
        });
        if (!variables) return false;
        const variable = variables[0];
        if (!variable) return false;
        return true;
    }
    variables_existsList(args, util) {
        const variableName = args.NAME;
        let target;
        if (args.SCOPE === "all sprites") target = this.runtime.getTargetForStage();
        else if (args.SCOPE === "this sprite") target = util.target;
        else return false;
        const variables = Object.values(target.variables).filter(v => v.type === "list").filter(v => v.name === variableName);
        if (!variables) return false;
        const variable = variables[0];
        if (!variable) return false;
        return true;
    }
}

module.exports = JgRuntimeBlocks;