package extensions {

import flash.external.ExternalInterface;

import flash.net.*;

import flash.utils.getTimer;

import blocks.Block;

import interpreter.*;

import util.*;

public class ExtensionManager {

private var app:Scratch;

private var extensionDict:Object = new Object(); // extension name -> extension record

private var justStartedWait:Boolean;

static public const wedoExt:String = 'LEGO WeDo';

public function ExtensionManager(app:Scratch) {

this.app = app;

clearImportedExtensions();

}

public function extensionActive(extName:String):Boolean {

return extensionDict.hasOwnProperty(extName);

}

public function isInternal(extName:String):Boolean {

return (extensionDict.hasOwnProperty(extName) && extensionDict[extName].isInternal);

}

public function clearImportedExtensions():void {

// Clear imported extensions before loading a new project.

extensionDict = {};

//extensionDict['PicoBoard'] = ScratchExtension.PicoBoard();

extensionDict[wedoExt] = ScratchExtension.WeDo();

}

// -----------------------------

// Block Specifications

//------------------------------

public function specForCmd(op:String):Array {

// Return a command spec array for the given operation or null.

for each (var ext:ScratchExtension in extensionDict) {

var prefix:String = ext.useScratchPrimitives ? '' : (ext.name + '.');

for each (var spec:Array in ext.blockSpecs) {

if ((spec.length > 2) && ((prefix + spec[2]) == op)) {

return [spec[1], spec[0], Specs.extensionsCategory, op, spec.slice(3)];

}

}

}

return null;

}

// -----------------------------

// Enable/disable/reset

//------------------------------

public function setEnabled(extName:String, flag:Boolean):void {

var ext:ScratchExtension = extensionDict[extName];

if (ext && ext.showBlocks != flag) {

ext.showBlocks = flag;

if(app.jsEnabled) {

if(flag && ext.javascriptURL) {

ExternalInterface.call('ScratchExtensions.loadExternalJS', ext.javascriptURL);

ext.showBlocks = false; // Wait for it to load

}

else if(!flag) {

ExternalInterface.call('ScratchExtensions.unregister', extName);

}

}

}

}

public function isEnabled(extName:String):Boolean {

var ext:ScratchExtension = extensionDict[extName];

return ext ? ext.showBlocks : false;

}

public function enabledExtensions():Array {

// Answer an array of enabled extensions, sorted alphabetically.

var result:Array = [];

for each (var ext:ScratchExtension in extensionDict) {

if (ext.showBlocks) result.push(ext);

}

result.sortOn('name');

return result;

}

public function stopButtonPressed():* {

// Send a reset_all command to all active extensions.

for each (var ext:ScratchExtension in enabledExtensions()) {

call(ext.name, 'reset_all', []);

}

}

// -----------------------------

// Importing

//------------------------------

public function importExtension():void {

function fileSelected(event:Event):void {

if (fileList.fileList.length == 0) return;

var file:FileReference = FileReference(fileList.fileList[0]);

file.addEventListener(Event.COMPLETE, fileLoaded);

file.load();

}

function fileLoaded(event:Event):void {

var extObj:Object;

try {

extObj = util.JSON.parse(FileReference(event.target).data.toString());

} catch(e:*) {}

if (!extObj || !('extensionName' in extObj) || !('extensionPort' in extObj)) return;

if (!extObj.blockSpecs) extObj.blockSpecs = [];

loadRawExtension(extObj);

}

var fileList:FileReferenceList = new FileReferenceList();

fileList.addEventListener(Event.SELECT, fileSelected);

try {

// Ignore the exception that happens when you call browse() with the file browser open

fileList.browse();

} catch(e:*) {}

}

public function extensionsToSave():Array {

// Answer an array of extension descriptor objects for imported extensions to be saved with the project.

var result:Array = [];

for each (var ext:ScratchExtension in extensionDict) {

if(!ext.showBlocks) continue;

var descriptor:Object = {};

descriptor.extensionName = ext.name;

descriptor.blockSpecs = ext.blockSpecs;

descriptor.menus = ext.menus;

if(ext.port) descriptor.extensionPort = ext.port;

else if(ext.javascriptURL) descriptor.javascriptURL = ext.javascriptURL;

result.push(descriptor);

}

return result;

}

public function callCompleted(extensionName:String, id:Number):void {

var ext:ScratchExtension = extensionDict[extensionName];

if (ext == null) return; // unknown extension

var index:int = ext.busy.indexOf(id);

if(index > -1) ext.busy.splice(index, 1);

}

public function reporterCompleted(extensionName:String, id:Number, retval:*):void {

var ext:ScratchExtension = extensionDict[extensionName];

if (ext == null) return; // unknown extension

var index:int = ext.busy.indexOf(id);

if(index > -1) {

ext.busy.splice(index, 1);

for(var b:Object in ext.waiting) {

if(ext.waiting[b] == id) {

delete ext.waiting[b];

(b as Block).response = retval;

(b as Block).requestState = 2;

}

}

}

}

public function loadRawExtension(extObj:Object):void {

var ext:ScratchExtension = extensionDict[extObj.extensionName];

if(!ext || (ext.blockSpecs && ext.blockSpecs.length))

ext = new ScratchExtension(extObj.extensionName, extObj.extensionPort);

ext.blockSpecs = extObj.blockSpecs;

if(extObj.url) ext.url = extObj.url;

ext.showBlocks = true;

ext.menus = extObj.menus;

ext.javascriptURL = extObj.javascriptURL;

if (extObj.host) ext.host = extObj.host; // non-local host allowed but not saved in project

extensionDict[extObj.extensionName] = ext;

Scratch.app.translationChanged();

Scratch.app.updatePalette();

// Update the indicator

for (var i:int = 0; i < app.palette.numChildren; i++) {

var indicator:IndicatorLight = app.palette.getChildAt(i) as IndicatorLight;

if (indicator && indicator.target === ext) {

updateIndicator(indicator, indicator.target, true);

break;

}

}

}

public function loadSavedExtensions(savedExtensions:Array):void {

// Reset the system extensions and load the given array of saved extensions.

if (!savedExtensions) return; // no saved extensions

for each (var extObj:Object in savedExtensions) {

if (!('extensionName' in extObj) ||

(!('extensionPort' in extObj) && !('javascriptURL' in extObj)) ||

!('blockSpecs' in extObj)) {

continue;

}

if (extensionDict[extObj.extensionName] &&

extensionDict[extObj.extensionName].isInternal) {

setEnabled(extObj.extensionName, true);

continue; // internal extension overrides one saved in project

}

var ext:ScratchExtension = new ScratchExtension(extObj.extensionName, extObj.extensionPort || 0);

ext.blockSpecs = extObj.blockSpecs;

ext.showBlocks = true;

ext.menus = extObj.menus;

if(extObj.javascriptURL) ext.javascriptURL = extObj.javascriptURL;

extensionDict[extObj.extensionName] = ext;

}

Scratch.app.updatePalette();

}

// -----------------------------

// Menu Support

//------------------------------

public function menuItemsFor(op:String, menuName:String):Array {

// Return a list of menu items for the given menu of the extension associated with op or null.

var i:int = op.indexOf('.');

if (i < 0) return null;

var ext:ScratchExtension = extensionDict[op.slice(0, i)];

if (ext == null) return null; // unknown extension

return ext.menus[menuName];

}

// -----------------------------

// Status Indicator

//------------------------------

public function updateIndicator(indicator:IndicatorLight, ext:ScratchExtension, firstTime:Boolean = false):void {

if(ext.port > 0) {

var msecsSinceLastResponse:uint = getTimer() - ext.lastPollResponseTime;

if (msecsSinceLastResponse > 500) indicator.setColorAndMsg(0xE00000, 'Cannot find helper app');

else if (ext.problem != '') indicator.setColorAndMsg(0xE0E000, ext.problem);

else indicator.setColorAndMsg(0x00C000, 'Okay');

}

else if(app.jsEnabled) {

var retval:Object = ExternalInterface.call('ScratchExtensions.getStatus', ext.name);

if(!retval) retval = {status: 0, msg: 'Cannot communicate with extension.'};

var color:uint;

if(retval.status == 2) color = 0x00C000;

else if(retval.status == 1) color = 0xE0E000;

else {

color = 0xE00000;

if(firstTime) {

Scratch.app.showTip('extensions');

DialogBox.notify('Extension Problem', 'See the Tips window (on the right) to install the plug-in and get the extension working.', Scratch.app.stage);

}

}

indicator.setColorAndMsg(color, retval.msg);

}

}

// -----------------------------

// Execution

//------------------------------

public function primExtensionOp(b:Block):* {

var i:int = b.op.indexOf('.');

var extName:String = b.op.slice(0, i);

var ext:ScratchExtension = extensionDict[extName];

if (ext == null) return 0; // unknown extension

var primOrVarName:String = b.op.slice(i + 1);

var args:Array = [];

for (i = 0; i < b.args.length; i++) {

args.push(app.interp.arg(b, i));

}

var value:*;

if (b.isReporter) {

if(b.isRequester) {

if(b.requestState == 2) {

b.requestState = 0;

return b.response;

}

else if(b.requestState == 0) {

request(extName, primOrVarName, args, b);

}

// Returns null if we just made a request or we're still waiting

return null;

}

else {

var sensorName:String = primOrVarName;

if(ext.port > 0) { // we were checking ext.isInternal before, should we?

for each (var a:* in args) sensorName += '/' + a; // append menu args

value = ext.stateVars[sensorName];

}

else if(Scratch.app.jsEnabled) {

// Javascript

value = ExternalInterface.call('ScratchExtensions.getReporter', ext.name, sensorName, args);

}

if (value == undefined) value = 0; // default to zero if missing

if ('b' == b.type) value = ('true' == value); // coerce value to a boolean

return value;

}

} else {

if ('w' == b.type) {

var activeThread:Thread = app.interp.activeThread;

if (activeThread.firstTime) {

var id:int = ++ext.nextID; // assign a unique ID for this call

ext.busy.push(id);

activeThread.tmp = id;

activeThread.firstTime = false;

app.interp.doYield();

justStartedWait = true;

if(ext.port == 0) {

if(app.jsEnabled)

ExternalInterface.call('ScratchExtensions.runAsync', ext.name, primOrVarName, args, id);

else

ext.busy.pop();

return;

}

args.unshift(id); // pass the ID as the first argument

} else {

if (ext.busy.indexOf(activeThread.tmp) > -1) {

app.interp.doYield();

} else {

activeThread.tmp = 0;

activeThread.firstTime = true;

}

return;

}

}

call(extName, primOrVarName, args);

}

}

public function call(extensionName:String, op:String, args:Array):void {

var ext:ScratchExtension = extensionDict[extensionName];

if (ext == null) return; // unknown extension

if (ext.port > 0) {

var activeThread:Thread = app.interp.activeThread;

if(activeThread && op != 'reset_all') {

if(activeThread.firstTime) {

httpCall(ext, op, args);

activeThread.firstTime = false;

app.interp.doYield();

}

else {

activeThread.firstTime = true;

}

}

else

httpCall(ext, op, args);

} else {

if(op == 'reset_all') op = 'resetAll';

// call a JavaScript extension function with the given arguments

if(Scratch.app.jsEnabled) ExternalInterface.call('ScratchExtensions.runCommand', ext.name, op, args);

app.interp.redraw(); // make sure interpreter doesn't do too many extension calls in one cycle

}

}

public function request(extensionName:String, op:String, args:Array, b:Block):void {

var ext:ScratchExtension = extensionDict[extensionName];

if (ext == null) {

// unknown extension, skip the block

b.requestState = 2;

return;

}

if (ext.port > 0) {

httpRequest(ext, op, args, b);

} else if(Scratch.app.jsEnabled) {

// call a JavaScript extension function with the given arguments

b.requestState = 1;

++ext.nextID;

ext.busy.push(ext.nextID);

ext.waiting[b] = ext.nextID;

ExternalInterface.call('ScratchExtensions.getReporterAsync', ext.name, op, args, ext.nextID);

}

}

private function httpRequest(ext:ScratchExtension, op:String, args:Array, b:Block):void {

function responseHandler(e:Event):void {

if(e.type == Event.COMPLETE)

b.response = loader.data;

else

b.response = '';

b.requestState = 2;

b.requestLoader = null;

}

var loader:URLLoader = new URLLoader();

loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, responseHandler);

loader.addEventListener(IOErrorEvent.IO_ERROR, responseHandler);

loader.addEventListener(Event.COMPLETE, responseHandler);

b.requestState = 1;

b.requestLoader = loader;

var url:String = 'http://' + ext.host + ':' + ext.port + '/' + op;

for each (var arg:* in args) {

url += '/' + ((arg is String) ? escape(arg) : arg);

}

loader.load(new URLRequest(url));

}

private function httpCall(ext:ScratchExtension, op:String, args:Array):void {

function errorHandler(e:Event):void { } // ignore errors

var url:String = 'http://' + ext.host + ':' + ext.port + '/' + op;

for each (var arg:* in args) {

url += '/' + ((arg is String) ? escape(arg) : arg);

}

var loader:URLLoader = new URLLoader();

loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);

loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);

loader.load(new URLRequest(url));

}

public function getStateVar(extensionName:String, varName:String, defaultValue:*):* {

var ext:ScratchExtension = extensionDict[extensionName];

if (ext == null) return defaultValue; // unknown extension

var value:* = ext.stateVars[varName];

return (value == undefined) ? defaultValue : value;

}

// -----------------------------

// Polling

//------------------------------

public function step():void {

// Poll all extensions.

for each (var ext:ScratchExtension in extensionDict) {

if (ext.showBlocks) {

if (!ext.isInternal && ext.port > 0) {

if (ext.blockSpecs.length == 0) httpGetSpecs(ext);

httpPoll(ext);

}

}

}

}

private function httpGetSpecs(ext:ScratchExtension):void {

// Fetch the block specs (and optional menu specs) from the helper app.

function completeHandler(e:Event):void {

var specsObj:Object;

try {

specsObj = util.JSON.parse(loader.data);

} catch(e:*) {}

if (!specsObj) return;

// use the block specs and (optionally) menu returned by the helper app

if (specsObj.blockSpecs) ext.blockSpecs = specsObj.blockSpecs;

if (specsObj.menus) ext.menus = specsObj.menus;

}

function errorHandler(e:Event):void { } // ignore errors

var url:String = 'http://' + ext.host + ':' + ext.port + '/get_specs';

var loader:URLLoader = new URLLoader();

loader.addEventListener(Event.COMPLETE, completeHandler);

loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);

loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);

loader.load(new URLRequest(url));

}

private function httpPoll(ext:ScratchExtension):void {

// Poll via HTTP.

function completeHandler(e:Event):void {

processPollResponse(ext, loader.data);

}

function errorHandler(e:Event):void { } // ignore errors

var url:String = 'http://' + ext.host + ':' + ext.port + '/poll';

var loader:URLLoader = new URLLoader();

loader.addEventListener(Event.COMPLETE, completeHandler);

loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);

loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);

loader.load(new URLRequest(url));

}

private function processPollResponse(ext:ScratchExtension, response:String):void {

if (response == null) return;

ext.lastPollResponseTime = getTimer();

ext.problem = '';

// clear the busy list unless we just started a command that waits

if (justStartedWait) justStartedWait = false;

else ext.busy = [];

var lines:Array = response.split('\n');

for each (var line:String in lines) {

var tokens:Array = ReadStream.tokenize(line);

if (tokens.length > 1) {

var key:String = tokens[0];

if (key.indexOf('_') == 0) { // internal status update or response

if ('_busy' == key) {

for (var i:int = 1; i < tokens.length; i++) {

var id:int = parseInt(tokens[i]);

if (ext.busy.indexOf(id) == -1) ext.busy.push(id);

}

}

if ('_problem' == key) ext.problem = line.slice(9);

} else { // sensor value

var val:String = tokens[1];

var n:Number = Number(val);

ext.stateVars[key] = isNaN(n) ? val : n;

}

}

}

}

}}