define(["dojo/_base/lang",
        "dojo/_base/array",
        "dojo/Deferred",
        "dojo/i18n!app/nls/resources",
        "app/base/etc/utilities",
        "esri/request",
        "esri/IdentityManager"],
function(lang, array, Deferred, i18n, utilities, esriRequest, esriId) {

  var oThisObject = {

    addToken: function(content,options) {
      if (options && options.token) {
        content.token = options.token;
        return;
      }

      // issue #1500
      if (AppContext._platformSelfTKN) {
        content.token = AppContext._platformSelfTKN;
        return;
      }

      var credential = esriId.findCredential(this.getServiceUrl());
      if (credential && credential.token) content.token = credential.token;
    },

    addToServiceDefinition: function(json,options) {
      var url = this.getServiceAdminUrl(options)+"/addToDefinition";
      var content = {f:"json",addToDefinition:JSON.stringify(json)};
      this.addToken(content,options);
      //console.warn("addToDefinition",content.addToDefinition);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    },

    addToLayerDefinition: function(layerId,json,options) {
      var url = this.getServiceAdminUrl(options)+"/"+layerId+"/addToDefinition";
      var content = {f:"json",addToDefinition:JSON.stringify(json)};
      this.addToken(content,options);
      //console.warn("addToDefinition",content);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    },

    canAddToDefinition: function(layer) {
      var ok = false;
      if (layer && layer.type === "Feature Layer") {
        //var hasTypes = (layer.types && layer.types.length > 0);
        ok = true;
        if (ok && AppContext.isPortalForArcGIS()) {
          // Portal (10.5.1) - OID field type must be esriFieldTypeOID
          var oidField = this.findField(layer,layer.objectIdField);
          if (!oidField || oidField.type !== "esriFieldTypeOID") ok = false;
        }
      }
      return ok;
    },

    canUserEditSchema: function() {
      var dsc = AppContext.activeProject.activeProjectDescriptor;
      if (dsc && dsc.projectFeatureServiceItem) {
        var u = AppContext.appUser.getUsername();
        return (u === dsc.projectFeatureServiceItem.owner);
      }
      return false;
    },

    deleteFromLayerDefinition: function(layerId,json,options) {
      var url = this.getServiceAdminUrl(options)+"/"+layerId+"/deleteFromDefinition";
      var content = {f:"json",deleteFromDefinition:JSON.stringify(json)};
      this.addToken(content,options);
      //console.warn("deleteFromDefinition",content);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    },

    deleteLayers: function(layerIds) {
      var json = {layers:[]};
      array.forEach(layerIds,function(id){json.layers.push({id:""+id});});
      var url = this.getServiceAdminUrl()+"/deleteFromDefinition";
      var content = {f:"json",deleteFromDefinition:JSON.stringify(json)};
      this.addToken(content);
      //console.warn("deleteFromDefinition",content);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    },

    findField: function(layer,fieldName,opts) {
      var field = null;
      if (typeof fieldName === "string") {
        fieldName = fieldName.toLowerCase();
      }
      array.some(layer.fields,function(fld){
        if (fld.name.toLowerCase() === fieldName) {
          field = fld;
          return true;
        }
      });
      if (!field && opts && opts.considerStartsWith) {
        array.forEach(layer.fields,function(fld){
          if (fieldName.indexOf(fld.name.toLowerCase()) === 0) {
            if (!field || (fld.name.length > field.name.length)) {
              field = fld;
              //console.log("considerStartsWith",field.name)
            }
          }
        });
      }
      return field;
    },

    getDefaultFieldTypes: function(layer) {
      return ["esriFieldTypeString","esriFieldTypeSmallInteger","esriFieldTypeInteger",
              "esriFieldTypeSingle","esriFieldTypeDouble"];
    },

    getLayerTitle: function(layer) {
      var wmInfo = AppContext.activeProject.activeMap.findWebMapLayer(layer.id);
      if (wmInfo && wmInfo.operationalLayer && wmInfo.operationalLayer.title) {
        return utilities.checkTitle(wmInfo.operationalLayer.title);
      } else {
        return layer.name;
      }
    },

    getServiceAdminUrl: function(options) {
      var url = (options && options.serviceUrl) || this.getServiceUrl();
      url = url.replace("/rest/services/","/rest/admin/services/");
      if (window.AppContext) window.AppContext.addCors(url);
      return url;
    },

    getServiceUrl: function() {
      var dsc = AppContext.activeProject.activeProjectDescriptor;
      return AppContext.checkMixedContent(dsc.projectDesignService.serviceUrl);
    },

    hasSimpleRenderer: function(layer) {
      if (layer && layer.renderer && layer.renderer.declaredClass) {
        var dcls = layer.renderer.declaredClass;
        if (dcls === "esri.renderer.SimpleRenderer") {
          return true;
        }
      } else if (layer && layer.drawingInfo && layer.drawingInfo.renderer &&
        layer.drawingInfo.renderer.type === "simple") {
        return true;
      }
      return false;
    },

    hasSimpleTemplates: function(layer) {
      return (layer && layer.templates && layer.templates.length > 0);
    },

    hasTypes: function(layer) {
      return (layer && layer.typeIdField && layer.types && layer.types.length > 0);
    },

    isIntegerField: function(field) {
      var a = ["esriFieldTypeSmallInteger","esriFieldTypeInteger"];
      if (field && field.type) {
        return (a.indexOf(field.type) !== -1);
      }
      return false;
    },

    isNullableField: function(field) {
      if (field && typeof field.nullable === "boolean") return field.nullable;
      return true;
    },

    isNumericField: function(field) {
      var a = ["esriFieldTypeSmallInteger","esriFieldTypeInteger","esriFieldTypeSingle","esriFieldTypeDouble"];
      if (field && field.type) {
        return (a.indexOf(field.type) !== -1);
      }
      return false;
    },

    isSmallIntegerField: function(field) {
      return (field && field.type === "esriFieldTypeSmallInteger");
    },

    isUniqueValuedOnTypeId: function(layer) {

      // must have types
      // must have a UniqueValueRenderer on the typeIdField
      // every type must have one and only one template

      var oneTemplatePerType = function() {
        var n1 = 0, n2 = 0;
        array.forEach(layer.types,function(t){
          n1++;
          if (t.templates && t.templates.length === 1) {
            n2++;
          }
        });
        return (n1 > 0 && n1 === n2);
      };

      var rnd, hasTypes = this.hasTypes(layer);
      if (hasTypes && layer.renderer && layer.renderer.declaredClass) {
        var dcls = layer.renderer.declaredClass;
        if (dcls === "esri.renderer.UniqueValueRenderer") {
          rnd = layer.renderer;
          if ((typeof rnd.attributeField === "string" && rnd.attributeField.length > 0) &&
              (typeof rnd.attributeField2 !== "string" || rnd.attributeField2.length === 0) &&
              (typeof rnd.attributeField3 !== "string" || rnd.attributeField3.length === 0)) {
            if (layer.typeIdField === rnd.attributeField) {
              //return true;
              if (oneTemplatePerType()) return true;
            }
          }
        }
      } else if (hasTypes && layer.drawingInfo && layer.drawingInfo.renderer) {
        if (layer.drawingInfo.renderer.type === "uniqueValue") {
          rnd = layer.drawingInfo.renderer;
          if ((typeof rnd.field1 === "string" && rnd.field1.length > 0) &&
              (typeof rnd.field2 !== "string" || rnd.field2.length === 0) &&
              (typeof rnd.field3 !== "string" || rnd.field3.length === 0)) {
            if (layer.typeIdField === rnd.field1) {
              //return true;
              if (oneTemplatePerType()) return true;
            }
          }
        }
      }
      return false;
    },

    renameLayer: function(layerId,name) {
      var json = {name:name};
      return this.updateLayerDefinition(layerId,json);
    },

    updateLayerDefinition: function(layerId,json,options) {
      var url = this.getServiceAdminUrl(options)+"/"+layerId+"/updateDefinition";
      var content = {f:"json",updateDefinition:JSON.stringify(json)};
      this.addToken(content,options);
      //console.warn("updateDefinition",content);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    },

    updateServiceDefinition: function(serviceUrl,json,options) {
      var url = this.getServiceAdminUrl({serviceUrl:serviceUrl})+"/updateDefinition";
      var content = {f:"json",updateDefinition:JSON.stringify(json)};
      this.addToken(content,options);
      //console.warn("updateDefinition",content);
      return esriRequest({url:url,content:content,handleAs:"json",timeout:120000},{usePost:true});
    }

  };

  return oThisObject;
});