define(["dojo/_base/declare",
        "dojo/_base/lang",
        "dojo/_base/array",
        "dojo/json",
        "dojo/promise/all",
        "dojo/Deferred",
        "app/base/etc/utilities",
        "app/ui/util/MessageDialog",
        "app/base/portal/PortalUtil",
        "app/base/project/DesignService",
				"app/base/project/policyActionUtil",
        "app/base/project/ProjectCreator",
        "app/base/project/ProjectUtil",
        "app/base/project/ScenarioDescriptor",
        "dojo/i18n!app/nls/resources"],
function(declare, lang, array, djJson, all, Deferred, utilities,
		     MessageDialog, PortalUtil, DesignService, policyActionUtil, ProjectCreator,
		     ProjectUtil, ScenarioDescriptor, i18n) {

  var oThisClass = declare("app.base.project.ProjectLoader", null, {

  	i18n: i18n,

    constructor: function(args) {
      lang.mixin(this,args);
    },

    loadProject: function(projectGroupId,bPopupValidationErrors) {
    	AppContext.logger.debug("ProjectLoader.loadingProject:",projectGroupId);
    	var deferred = new Deferred();
    	var projectUtil = new ProjectUtil();
    	var projectCreator = new ProjectCreator();
    	projectUtil.readProjectDescriptor(projectGroupId).then(
    		lang.hitch(this,function(projectDescriptor){
        	this._validateProject(projectDescriptor).then(
        		lang.hitch(this,function(){
        			if (projectDescriptor.hasValidationErrors()) {
        				deferred.resolve(projectDescriptor);
        				this._showValidationErrors(projectDescriptor,bPopupValidationErrors);
        			} else {
          			deferred.progress(this.i18n.project.working.openingMap);
              	projectUtil.ensureProjectFolder(projectDescriptor).then(
              		lang.hitch(this,function(){
              			projectCreator.ensureUserWebMap(projectDescriptor).then(
                  		lang.hitch(this,function(){
                  			this._processUserWebMap(projectDescriptor).then(
                      		lang.hitch(this,function(){
                      			deferred.resolve(projectDescriptor);
                      		}),function(error5){deferred.reject(error5);}
                        );
                  		}),function(error4){deferred.reject(error4);}
                    );
              		}),function(error3){deferred.reject(error3);}
                );
        			}
        		}),
        		function(error2){deferred.reject(error2);},
        		function(update2){deferred.progress(update2);}
          );
    		}),function(error){deferred.reject(error);}
      );
    	return deferred;
    },

    _loadFirstScenario: function(projectDescriptor) {
    	var deferred = new Deferred();
    	var projectUtil = new ProjectUtil();
    	projectUtil.findFirstScenario(projectDescriptor.projectGroup.id).then(
    		lang.hitch(this,function(item){
        	if (item && item.id) {
        		var scenarioDescriptor = new ScenarioDescriptor();
        		scenarioDescriptor.scenarioItem = item;
           	projectDescriptor.autoLoadedScenarios = {
          		activeScenarioDescriptor: scenarioDescriptor,
          		openScenarioDescriptors: [scenarioDescriptor]
          	};
        	}
    			deferred.resolve(projectDescriptor);
    		}),function(error){
        	console.error(error);
        	deferred.resolve(projectDescriptor);
    		}
      );
    	return deferred;
    },

    _loadScenarios: function(projectDescriptor,activeScenarioId,openScenarioIds) {
    	var deferred = new Deferred();
    	var deferreds = [];
    	var portalUtil = new PortalUtil();
    	array.forEach(openScenarioIds,function(id){
    		deferreds.push(portalUtil.readItem(id));
    	});
      var promises = new all(deferreds);
      promises.then(
        lang.hitch(this,function(results) {
        	var activeScenarioDescriptor = null;
        	var openScenarioDescriptors = [];
        	array.forEach(results,function(item){
          	if (item && item.id) {
          		var scenarioDescriptor = new ScenarioDescriptor();
          		scenarioDescriptor.scenarioItem = item;
          		openScenarioDescriptors.push(scenarioDescriptor);
          		if (activeScenarioId === item.id) {
          			activeScenarioDescriptor = scenarioDescriptor;
          		}
          	}
        	});
        	if (openScenarioDescriptors.length > 0) {
        		if (activeScenarioDescriptor == null) {
        			activeScenarioDescriptor = openScenarioDescriptors[0];
        		}
           	projectDescriptor.autoLoadedScenarios = {
          		activeScenarioDescriptor: activeScenarioDescriptor,
          		openScenarioDescriptors: openScenarioDescriptors
          	};
           	deferred.resolve(projectDescriptor);
        	} else {
       			this._loadFirstScenario(projectDescriptor).then(
          		lang.hitch(this,function(){
          			deferred.resolve(projectDescriptor);
          		}),function(error2){deferred.reject(error2);}
            );
        	}
        }),function(error){
        	console.error(error);
        	deferred.resolve(projectDescriptor);
        }
      );
    	return deferred;
    },

    _processUserWebMap: function(projectDescriptor) {
    	var deferred = new Deferred();
    	var loadFirstScenario = true;
    	var data = null, xtn = null, item = projectDescriptor.userWebMapItem;
    	if (item && item.xtnItemData) data = item.xtnItemData;
    	if (data && data.extensionForGeodesign) xtn = data.extensionForGeodesign;
    	if (xtn) {
    		if (xtn.activeProjectId === projectDescriptor.projectGroup.id) {
    			var activeScenarioId = xtn.activeScenarioId;
    			var openScenarioIds = xtn.openScenarioIds;
    			if (openScenarioIds && openScenarioIds.length > 0) {
    				loadFirstScenario = false;
      			this._loadScenarios(projectDescriptor,activeScenarioId,openScenarioIds).then(
          		lang.hitch(this,function(){
          			deferred.resolve(projectDescriptor);
          		}),function(error2){deferred.reject(error2);}
            );
    			}
    		}
    	}
    	if (loadFirstScenario) {
  			this._loadFirstScenario(projectDescriptor).then(
      		lang.hitch(this,function(){
      			deferred.resolve(projectDescriptor);
      		}),function(error){deferred.reject(error);}
        );
    	}
    	return deferred;
    },

    _showValidationErrors: function(projectDescriptor,bPopup) {
    	var errors = projectDescriptor.validationErrors;
			if (bPopup) {
		  	var sTitle = this.i18n.project.validation.invalidProject;
		  	var sSubTitle = projectDescriptor.projectGroup.title;
	    	var md = new MessageDialog({"status": "danger"});
	    	md.showMessages(sTitle,sSubTitle,errors);
			} else {
				AppContext.logger.warn("ProjectValidationErrors",errors);
			}
    },

    _validateProject: function(projectDescriptor) {
    	var deferred = new Deferred();
    	projectDescriptor.validationErrors = null;
    	var errors = [];
      if (!projectDescriptor.projectWebMapItem) {
      	errors.push(this.i18n.project.validation.couldNotLocateProjectWebMap);
      }
      if (!projectDescriptor.projectFeatureServiceItem) {
      	errors.push(this.i18n.project.validation.couldNotLocateProjectFeatureService);
      }
      if (errors.length > 0) {
      	projectDescriptor.validationErrors = errors;
      	deferred.resolve(projectDescriptor);
      } else {
      	var prg = this.i18n.project.working.validatingFeatureService;
        setTimeout(function(){deferred.progress(prg);},1);
        var bLoadServiceRestLayers = false;
      	var url = projectDescriptor.projectFeatureServiceItem.url;
        var ds = new DesignService();

        ds.loadAndValidate(url,bLoadServiceRestLayers).then(function(response) {
					projectDescriptor.projectDesignService = ds;
					if ((ds.validationErrors) && (ds.validationErrors.length > 0)) {
						projectDescriptor.validationErrors = ds.validationErrors;
					}
					if (ds.policyActionTable) {
						return policyActionUtil.readActions(ds).then(function(policyActions){
							projectDescriptor.policyActions = policyActions;
							if (policyActions) document.body.classList.add("g-policy-actions-on");
							else document.body.classList.remove("g-policy-actions-on");
						});
					} else {
						document.body.classList.remove("g-policy-actions-on")
					}
				}).then(function() {
					deferred.resolve(projectDescriptor);
				}).otherwise(function(ex) {
					deferred.reject(ex);
				});

      }
      return deferred;
    }

  });

  return oThisClass;
});