/// <reference name="MicrosoftAjax.js"/>

//-----------------------------------------------------------------------
// Copyright (C) David Muñoz. All rights reserved. [06/04/2009]
//-----------------------------------------------------------------------
// Fwk.Commons.js
//-----------------------------------------------------------------------
Type.registerNamespace("Fwk");

//-----------------------------------------------------------------------
// Fwk.GenericEventArgs.js
//-----------------------------------------------------------------------
Fwk.GenericEventArgs=function(event) {
    Fwk.GenericEventArgs.initializeBase(this);
    this._domEvent=event;
};
Fwk.GenericEventArgs.prototype={
    get_domEvent: function() {
        return this._domEvent;
    }
};
Fwk.GenericEventArgs.registerClass("Fwk.GenericEventArgs",Sys.EventArgs);

//-----------------------------------------------------------------------
// Fwk.ItemEventArgs.js
//-----------------------------------------------------------------------
Fwk.ItemEventArgs=function(index,item) {
    Fwk.ItemEventArgs.initializeBase(this);
    this._item=item;
    this._index=index;
};
Fwk.ItemEventArgs.prototype={
    get_item: function() {
        return this._item;
    },

    get_index: function() {
        return this._index;
    }
};
Fwk.ItemEventArgs.registerClass("Fwk.ItemEventArgs",Sys.EventArgs);

//-----------------------------------------------------------------------
// Fwk.WebServiceLoaderEventArgs.js
//-----------------------------------------------------------------------
Fwk.WebServiceLoaderEventArgs=function(context) {
    Fwk.WebServiceLoaderEventArgs.initializeBase(this);
    this._context=context;
};
Fwk.WebServiceLoaderEventArgs.prototype={
    get_context: function() {
        return this._context;
    }
};
Fwk.WebServiceLoaderEventArgs.registerClass("Fwk.WebServiceLoaderEventArgs",Sys.EventArgs);

//-----------------------------------------------------------------------
// Fwk.WebServiceLoaderSuccessEventArgs.js
//-----------------------------------------------------------------------
Fwk.WebServiceLoaderSuccessEventArgs=function(data,context) {
    Fwk.WebServiceLoaderSuccessEventArgs.initializeBase(this,[context]);
    this._data=data;
};
Fwk.WebServiceLoaderSuccessEventArgs.prototype={
    get_data: function() {
        return this._data;
    }
};
Fwk.WebServiceLoaderSuccessEventArgs.registerClass("Fwk.WebServiceLoaderSuccessEventArgs",Fwk.WebServiceLoaderEventArgs);

//-----------------------------------------------------------------------
// Fwk.WebServiceLoaderErrorEventArgs.js
//-----------------------------------------------------------------------
Fwk.WebServiceLoaderErrorEventArgs=function(message,context) {
    Fwk.WebServiceLoaderErrorEventArgs.initializeBase(this,[context]);
    this._message=message;
};
Fwk.WebServiceLoaderErrorEventArgs.prototype={
    get_message: function() {
        return this._message;
    }
};
Fwk.WebServiceLoaderErrorEventArgs.registerClass("Fwk.WebServiceLoaderErrorEventArgs",Fwk.WebServiceLoaderEventArgs);

//-----------------------------------------------------------------------
// Fwk.WebServiceLoader.js
//-----------------------------------------------------------------------
Fwk.WebServiceLoader=function(webServiceSettings) {
    this._webServiceSettings=webServiceSettings;
    this._events=null;
    this._currentWebRequest=null;
    this._onWebServiceSuccessDelegate=Function.createDelegate(this,this._onWebServiceSuccess);
    this._onWebServiceErrorDelegate=Function.createDelegate(this,this._onWebServiceError);
};
Fwk.WebServiceLoader.prototype={
    get_webServiceSettings: function() {
        return this._webServiceSettings;
    },

    get_events: function() {
        if(!this._events)
            this._events=new Sys.EventHandlerList();

        return this._events;
    },

    loadData: function(params,context) {
        var settings=this.get_webServiceSettings();
        if(settings.get_isEmpty()) {
            Error.invalidOperation("Please, specify valid web service and method.");
            return;
        }
        var servicePath=settings.get_path();
        var methodName=settings.get_method();

        this._raiseEvent("loadingStarted",new Fwk.WebServiceLoaderEventArgs(context));
        this._currentWebRequest=Sys.Net.WebServiceProxy.invoke(servicePath,methodName,false,params,this._onWebServiceSuccessDelegate,this._onWebServiceErrorDelegate,context);
    },

    add_loadingStarted: function(args) {
        this.get_events().addHandler("loadingStarted",args);
    },

    add_loadingError: function(args) {
        this.get_events().addHandler("loadingError",args);
    },

    add_loadingSuccess: function(args) {
        this.get_events().addHandler("loadingSuccess",args);
    },

    _onWebServiceSuccess: function(data,context) {
        var args=new Fwk.WebServiceLoaderSuccessEventArgs(data,context);
        this._raiseEvent("loadingSuccess",args);
    },

    _onWebServiceError: function(error,context) {
        var args=new Fwk.WebServiceLoaderErrorEventArgs(error.get_message(),context);
        this._raiseEvent("loadingError",args);
    },

    _raiseEvent: function(event,args) {
        var handler=this.get_events().getHandler(event);
        if(handler) {
            if(!args)
                args=Sys.EventArgs.Empty;
            handler(this,args);
        }
    }
};
Fwk.WebServiceLoader.registerClass("Fwk.WebServiceLoader");

//-----------------------------------------------------------------------
// Fwk.WebServiceSettings.js
//-----------------------------------------------------------------------
Fwk.WebServiceSettings=function(data) {
    if(!data)
        data={ path: null,method: null,params: null };

    this._path=data.path;
    this._method=data.method;
    this._params=data.params;
};
Fwk.WebServiceSettings.prototype={
    get_path: function() {
        return this._path;
    },

    set_path: function(path) {
        this._path=path;
    },

    get_method: function() {
        return this._method;
    },

    set_method: function(method) {
        this._method=method;
    },

    get_params: function() {
        return this._params;
    },

    set_params: function(params) {
        this._params=params;
    },

    get_isEmpty: function() {
        var path=this.get_path();
        var method=this.get_method();
        return (!(path&&method));
    }
};
Fwk.WebServiceSettings.registerClass("Fwk.WebServiceSettings");

//-----------------------------------------------------------------------
// Fwk.GenericItemCollection 
//-----------------------------------------------------------------------
Fwk.GenericItemCollection=function(parent) {
    this._parent=parent;     //Padre
    this._array=new Array();
}
Fwk.GenericItemCollection.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    get_parent: function() {
        return this._parent;
    },

    get_count: function() {
        return this._array.length;
    },

    get_item: function(index) {
        return this._array[index];
    },

    //-------------------------------------------------------------------------------------------------------------
    //Metodos
    //--------------------------------------------------------------------------------------------------------------
    add: function(item) {
        var arraylength=this._array.length;
        return this.insert(arraylength,item);
    },

    addAt: function(index,item) {
        return this.insert(index,item);
    },

    insert: function(index,item) {
        Array.insert(this._array,index,item);

        if(typeof item._parent!="undefined") {
            item._parent=this._parent;

            var n=Object.getType(item).getName();
            n=String.format("item._parent.on{0}Insert",n.substring(n.lastIndexOf(".")+1,n.length));
            if(typeof eval(n)=="function")
                eval(String.format("{0}(item._parent,new Fwk.ItemEventArgs(index,item))",n));
        }

        return item;
    },

    remove: function(item) {
        Array.remove(this._array,item);
    },

    removeAt: function(index) {
        var item=this.get_item(index);
        if(item)
            this.remove(item);
    },

    clear: function() {
        Array.clear(this._array);
    },

    indexOf: function(item) {
        return Array.indexOf(this._array,item);
    },

    forEach: function(_evalfunction) {
        for(var _$i=0,count=this.get_count();_$i<count;_$i++)
            _evalfunction(this._array[_$i],_$i);
    },

    serialize: function() {
        return Sys.Serialization.JavaScriptSerializer.serialize(this._array);
    }
}
Fwk.GenericItemCollection.registerClass('Fwk.GenericItemCollection');

//-----------------------------------------------------------------------
//  Fwk.DataTableCollection.js
//-----------------------------------------------------------------------
Fwk.DataTableCollection=function(parent) {
    Fwk.DataTableCollection.initializeBase(this,[parent]);
};
Fwk.DataTableCollection.prototype={
    get_item: function(value) {
        for(var index=0;index<this.get_count();index++) {
            var item=Fwk.DataTableCollection.callBaseMethod(this,"get_item",[index]);;
            switch(typeof (value)) {
                case "number":
                    if(item.get_index()==value)
                        return item;
                    break;
                case "string":
                    if(item.get_name()==value)
                        return item;
                    break;
            }
        }
        return null;
    }
};
Fwk.DataTableCollection.registerClass("Fwk.DataTableCollection",Fwk.GenericItemCollection);

//-----------------------------------------------------------------------
//  Fwk.DataRowCollection.js
//-----------------------------------------------------------------------
Fwk.DataRowCollection=function(parent) {
    Fwk.DataRowCollection.initializeBase(this,[parent]);
};
Fwk.DataRowCollection.prototype={};
Fwk.DataRowCollection.registerClass("Fwk.DataRowCollection",Fwk.GenericItemCollection);

//-----------------------------------------------------------------------
//  Fwk.DataCellCollection.js
//-----------------------------------------------------------------------
Fwk.DataCellCollection=function(parent) {
    Fwk.DataCellCollection.initializeBase(this,[parent]);
};
Fwk.DataCellCollection.prototype={
    get_item: function(value) {
        switch(typeof (value)) {
            case "number":
                for(var index=0;index<this.get_count();index++) {
                    var item=Fwk.DataCellCollection.callBaseMethod(this,"get_item",[index]);;
                    if(item.get_index()==value) {
                        return item;
                    }
                }
                break;
            case "string":
                var table=this._parent.get_table();
                for(var index=0;index<table.get_columns().get_count();index++) {
                    var column=table.get_columns().get_item(index);

                    if(column.get_name()==value) {
                        return Fwk.DataCellCollection.callBaseMethod(this,"get_item",[column.get_index()]);;
                    }
                }
                break;
        }
        return null;
    }
};
Fwk.DataCellCollection.registerClass("Fwk.DataCellCollection",Fwk.GenericItemCollection);

//-----------------------------------------------------------------------
//  Fwk.DataColumnCollection.js
//-----------------------------------------------------------------------
Fwk.DataColumnCollection=function(parent) {
    Fwk.DataColumnCollection.initializeBase(this,[parent]);
};
Fwk.DataColumnCollection.prototype={};
Fwk.DataColumnCollection.registerClass("Fwk.DataColumnCollection",Fwk.DataTableCollection);

//-----------------------------------------------------------------------
// Fwk.DataTable
//-----------------------------------------------------------------------
Fwk.DataTable=function(name) {
    this._name=name||"";
    this._index= -1;
    this._parent=null;
    this._rows=new Fwk.DataRowCollection(this);
    this._columns=new Fwk.DataColumnCollection(this);
}
Fwk.DataTable.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    get_datasource: function() {
        return this._parent;
    },

    get_index: function() {
        return this._index;
    },

    get_name: function() {
        return this._name;
    },

    get_rows: function(index) {
        return ((typeof index!=="undefined")?this._rows.get_item(index):this._rows);
    },

    get_columns: function(index) {
        return ((typeof index!=="undefined")?this._columns.get_item(index):this._columns);
    }
}
Fwk.DataTable.registerClass('Fwk.DataTable');

//-----------------------------------------------------------------------
// Fwk.DataRow
//-----------------------------------------------------------------------
Fwk.DataRow=function() {
    this._parent=null;
    this._index= -1;
    this._key= -1;
    this._cells=new Fwk.DataCellCollection(this);
}
Fwk.DataRow.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    get_table: function() {
        return this._parent;
    },

    get_index: function() {
        return this._index;
    },

    get_cells: function(index) {
        return ((typeof index!=="undefined")?this._cells.get_item(index):this._cells);
    },

    get_key: function() {
        return this._key;
    }
}
Fwk.DataRow.registerClass('Fwk.DataRow');

//-----------------------------------------------------------------------
// Fwk.DataCell
//-----------------------------------------------------------------------
Fwk.DataCell=function(value) {
    this._parent=null;
    this._index= -1;
    this._value=value||null;
}
Fwk.DataCell.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    get_row: function() {
        return this._parent;
    },

    get_index: function() {
        return this._index;
    },

    get_value: function() {
        return this._value;
    },

    hasValue: function() {
        return (this._value)
    }
}
Fwk.DataCell.registerClass('Fwk.DataCell');

//-----------------------------------------------------------------------
// Fwk.DataColumn
//-----------------------------------------------------------------------
Fwk.DataColumn=function(name) {
    this._parent=null;
    this._index= -1;
    this._parent=null
    this._name=name||"";
}
Fwk.DataColumn.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    get_table: function() {
        return this._parent;
    },

    get_index: function() {
        return this._index;
    },

    get_name: function() {
        return this._name;
    }
}
Fwk.DataColumn.registerClass('Fwk.DataColumn');

//-----------------------------------------------------------------------
// Fwk.DataSet
//-----------------------------------------------------------------------
Fwk.DataSet=function(data) {
    this._tables=new Fwk.DataTableCollection(this);
    this._initialize(data);
}
Fwk.DataSet.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Propiedades
    //--------------------------------------------------------------------------------------------------------------
    _initialize: function(v) {
        if (v =="" || v == null || typeof v == "undefined"){
            v = [];
        }
        
        if (Object.getType(v).getName() == "String"){
            v = eval("("+v+")");
        }
        
        if (Object.getType(v).getName() !== "Array"){
            v = [v];
        }
        
        for (var ii=0; ii < v.length; ii++){
            var data = v[ii];
            var table=new Fwk.DataTable("Table"+(ii+1));
            table._index=ii;
            this.get_tables().add(table);

        
            for(var colIndex in data.columnNames) {
                var dataColumn=new Fwk.DataColumn(data.columnNames[colIndex]);
                dataColumn._index=Number(colIndex);
                table.get_columns().add(dataColumn);
            }

            for(var rowIndex in data.rows) {
                var row=data.rows[rowIndex];
                var dataRow=new Fwk.DataRow();
                dataRow._index=Number(rowIndex);
                dataRow._key=row.key|| -1;

                for(var cellIndex in row.cells) {
                    var dataCell=new Fwk.DataCell(row.cells[cellIndex]);
                    dataCell._index=Number(cellIndex);
                    dataRow.get_cells().add(dataCell);
                }

                table.get_rows().add(dataRow);
            }
        }
    },

    get_tables: function(index) {

        return ((typeof index!=="undefined")?this._tables.get_item(index):this._tables);
    }
}
Fwk.DataSet.registerClass('Fwk.DataSet');

//-----------------------------------------------------------------------
// Fwk.Param.js
//-----------------------------------------------------------------------
Fwk.Param=function(name,value) {
    this._name=name||null;
    this._value=value||null;
}
Fwk.Param.prototype={
    get_name: function() {
        return this._name;
    },

    get_value: function() {
        return this._value;
    }
}
Fwk.Param.registerClass('Fwk.Param');

//-----------------------------------------------------------------------
//  Fwk.Params.js
//-----------------------------------------------------------------------
Fwk.Params=function(parent,jsonParams) {
    Fwk.Params.initializeBase(this,[parent]);
};
Fwk.Params.prototype={
    get_param: function(parameterName) {
        for(var paramIndex=0;paramIndex<this.get_count();paramIndex++) {
            var param=this.get_item(paramIndex);
            if(param[0]==parameterName)
                return { Name: param[0],Value: param[1] };
        }
        return "";
    }
};
Fwk.Params.registerClass("Fwk.Params",Fwk.GenericItemCollection);

//-----------------------------------------------------------------------
// Fwk.Request
//-----------------------------------------------------------------------
Fwk.Request=function() {
    this._params=new Fwk.Params(this);     //Padre
    this.initialize();
}
Fwk.Request.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Metodos
    //--------------------------------------------------------------------------------------------------------------
    initialize: function() {
        var l=document.location.href;
        var q=l.substring(l.indexOf("?")+1,l.length);
        var ps=this._params;

        var f=function(t) {
            var n=t.substring(0,t.indexOf("="));
            var v=t.substring(t.indexOf("=")+1);
            ps.add([n,v]);
        }

        if(q.indexOf("&")>0)
            while(q.indexOf("&")>=0) {
            f(q.substring(0,q.indexOf("&")));
            q=q.substring(q.indexOf("&")+1);
        }

        if(q.length>0)
            f(q);
    },

    get_params: function(value) {
        return ((typeof value=="string")?this._params.get_param(value).Value:this._params);
    }
}
Fwk.Request.registerClass('Fwk.Request');

//-----------------------------------------------------------------------
// Fwk.Timer.js
//-----------------------------------------------------------------------
Fwk.Timer=function() {
    Fwk.Timer.initializeBase(this);
    this._interval=1000;
    this._enabled=false;
    this._timer=null;
}

Fwk.Timer.prototype={
    get_interval: function() {
        return this._interval;
    },

    set_interval: function(value) {
        if(this._interval!==value) {
            this._interval=value;
            this.raisePropertyChanged('interval');
            if(!this.get_isUpdating()&&(this._timer!==null)) {
                this._stopTimer();
                this._startTimer();
            }
        }
    },

    get_enabled: function() {
        return this._enabled;
    },

    set_enabled: function(value) {
        if(value!==this.get_enabled()) {
            this._enabled=value;
            this.raisePropertyChanged('enabled');
            if(!this.get_isUpdating())
                if(value)
                this._startTimer();
            else
                this._stopTimer();
        }
    },

    add_tick: function(handler) {
        this.get_events().addHandler("tick",handler);
    },

    remove_tick: function(handler) {
        this.get_events().removeHandler("tick",handler);
    },

    dispose: function() {
        this.set_enabled(false);
        this._stopTimer();
        Fwk.Timer.callBaseMethod(this,'dispose');
    },

    updated: function() {
        Fwk.Timer.callBaseMethod(this,'updated');
        if(this._enabled) {
            this._stopTimer();
            this._startTimer();
        }
    },

    _timerCallback: function() {
        var handler=this.get_events().getHandler("tick");
        if(handler)
            handler(this,Sys.EventArgs.Empty);
    },

    _startTimer: function() {
        this._timer=window.setInterval(Function.createDelegate(this,this._timerCallback),this._interval);
    },

    _stopTimer: function() {
        window.clearInterval(this._timer);
        this._timer=null;
    }
}

Fwk.Timer.descriptor={
    properties: [{ name: 'interval',type: Number },
                    { name: 'enabled',type: Boolean}],
    events: [{ name: 'tick'}]
}
Fwk.Timer.registerClass('Fwk.Timer',Sys.Component);

//-----------------------------------------------------------------------
// Fwk.Utils.js
//-----------------------------------------------------------------------
Fwk.Utils=function() {
    this._separadorMiles='.';
    this._separadorDecimales=',';
    this._browser={
        isIE: (Sys.Browser.agent==Sys.Browser.InternetExplorer),
        isFirefox: (Sys.Browser.agent==Sys.Browser.Firefox),
        isIE8: (Sys.Browser.agent==Sys.Browser.InternetExplorer&&Sys.Browser.version>=8),
        isIE7: (Sys.Browser.agent==Sys.Browser.InternetExplorer&&Sys.Browser.version==7),
        isIE6: (Sys.Browser.agent==Sys.Browser.InternetExplorer&&Sys.Browser.version==6)
    };
}
Fwk.Utils.prototype={
    //-----------------------------------------------------------------------
    // Metodos
    //-----------------------------------------------------------------------
    get_browser: function() {
        return this._browser;
    },

    getScrollXY: function() {
        var b=document.body;
        var e=document.documentElement;

        if(typeof (window.pageYOffset)=='number')  //Netscape compliant
            return { x: window.pageXOffset,y: window.pageYOffset };
        else if(b&&(b.scrollLeft||b.scrollTop)) //DOM compliant
            return { x: b.scrollLeft,y: b.scrollTop };
        else if(e&&(e.scrollLeft||e.scrollTop)) //IE6 standards compliant mode
            return { x: e.scrollLeft,y: e.scrollTop };

        return { x: 0,y: 0 };
    },

    getPageBounds: function() {
        var d=document.documentElement;
        var b=document.body;
        var wh=0;
        var ww=0;

        if(typeof (window.innerHeight)=='number')
            wh=window.innerHeight;
        else
            if(d&&d.clientHeight)
            wh=d.clientHeight;
        else
            if(b&&b.clientHeight)
            wh=b.clientHeight;

        if(typeof (window.innerWidth)=='number')
            ww=window.innerWidth;
        else
            if(d&&d.clientWidth)
            ww=d.clientWidth;
        else
            if(b&&b.clientWidth)
            ww=b.clientWidth;

        return { height: wh,width: ww,scrollHeight: d.scrollHeight,scrollWidth: d.scrollWidth };
    }
}
Fwk.Utils.registerClass('Fwk.Utils');
Fwk.Utils._staticInstance=new Fwk.Utils();
Fwk.Utils=Fwk.Utils._staticInstance;

//-----------------------------------------------------------------------
// Fwk.Page.js
//-----------------------------------------------------------------------
Fwk.Page=function() {
    this._controls=null;    //Child Controls Collection
    this._request=new Fwk.Request();                          //Request
}
Fwk.Page.prototype={
    //--------------------------------------------------------------------------------------------------------------
    //Metodos
    //--------------------------------------------------------------------------------------------------------------
    get_controls: function(index) {
        if(!this._controls) this._controls=new App.Common.ControlCollection(this)
        return (typeof index=="undefined"?this._controls:this._controls.get_item(index));
    },

    get_request: function() {
        return this._request;
    },

    //<--[DESIGN] (estas Lineas se sacan cuando se Publica)
    invokeMethod: function(method,params,successHandler,errorHandler,context,urlService) {
        var w=new Fwk.WebServiceLoader(new Fwk.WebServiceSettings({ path: urlService||servicePath,method: method }));

        if(!errorHandler)
            errorHandler=function(sender,error) { throw Error.create("Sys.WebServiceError: "+error.get_message()); }

        if(successHandler)
            w.add_loadingSuccess(successHandler);

        w.add_loadingError(errorHandler);

        w.loadData(params,context||method);
    },
    //<--[ENDDESIGN]

    invokeExtension: function(method,params,successHandlers,errorHandler,context) {
        var sh=[];

        if(typeof successHandlers!=="undefined") {
            if(Object.getType(successHandlers).getName()=="Array") {
                sh=successHandlers;
            } else {
                sh.push(successHandlers);
            }
        }
        
        var url ="";
        if (typeof WebSiteID !== "undefined"){
            url = "EditarSitioWeb.aspx";
        }else{
            url = serviceFwkPath;
        }
            
        var w=new Fwk.WebServiceLoader(new Fwk.WebServiceSettings({ path: url,method: "InvokeExtension" }));
        var p=[];

        if(params&&Object.getType(params).getName()!="Array")
            for(var name in params)
            Array.add(p,{ Name: name,Value: params[name] });
        else
            p=params||[];

        var mParams = { ExtensionName: method};
        //<--[DESIGN] (estas Lineas se sacan cuando se Publica)
        //En Produccion Siempre Envio el WebSiteID
        if (typeof WebSiteID !== "undefined"){
            Array.add(p,{ Name: "WebSiteID",Value: WebSiteID });   
            mParams.WebSiteID = WebSiteID
        }
        //<--[ENDDESIGN]
        mParams.JsonParams = Sys.Serialization.JavaScriptSerializer.serialize(p);
        
        if(!errorHandler){
            errorHandler=function(sender,error) { throw Error.create("Sys.WebServiceError: "+error.get_message()); }
        }
        
        for (var i=0; i<sh.length; i++){
            w.add_loadingSuccess(sh[i]);
        }
        
        w.add_loadingError(errorHandler);
        
        
        w.loadData(mParams,context||method);
    }
}
Fwk.Page.registerClass('Fwk.Page');

Fwk.Page._staticInstance=new Fwk.Page();
Fwk.Page=Fwk.Page._staticInstance;

//-----------------------------------------------------------------------
// Fwk.ScriptLoader.js
//-----------------------------------------------------------------------
Fwk.ScriptLoader=function() {
    this._scriptToLoad=[];
    this._scriptLoaded=[];
    this._isLoading=false;
    this._timer=new Fwk.Timer();
    this._scriptsFinished=0;
    this._errorHandler=null;
    this._successHandler=null;
    this._onScriptLoadHandler=null;
    this._timeOutDelegate=Function.createDelegate(this,this._timeOutHandler);
    this._scriptLoadedDelegate=this._scriptLoadedDelegate;
    this._timeOut=60000;    //60 Seg Timeout Default;
    this._timer.add_tick(this._timeOutDelegate);   //Delegado de Timeout
};
Fwk.ScriptLoader.prototype={
    loadScripts: function(Scripts,SuccessHandler,ErrorHandler,OnScriptLoadHandler,TimeOut) {
        this._scriptToLoad=Scripts;
        this._errorHandler=ErrorHandler;
        this._successHandler=SuccessHandler;
        this._onScriptLoadHandler=OnScriptLoadHandler;

        //Reseteo General ---------------------- 
        this._timer.set_interval(TimeOut||this._timeOut);   
        this._timer.set_enabled(true);     //Inicia el Time;
        this._scriptsFinished=0;
        this._isLoading=true;
        //---------------------------------------

        this._loadCurrentScript();
    },

    get_isLoading: function() {
        return this._isLoading;
    },

    isScriptLoaded: function(scriptElement) {
        for(var tindex=this._scriptLoaded.length-1;tindex>=0;tindex--)
            if(this._scriptLoaded[tindex].src.toLowerCase()==scriptElement.src.toLowerCase())
            return true;

        return false;
    },

    _loadCurrentScript: function() {
        var scriptElement=this._scriptToLoad[this._scriptsFinished];
        if(scriptElement.alwaysReload||false)
            this._removeScriptElement(scriptElement);
        else
            if(this.isScriptLoaded(scriptElement)) {
            this.notifyScriptLoaded();
            return;
        }

        var script=document.createElement("script")
        script.type="text/javascript";
        script.src=scriptElement.src;
        document.getElementsByTagName("head")[0].appendChild(script);
    },

    _removeScriptElement: function(scriptElement) {
        var head=document.getElementsByTagName("head")[0];
        var scripts=head.getElementsByTagName("script");

        for(var tindex=scripts.length-1;tindex>=0;tindex--)
            if(scripts[tindex].src.toLowerCase()==scriptElement.src.toLowerCase()) {
            head.removeChild(scripts[tindex]);
            return;
        }
    },

    _timeOutHandler: function() {
        var scriptElement=this._scriptToLoad[this._scriptsFinished];
        var isLoaded=false;

        Array.forEach(this._scriptToLoad,function(elt) {
            isLoaded=this.isScriptLoaded(elt);
        },this);

        if(!isLoaded)
            this.ErrorHandler();

        this._timer.set_enabled(false);
    },

    ErrorHandler: function() {
        var scriptElement=this._scriptToLoad[this._scriptsFinished];
        this._timer.set_enabled(false);
        if(this._errorHandler)
            this._errorHandler(scriptElement);
    },

    notifyScriptLoaded: function() {
        var scriptElement=this._scriptToLoad[this._scriptsFinished];

        if(!this.isScriptLoaded(scriptElement))
            Array.add(this._scriptLoaded,scriptElement);

        if(this._onScriptLoadHandler) this._onScriptLoadHandler(scriptElement);

        this._scriptsFinished++;

        if(this._scriptsFinished==this._scriptToLoad.length) {
            this._timer.set_enabled(false);
            this._isLoading=false;
            if(this._successHandler) this._successHandler();
        } else {
            setTimeout(Function.createDelegate(this,this._loadCurrentScript),0);
        }
    }
}
Fwk.ScriptLoader.registerClass("Fwk.ScriptLoader");

Fwk.ScriptLoader._staticInstance=new Fwk.ScriptLoader();
Fwk.ScriptLoader=Fwk.ScriptLoader._staticInstance;

//Overrides
Sys.Application.notifyScriptLoaded=function() {
    /// <summary locid="M:J#Sys.Application.notifyScriptLoaded" />
    if(arguments.length!==0) throw Error.parameterCount();
    var sl=Sys._ScriptLoader.getInstance();
    if(sl)
        sl.notifyScriptLoaded();

    if(Fwk.ScriptLoader.get_isLoading())
        Fwk.ScriptLoader.notifyScriptLoaded();  //Fwk
}

if(typeof (Sys)!=='undefined') Sys.Application.notifyScriptLoaded();