define([
  'dojo/_base/declare',
  'dojo/_base/lang',
  'dojo/_base/array',
  'dojo/_base/html',
  'dojo/topic',
  'dojo/Deferred',
  'dojo/on',
  './utils',
  './WidgetManager',
  './shared/AppVersionManager',
  './ConfigLoader',
  './dijit/AGOLLoading'
],
function (declare, lang, array, html, topic, Deferred, on, jimuUtils, WidgetManager,
  AppVersionManager, ConfigLoader, AGOLLoading) {
  var instance = null, clazz;

  clazz = declare(null, {
    urlParams: null,
    appConfig: null,
    configFile: null,
    _configLoaded: false,
    portalSelf: null,

    constructor: function (urlParams) {
      this.urlParams = urlParams || {};
      this.listenBuilderEvents();
      this.versionManager = new AppVersionManager();
      this.widgetManager = WidgetManager.getInstance();
      this.configLoader = ConfigLoader.getInstance(this.urlParams, {
        versionManager: this.versionManager
      });

      if(this.urlParams.mode === 'config' && window.parent.setConfigViewerTopic &&
        lang.isFunction(window.parent.setConfigViewerTopic)){
        window.parent.setConfigViewerTopic(topic);
      }
      if(this.urlParams.mode === 'preview' && window.parent.setPreviewViewerTopic &&
        lang.isFunction(window.parent.setPreviewViewerTopic)){
        window.parent.setPreviewViewerTopic(topic);
      }

      if (!jimuUtils.isMobileUa()) {
        //mobile devices do NOT listen to the 'resize' event
        //avoid to virtual-keyboard appears and then app switches between "Mobile Mode" and "Desktop Mode"
        on(window, 'resize', lang.hitch(this, this._onWindowResize));
      }
      on(window, "orientationchange", lang.hitch(this, this._onOrientationChange));
    },

    listenBuilderEvents: function(){

    },

    loadConfig: function(){
      if(this.urlParams.mode === 'preview' ||
        this.urlParams.mode === 'config'){
        //in preview/config mode, the config is set by the builder.
        return;
      }

      var loading = new AGOLLoading();
      loading.placeAt(window.jimuConfig.layoutId);
      return this.configLoader.loadConfig().then(lang.hitch(this, function(appConfig){
        this.portalSelf = this.configLoader.portalSelf;
        this.appConfig = this._addDefaultValues(appConfig);

        console.timeEnd('Load Config');

        window.appInfo.isRunInMobile = jimuUtils.inMobileSize();

        var _ac = this.getAppConfig();
        loading.destroy();
        topic.publish("appConfigLoaded", _ac);
        return _ac;
      }), lang.hitch(this, function(err){
        loading.destroy();
        console.error(err);
        if(err && err.message && typeof err.message === 'string'){
          this._showErrorMessage(err.message);
        }
      }));
    },

    _showErrorMessage: function(msg){
      html.create('div', {
        'class': 'app-error',
        innerHTML: jimuUtils.sanitizeHTML(msg)
      }, document.body);
    },

    getAppConfig: function () {
      var c;
      if(window.appInfo.isRunInMobile){
        // console.log('Switch to mobile mode.');
        c = lang.clone(this._getMobileConfig(this.appConfig));
        c._originConfig = lang.clone(this.appConfig);
      }else{
        // console.log('Switch to desktop mode.');
        c = lang.clone(this.appConfig);
      }

      c.getConfigElementById = function(id){
        return jimuUtils.getConfigElementById(this, id);
      };

      c.getConfigElementsByName = function(name){
        return jimuUtils.getConfigElementsByName(this, name);
      };

      c.getCleanConfig = function(isForAGOLTemplate){
        if(this._originConfig){
          return getCleanConfig(this._originConfig, isForAGOLTemplate);
        }else{
          return getCleanConfig(this, isForAGOLTemplate);
        }
      };

      c.visitElement = function(cb){
        jimuUtils.visitElement(this, cb);
      };
      return c;
    },

    _onOrientationChange: function() {
      if (this.appConfig) {
        topic.publish("appConfigChanged", this.getAppConfig(), 'layoutChange');
      }
    },
    _onWindowResize: function () {
      var runInMobile = jimuUtils.inMobileSize();
      if(window.appInfo.isRunInMobile === runInMobile){
        return;
      }
      window.appInfo.isRunInMobile = runInMobile;

      if(this.appConfig){
        topic.publish("appConfigChanged", this.getAppConfig(), 'layoutChange');
      }
    },

    _getMobileConfig: function(appConfig) {
      return jimuUtils.mixinAppConfigPosition(appConfig, appConfig.mobileLayout);
    },

    _updateDataSourceForWidget: function(newJson){
      this._deleteDataSourcesFromWidget(newJson);
      this._addDataSourcesForWidget(newJson);
    },

    _deleteDataSourcesFromWidget: function(widgetJson){
      //remove all data sources of this widget
      for(var p in this.appConfig.dataSource.dataSources){
        if(p.startWith('widget~' + widgetJson.id + '~')){
          delete this.appConfig.dataSource.dataSources[p];
        }
      }
    },

    _addDataSourcesForWidget: function(widgetJson){
      array.forEach(widgetJson.provideDataSources, function(ds){
        var dsId = 'widget~' + widgetJson.id + '~' + ds.id;
        ds.id = dsId;
        this.appConfig.dataSource.dataSources[dsId] = ds;
      }, this);

      delete widgetJson.provideDataSources;
    },

    _addIdForWidgets: function (widgetJsons){
      var maxId = 0, i;

      this.getAppConfig().visitElement(function(e){
        if(!e.id){
          return;
        }
        //fix element id
        e.id = e.id.replace(/\//g, '_');

        var li = e.id.lastIndexOf('_');
        if(li > -1){
          i = e.id.substr(li + 1);
          maxId = Math.max(maxId, i);
        }
      });

      array.forEach(widgetJsons, function(e){
        if(!e.id){
          maxId ++;
          if(e.itemId){
            e.id = e.itemId + '_' + maxId;
          }else if(e.uri){
            e.id = e.uri.replace(/\//g, '_') + '_' + maxId;
          }else{
            e.id = ''  + '_' + maxId;
          }
        }
      });
    },
    _handleDataSourceForWidgets: function(oldJson, newJson){
      var newAddedWidgets = array.filter(newJson.widgets, function(nw){
        if(!nw.id){
          return true;
        }else{
          return array.filter(oldJson.widgets, function(ow){return nw.id === ow.id;}).length === 0;
        }
      }, this);
      this._addIdForWidgets(newAddedWidgets);
      array.forEach(newAddedWidgets, function(w){
        this._addDataSourcesForWidget(w);
      }, this);

      var removedWidgets = array.filter(oldJson.widgets, function(ow){
        return array.filter(newJson.widgets, function(nw){return nw.id === ow.id;}).length === 0;
      }, this);
      array.forEach(removedWidgets, function(w){
        this._deleteDataSourcesFromWidget(w);
      }, this);

      array.forEach(newJson.widgets, function(nw){
        array.forEach(oldJson.widgets, function(ow){
          if(nw.id === ow.id && nw.provideDataSources){
            this._updateDataSourceForWidget(nw);
          }
        }, this);
      }, this);
    },

    _handleDataSourceForWidgetsSection: function(oldJson, newJson){
      var newWidgets = newJson.widgets;
      array.forEach(newJson.groups, function(g){
        newWidgets = newWidgets.concat(g.widgets);
      }, this);

      var oldWidgets = oldJson.widgets;
      array.forEach(oldJson.groups, function(g){
        oldWidgets = oldWidgets.concat(g.widgets);
      }, this);

      this._handleDataSourceForWidgets({widgets: oldWidgets}, {widgets: newWidgets});
    },

    _removeWidgetOrGroupFromPoolById: function(appConfig, id){
      array.some(appConfig.widgetPool.widgets, function(widget, i){
        if(widget.id === id){
          appConfig.widgetPool.widgets.splice(i, 1);
          return true;
        }
      });

      array.some(appConfig.widgetPool.groups, function(group, i){
        if(group.id === id){
          appConfig.widgetPool.groups.splice(i, 1);
          return true;
        }
      });
    },

    _onDataSourceChanged: function(_dataSource){
      var newDataSource = jimuUtils.reCreateObject(_dataSource);
      this.appConfig.dataSource = newDataSource;

      topic.publish('appConfigChanged', this.getAppConfig(), 'dataSourceChange', _dataSource);
    },

    _onMapChanged: function(_newJson){
      // transfer obj to another iframe may cause problems on IE8
      var newJson = jimuUtils.reCreateObject(_newJson);

      //remove the options that are relative to map's display when map is changed.
      if(this.appConfig.map.mapOptions){
        jimuUtils.deleteMapOptions(this.appConfig.map.mapOptions);
      }

      this.appConfig.map.mapRefreshInterval = {
        useWebMapRefreshInterval: true
      };

      lang.mixin(this.appConfig.map, newJson);

      this._deleteDataSourcesFromMap();

      this.configLoader.addNeedValues(this.appConfig);

      this.configLoader.loadAndUpgradeAllWidgetsConfig(this.appConfig).then(lang.hitch(this, function(appConfig){
        this.appConfig = appConfig;
        this._addDefaultValues(this.appConfig);
        topic.publish('appConfigChanged', this.getAppConfig(), 'mapChange', newJson);
      }));
    },

    _deleteDataSourcesFromMap: function(){
      array.forEach(Object.keys(this.appConfig.dataSource.dataSources), function(dsId){
        if(dsId.startWith('map')){
          delete this.appConfig.dataSource.dataSources[dsId];
        }
      }, this);
    },

    _genStyles: function(allStyle, currentStyle){
      var styles = [];
      styles.push(currentStyle);
      array.forEach(allStyle, function(_style){
        if(styles.indexOf(_style) < 0){
          styles.push(_style);
        }
      });
      return styles;
    },

    /**************************************
    Keep the following same between themes:
    1. map config excluding map's position
    2. widget pool config excluding pool panel config
    ***************************************/
    _getAppConfigFromTheme: function(theme){
      var def = new Deferred();
      var config, styles = [];
      var currentConfig = this.getAppConfig().getCleanConfig();

      currentConfig.mode = this.urlParams.mode;

      //because we don't allow user config panel for group,
      //and group's panel should be different between differrent theme
      //so, we delete group panel
      array.forEach(currentConfig.widgetPool.groups, function(group){
        delete group.panel;
      }, this);
      //theme has already appConfig object, use it but keep something
      if(theme.appConfig){
        config = lang.clone(theme.appConfig);
        config.map = currentConfig.map;
        config.map.position = theme.appConfig.map.position;
        this._copyPoolToThemePool(currentConfig, config);

        config.links = currentConfig.links;
        config.title = currentConfig.title;
        config.subtitle = currentConfig.subtitle;
        config.logo = currentConfig.logo;
      }else{
        //use layout and style to create a new appConfig, which may contain some place holders
        var layout = theme.getCurrentLayout();
        var style = theme.getCurrentStyle();

        config = lang.clone(currentConfig);
        var layoutConfig = lang.clone(layout.layoutConfig);

        //use onscreen
        config.widgetOnScreen = layoutConfig.widgetOnScreen;

        //add flag
        if(layoutConfig.widgetPool){
          array.forEach(layoutConfig.widgetPool.widgets, function(w){
            w.isPreconfiguredInTheme = true;
          });
          array.forEach(layoutConfig.widgetPool.groups, function(g){
            g.isPreconfiguredInTheme = true;
          });
        }

        //copy pool
        this._copyPoolToThemePool(currentConfig, layoutConfig);
        config.widgetPool = layoutConfig.widgetPool;

        if(layoutConfig.map && layoutConfig.map.position){
          config.map.position = layoutConfig.map.position;
        }
        config.mobileLayout = layoutConfig.mobileLayout;
        config.layoutDefinition = layoutConfig.layoutDefinition;

        //put all styles into the style array, and the current style is the first element
        styles = this._genStyles(array.map(theme.getStyles(), function(style){
          return style.name;
        }), style.name);
        config.theme = {
          name: theme.getName(),
          styles: styles,
          version: theme.getVersion()
        };

        if (this.portalSelf.portalProperties && this.portalSelf.portalProperties.sharedTheme) {
          config.theme.sharedTheme = {
            "useHeader": true,
            "useLogo": true,
            isPortalSupport: true
          };
          config.theme.customStyles = {
            mainBackgroundColor: this.portalSelf.portalProperties.sharedTheme.header.background
          };
        } else {
          config.theme.sharedTheme = {
            "useHeader": false,
            "useLogo": false,
            isPortalSupport: false
          };
          config.theme.customStyles = {
            mainBackgroundColor: ''
          };
        }

        config.titleColor = currentConfig.titleColor;
        config.logoLink = currentConfig.logoLink;
      }

      this.configLoader.addNeedValues(config);
      this.configLoader.loadWidgetsManifest(config).then(lang.hitch(this, function(config){
        return this.configLoader.loadAndUpgradeAllWidgetsConfig(config);
      })).then(lang.hitch(this, function(){
        this._addDefaultValues(config);
        def.resolve(config);
      }));
      return def;
    },

    _copyPoolToThemePool: function(currentAppConfig, themeAppConfig){
      var cpool = currentAppConfig.widgetPool;

      if(!themeAppConfig.widgetPool){
        themeAppConfig.widgetPool = {};
      }
      var tpool = themeAppConfig.widgetPool;

      //widgets/groups defined in theme
      var themePoolWidgets = array.filter(tpool.widgets, function(tw){
        if(tw.isPreconfiguredInTheme){
          return true;
        }

        //widgets that exists in the theme only(added by user, not pre-configured)
        if(!array.some(cpool.widgets, function(cw){
          return cw.name === tw.name;
        })){
          return true;
        }
      });
      var themePoolGroups = array.filter(tpool.groups, function(g){
        return g.isPreconfiguredInTheme;
      });

      //widgets/groups are shared
      var currentPoolWidgets = array.filter(cpool.widgets, function(w){
        return !w.isPreconfiguredInTheme;
      });
      var currentPoolGroups = array.filter(cpool.groups, function(g){
        return !g.isPreconfiguredInTheme;
      });

      currentPoolWidgets = this._getPoolWidgetsWithoutDuplicated(currentPoolWidgets,
          themeAppConfig.widgetOnScreen.widgets || []);

      tpool.widgets = currentPoolWidgets.concat(themePoolWidgets);
      tpool.groups = currentPoolGroups.concat(themePoolGroups);
    },

    _getPoolWidgetsWithoutDuplicated: function(currentPoolWidgets, themeOnScreeWidgets){
      var ret = lang.clone(currentPoolWidgets);
      var currentAppConfig = this.getAppConfig();
      //we don't care groups and theme pool, because all in-panel widgets are not singleton
      for(var i = currentPoolWidgets.length - 1; i >= 0; i --){
        for(var j = themeOnScreeWidgets.length - 1; j >= 0; j --){
          if(!themeOnScreeWidgets[j].uri){
            continue;
          }
          var wname = themeOnScreeWidgets[j].name;
          if(!wname){
            wname = jimuUtils.getWidgetNameFromUri(themeOnScreeWidgets[j].uri);
          }

          var wid = currentPoolWidgets[i].id;
          var wjson = currentAppConfig.getConfigElementById(wid);
          if(currentPoolWidgets[i] && currentPoolWidgets[i].name === wname &&
            wjson.supportMultiInstance === false){
            console.log('Widget', currentPoolWidgets[i].name,
              'is not copied to new theme because this widget exists in new theme.');
            ret.splice(i, 1);
          }
        }
      }
      return ret;
    },


    /**********************************************
    * Add default values
    ************************************************/
    _addDefaultValues: function(config) {
      this._addDefaultPortalUrl(config);
      this._addDefaultStyle(config);
      this._addDefaultMap(config);
      this._addDefaultVisible(config);
      this._addDefaultDataSource(config);
      this._addDefaultSharedTheme(config);

      //preload widgets
      if(typeof config.widgetOnScreen === 'undefined'){
        config.widgetOnScreen = {};
      }

      if(typeof config.widgetPool === 'undefined'){
        config.widgetPool = {};
      }

      this._addDefaultPanelAndPosition(config);
      this._addDefaultOfWidgetGroup(config);
      //if the first widget or first group doesn't have index property, we add it
      if(config.widgetPool.widgets && config.widgetPool.widgets.length > 0 &&
        config.widgetPool.widgets[0].index === undefined ||
        config.widgetPool.groups && config.widgetPool.groups.length > 0 &&
        config.widgetPool.groups[0].index === undefined){
        this._addIndexForWidgetPool(config);
      }
      return config;
    },

    _addDefaultDataSource: function(config){
      if(!config.dataSource){
        config.dataSource = {
          dataSources: {},
          settings: {}
        };
      }else{
        if(!config.dataSource.dataSources){
          config.dataSource.dataSources = {};
        }

        if(!config.dataSource.settings){
          config.dataSource.settings = {};
        }
      }
    },

    _addDefaultPortalUrl: function(config){
      if(typeof config.portalUrl === 'undefined'){
        config.portalUrl = 'http://www.arcgis.com/';
      }
      if(config.portalUrl && config.portalUrl.substr(config.portalUrl.length - 1) !== '/'){
        config.portalUrl += '/';
      }
    },

    _addDefaultStyle: function(config){
      if(config.theme){
        if(!config.theme.styles || config.theme.styles.length === 0){
          config.theme.styles = ['default'];
        }
      }
    },

    _addDefaultMap: function(config){
      config.map.id = 'map';

      if(typeof config.map['3D'] === 'undefined' && typeof config.map['2D'] === 'undefined'){
        config.map['2D'] = true;
      }

      if(typeof config.map.position === 'undefined'){
        config.map.position = {
          left: 0,
          right: 0,
          top: 0,
          bottom: 0
        };
      }

      if(typeof config.map.portalUrl === 'undefined'){
        config.map.portalUrl = config.portalUrl;
      }
    },

    _addDefaultVisible: function(config){
      jimuUtils.visitElement(config, function(e){
        if(e.visible === undefined){
          e.visible = true;
        }
      });
    },

    _addDefaultSharedTheme: function(config){
      if(!config.theme.sharedTheme){
        config.theme.sharedTheme = {
          useHeader: false,
          useLogo: false
        };
      }else{
        if(typeof config.theme.sharedTheme.useHeader === 'undefined'){
          config.theme.sharedTheme.useHeader = false;
        }
        if(typeof config.theme.sharedTheme.useLogo === 'undefined'){
          config.theme.sharedTheme.useLogo = false;
        }
      }
    },

    _addDefaultPanelAndPosition: function(config){
      this._addOnScreenDefaultPanelAndPosition(config);
      this._addPoolDefaultPanelAndPosition(config);
    },

    _addOnScreenDefaultPanelAndPosition: function(config){
      var i, j, screenSectionConfig = config.widgetOnScreen;

      if(!screenSectionConfig){
        return;
      }

      var panelDefaultPositionR =
        screenSectionConfig.panel && screenSectionConfig.panel.positionRelativeTo?
        screenSectionConfig.panel.positionRelativeTo: 'map';

      if(typeof screenSectionConfig.panel === 'undefined' ||
        typeof screenSectionConfig.panel.uri === 'undefined'){
        screenSectionConfig.panel = {
          uri: 'jimu/OnScreenWidgetPanel',
          //positionRelativeTo: 'map',
          position: {
            //move positionRelativeTo to position.relativeTo
            relativeTo: panelDefaultPositionR
          }
        };
      }else if(typeof screenSectionConfig.panel.position === 'undefined'){
        screenSectionConfig.panel.position = {relativeTo: panelDefaultPositionR};
      }else if(typeof screenSectionConfig.panel.position.relativeTo === 'undefined'){
        screenSectionConfig.panel.position.relativeTo = panelDefaultPositionR;
      }

      if(screenSectionConfig.widgets){
        for(i = 0; i < screenSectionConfig.widgets.length; i++){
          if(!screenSectionConfig.widgets[i].position){
            screenSectionConfig.widgets[i].position = {};
          }
          if(!screenSectionConfig.widgets[i].position.relativeTo){
            screenSectionConfig.widgets[i].position.relativeTo =
              screenSectionConfig.widgets[i] && screenSectionConfig.widgets[i].positionRelativeTo?
              screenSectionConfig.widgets[i].positionRelativeTo: 'map';
          }
          if(screenSectionConfig.widgets[i].inPanel === true &&
            !screenSectionConfig.widgets[i].panel){
            screenSectionConfig.widgets[i].panel = lang.clone(screenSectionConfig.panel);
            screenSectionConfig.widgets[i].panel.position = screenSectionConfig.widgets[i].position;
            screenSectionConfig.widgets[i].panel.position.relativeTo =
            screenSectionConfig.widgets[i].position.relativeTo;
          }
        }
      }

      if(screenSectionConfig.groups){
        for(i = 0; i < screenSectionConfig.groups.length; i++){
          if(!screenSectionConfig.groups[i].panel){
            screenSectionConfig.groups[i].panel = screenSectionConfig.panel;
          }

          if(screenSectionConfig.groups[i].panel && !screenSectionConfig.groups[i].panel.position){
            screenSectionConfig.groups[i].panel.position = {};
          }

          if(!screenSectionConfig.groups[i].panel.position.relativeTo){
            screenSectionConfig.groups[i].panel.position.relativeTo =
              screenSectionConfig.groups[i].panel.positionRelativeTo?
              screenSectionConfig.groups[i].panel.positionRelativeTo:'map';
          }

          if(!screenSectionConfig.groups[i].widgets){
            screenSectionConfig.groups[i].widgets = [];
          }
          for(j = 0; j < screenSectionConfig.groups[i].widgets.length; j++){
            screenSectionConfig.groups[i].widgets[j].panel = screenSectionConfig.groups[i].panel;
          }
        }
      }
    },

    _addPoolDefaultPanelAndPosition: function(config){
      var i, j, poolSectionConfig = config.widgetPool;

      if(!poolSectionConfig){
        return;
      }

      var panelDefaultPositionR =
        poolSectionConfig.panel && poolSectionConfig.panel.positionRelativeTo?
        poolSectionConfig.panel.positionRelativeTo: 'map';

      if(typeof poolSectionConfig.panel === 'undefined' ||
        typeof poolSectionConfig.panel.uri === 'undefined'){
        poolSectionConfig.panel = {
          uri: 'jimu/OnScreenWidgetPanel',
          position: {
            relativeTo: panelDefaultPositionR
          }
        };
      }else if(typeof poolSectionConfig.panel.position === 'undefined'){
        poolSectionConfig.panel.position = {relativeTo: panelDefaultPositionR};
      }else if(typeof poolSectionConfig.panel.position.relativeTo === 'undefined'){
        poolSectionConfig.panel.position.relativeTo = panelDefaultPositionR;
      }

      if(poolSectionConfig.groups){
        for(i = 0; i < poolSectionConfig.groups.length; i++){
          if(!poolSectionConfig.groups[i].panel){
            poolSectionConfig.groups[i].panel = poolSectionConfig.panel;
          }else if(!poolSectionConfig.groups[i].panel.position.relativeTo){
            poolSectionConfig.groups[i].panel.position.relativeTo =
              poolSectionConfig.groups[i].panel.positionRelativeTo?
              poolSectionConfig.groups[i].panel.positionRelativeTo: 'map';
          }

          if(!poolSectionConfig.groups[i].widgets){
            poolSectionConfig.groups[i].widgets = [];
          }
          for(j = 0; j < poolSectionConfig.groups[i].widgets.length; j++){
            poolSectionConfig.groups[i].widgets[j].panel = poolSectionConfig.groups[i].panel;
          }
        }
      }

      if(poolSectionConfig.widgets){
        for(i = 0; i < poolSectionConfig.widgets.length; i++){
          if(poolSectionConfig.widgets[i].inPanel === false){
            var defaultWidgetPositionR = poolSectionConfig.widgets[i].positionRelativeTo?
                poolSectionConfig.widgets[i].positionRelativeTo: 'map';
            if(!poolSectionConfig.widgets[i].position){
              poolSectionConfig.widgets[i].position = {
                relativeTo: defaultWidgetPositionR
              };
            }else if(!poolSectionConfig.widgets[i].position.relativeTo){
              poolSectionConfig.widgets[i].position.relativeTo = defaultWidgetPositionR;
            }
          }else if(!poolSectionConfig.widgets[i].panel){
            poolSectionConfig.widgets[i].panel = config.widgetPool.panel;
          }
        }
      }
    },

    _addDefaultOfWidgetGroup: function(config){
      //group/widget labe, icon
      jimuUtils.visitElement(config, lang.hitch(this, function(e, info){
        e.isOnScreen = info.isOnScreen;
        if(e.widgets){
          //it's group
          e.gid = e.id;
          if(e.widgets.length === 1){
            if(!e.label){
              e.label = e.widgets[0].label? e.widgets[0].label: window.apiNls.common.groupLabel;
            }
            if(!e.icon){
              if(e.widgets[0].uri){
                e.icon = this._getDefaultIconFromUri(e.widgets[0].uri);
              }else{
                e.icon = 'jimu.js/images/group_icon.png';
              }
            }
          }else{
            e.icon = e.icon? e.icon: 'jimu.js/images/group_icon.png';
            e.label = e.label? e.label: (window.apiNls.common.groupLabel + ' ' + info.index);
          }
        }else{
          e.gid = info.groupId;
        }
      }));
    },

    _getDefaultIconFromUri: function(uri){
      var segs = uri.split('/');
      segs.pop();
      return segs.join('/') + '/images/icon.png?wab_dv=' + window.deployVersion;
    },

    _addIndexForWidgetPool: function(config){
      //be default, widgets are in front
      var index = 0, i, j;
      if(config.widgetPool.widgets){
        for(i = 0; i < config.widgetPool.widgets.length; i++){
          config.widgetPool.widgets[i].index = index;
          index ++;
        }
      }

      if(config.widgetPool.groups){
        for(i = 0; i < config.widgetPool.groups.length; i++){
          config.widgetPool.groups[i].index = index;
          index ++;
          for(j = 0; j < config.widgetPool.groups[i].widgets.length; j++){
            config.widgetPool.groups[i].widgets[j].index = j;
          }
        }
      }
    }

  });

  clazz.getInstance = function (urlParams) {
    if(instance === null) {
      instance = new clazz(urlParams);
    }else{
      if(urlParams){
        instance.urlParams = urlParams;
        if(instance.configLoader){
          instance.configLoader.urlParams = urlParams;
        }
      }
    }

    window.getAppConfig = lang.hitch(instance, instance.getAppConfig);
    return instance;
  };

  function getCleanConfig(config, isForAGOLTemplate){
    //delete the properties that framework add
    var newConfig = lang.clone(config);
    var properties = jimuUtils.widgetProperties;

    if(typeof isForAGOLTemplate === 'undefined'){
      isForAGOLTemplate = false;
    }
    delete newConfig.mode;
    delete newConfig.configWabVersion;
    jimuUtils.visitElement(newConfig, function(e, info){
      if(e.widgets){
        delete e.isOnScreen;
        delete e.gid;
        if(e.icon === 'jimu.js/images/group_icon.png'){
          delete e.icon;
        }
        delete e.openType;
        if(info.isOnScreen){
          if(e.panel && jimuUtils.isEqual(e.panel, newConfig.widgetOnScreen.panel)){
            delete e.panel;
          }
        }
        return;
      }

      if(e.icon && e.icon === e.folderUrl + 'images/icon.png?wab_dv=' + window.deployVersion){
        delete e.icon;
      }

      delete e.panel;
      delete e.folderUrl;
      delete e.amdFolder;
      delete e.thumbnail;
      delete e.configFile;
      delete e.gid;
      delete e.isOnScreen;
      delete e.isRemote;
      delete e.featureActions;

      properties.forEach(function(p){
        delete e[p];
      });

      if(!isForAGOLTemplate){
        if(e.visible){
          delete e.visible;
        }

        if(e.manifest && e.label === e.manifest.label){
          delete e.label;
        }

        if(e.isDefaultConfig){
          delete e.config;
          delete e.isDefaultConfig;
        }
      }else{
        if(typeof e.openAtStart === 'undefined'){
          e.openAtStart = false;
        }
      }

      delete e.manifest;

      if(e.itemId){
        delete e.uri;//uri will be get from item url
      }
    });
    delete newConfig.rawAppConfig;
    //the _ssl property is added by esriRequest
    delete newConfig._ssl;
    //delete all of the methods
    delete newConfig.getConfigElementById;
    delete newConfig.getConfigElementsByName;
    delete newConfig.processNoUriWidgets;
    delete newConfig.addElementId;
    delete newConfig.getCleanConfig;
    delete newConfig.visitElement;

    delete newConfig.agolConfig;
    delete newConfig._itemData;
    delete newConfig.oldWabVersion;

    delete newConfig.titleColor;

    return newConfig;
  }

  return clazz;
});