define(["dojo/_base/declare",
  "dojo/_base/lang",
  "dojo/_base/array",
  "dojo/Deferred",
  "dojo/aspect",
  "dojo/i18n!app/nls/resources",
  "dojo/topic",
  "app/base/context/app-topics",
  "app/base/etc/geo-utilities",
  "app/base/project/policyActionUtil",
  "app/v4/CommonTools",
  "app/v4/scene-type-util",
  "app/v4/v4-extrusion-util",
  "app/v4/v4-popup-util",
  "app/v4/v4-search-util",
  "app/v4/Slides",
  "esri/IdentityManager",
  "esri/geometry/Extent",
  "esri/SpatialReference",
  "esri4/identity/IdentityManager",
  "esri4/core/has",
  "esri4/core/watchUtils",
  "esri4/WebScene",
  "esri4/views/SceneView",
  "esri4/layers/Layer",
  "esri4/geometry/Extent",
  "esri4/geometry/SpatialReference",
  "esri4/widgets/Legend",
  "esri4/config",
  "esri4/identity/ServerInfo"],
function (declare, lang, array, Deferred, aspect, i18n, topic, appTopics, geoUtil, policyActionUtil,
  CommonTools, sceneTypeUtil, extrusionUtil, popupUtil, searchUtil, bookmarks3DUtil,
  esri3id, V3Extent, V3SpatialReference, esri4id, esri4has, watchUtils, WebScene,
  SceneView, Layer, Extent, SpatialReference, Legend, esri4Config, ServerInfo) {

	var oThisClass = declare(null, {

    extrusionUtil: extrusionUtil,
    popupUtil: popupUtil,
    watchUtils: watchUtils,
    _portalUrlWasConfigured: false,

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

    addOpLayer: function(webScene,sceneView,item,autoSave,v3Layer) {
      var self = this, lid = null, dfd = new Deferred();
      if (!webScene) {
        dfd.resolve();
        return dfd;
      } else if (v3Layer) {
        var info = sceneTypeUtil.getV3LayerInfo(v3Layer);
        if (info.sceneSupportsLayer) {
          lid = v3Layer.id;
        } else {
          dfd.resolve();
          return dfd;
        }
      } else {
        lid = geoUtil.generateRandomId();
      }

      Layer.fromPortalItem({
        portalItem: {id: item.id}
      }).then(function(layer){
        if (typeof lid === "string" && lid.length > 0) {
          layer.id = lid;
        }
        return layer.load();
      }).then(function(layer){
        //console.warn("addOpLayer",layer);
        var opl = {
          id: layer.id,
          itemId: item.id,
          layerType: layer.operationalLayerType,
          title: layer.title,
          visibility: layer.visible,
          opacity: layer.opacity,
          url: layer.url // not necessarily correct at this point
        };

        var srMismatch = false, srMismatchMsg = i18n.scene.srMismatch;
        if (sceneTypeUtil.isOpLayer3D(opl)) {
          if (sceneView.spatialReference.isWebMercator || sceneView.spatialReference.isWGS84) {
            if (!layer.spatialReference ||
               (!layer.spatialReference.isWebMercator && !layer.spatialReference.isWGS84)) {
              srMismatch = true;
            }
          } else {
            if (!layer.spatialReference ||
                !sceneView.spatialReference.equals(layer.spatialReference)) {
              srMismatch = true;
              srMismatchMsg = "Spatial reference mismatch."; // TODO i18n
            }
          }
        }
        if (srMismatch) {
          dfd.reject(new Error(srMismatchMsg));
          return;
        }
        if (sceneTypeUtil.isOpLayer3D(opl)) {
          popupUtil.checkPopup(layer);
        }

        var tp = {webSceneLayer:layer,sceneOpLayer:opl};
        // TODO index? add(layers,index?)
        webScene.add(layer);
        if (!v3Layer && sceneTypeUtil.isOpLayer3D(opl)) {
          topic.publish(appTopics.SceneDataAdded3D,tp);
        }
        if (autoSave) {
          // TODO may be too late to auto-save?
          self.autoSave();
        }
        dfd.resolve(layer);
      })["catch"](function(err){
        console.warn("Error adding operational data",item);
        console.error(err);
        dfd.reject(err);
      });
      return dfd;
    },

    asV3Extent: function(v4Extent) {
      if (!v4Extent) return null;
      var ext = v4Extent;
      var sr = new V3SpatialReference(ext.spatialReference.wkid);
      return new V3Extent(ext.xmin,ext.ymin,ext.xmax,ext.ymax,sr);
    },

    asV4Extent: function(v3Extent) {
      if (!v3Extent) return null;
      var ext = v3Extent;
      var sr = new SpatialReference(ext.spatialReference.wkid);
      return new Extent(ext.xmin,ext.ymin,ext.xmax,ext.ymax,sr);
    },

    autoSave: function() {
      try {
        AppContext.activeProject.activeMap.autoSave({}).then(
          function(){},
          function(errsv){
            console.warn("Error auto-saving WebMap");
            console.warn(errsv);
          }
        );
      } catch(ex) {
        console.warn("Error auto-saving WebMap");
        console.warn(ex);
      }
    },

    _checkSupport: function() {
      var isOld = (esri4has("ie") && esri4has("ie") < 11) || (esri4has("safari") && esri4has("safari") < 9);
      var isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent);
      var hasWebGL = esri4has("esri-webgl");
      if (!hasWebGL || isMobile || isOld) {
        if(window.AppContext) window.AppContext.supports3D = false;
      }
      //console.warn("V4Helper.hasWebGL",hasWebGL,"isOld",isOld,"isMobile",isMobile);
    },

    configPortalUrl: function() {
      try {
        if (this._portalUrlWasConfigured) return;
        var portalUrl = AppContext.appConfig.startupPortalUrl;
        if (portalUrl.indexOf("www.arcgis.com") === -1) {
          esri4Config.portalUrl = portalUrl;
          //console.warn("V4Helper::configPortalUrl",esri4Config.portalUrl);
        }
        // TODO on-premise portals have issues with the tokenServiceUrl - the app context name is dropped
        // no longer required, handled in marshallV3Credentials
        /*
        if (portalUrl.indexOf(".arcgis.com") === -1) {
          var serverInfo = new ServerInfo();
          serverInfo.server = portalUrl;
          serverInfo.hasPortal = true;
          serverInfo.tokenServiceUrl = portalUrl+"/sharing/rest/generateToken";
          if (portalUrl.indexOf("http://") === 0) {
            serverInfo.tokenServiceUrl = "https:"+serverInfo.tokenServiceUrl.substring("5");
          }
          esri4id.registerServers([serverInfo]);
        }
        */
        this._portalUrlWasConfigured = true;
      } catch(ex) {
        console.warn("Error V4Helper::configPortalUrl");
        console.warn(ex);
      }
    },

    getV3Extent: function(sceneView) {
      if (sceneView) return this.asV3Extent(sceneView.extent);
      return null;
    },

    goToV3Extent: function(sceneView,v3Extent,options) {
      if (sceneView && v3Extent) {
        var ext = this.asV4Extent(v3Extent);
        var target = {
          target: ext,
          heading: 0,
          tilt: 0
        };
        return sceneView.goTo(target,options);
      } else {
        var dfd = new Deferred();
        dfd.resolve(false);
        return dfd;
      }
    },

    marshallV3Credentials: function() {
      // TODO oAuthInfos?

      var serverInfos = [];
      array.forEach(esri3id.serverInfos,function(v3Info){
        var serverInfo = new ServerInfo();
        serverInfo.server = v3Info.server;
        serverInfo.hasPortal = v3Info.hasPortal;
        serverInfo.tokenServiceUrl = v3Info.tokenServiceUrl;
        if (serverInfo.tokenServiceUrl && serverInfo.tokenServiceUrl.indexOf("http://") === 0) {
          serverInfo.tokenServiceUrl = "https:"+serverInfo.tokenServiceUrl.substring("5");
        }
        serverInfos.push(serverInfo);
      });
      if (serverInfos.length > 0) esri4id.registerServers(serverInfos);

      array.forEach(esri3id.credentials,function(credential){
        var info = {
          expires: credential.expires,
          server: credential.server,
          ssl: credential.ssl,
          token: credential.token,
          userId: credential.userId
        };
        esri4id.registerToken(info);
      });
      //console.warn("esri4id",esri4id);
    },

    newCommonTools: function(sceneView, position) {
      var widget = new CommonTools({
        view: sceneView
      });
      widget.startup();
      if (position) {
        sceneView.ui.add(widget, position);
      }
      return widget;
    },

    newLegend: function(sceneView,node) {
      var legend = new Legend({
        view: sceneView
      },node);

      var policyActions = policyActionUtil.getPolicyActions();
      if (policyActions) {
        aspect.around(legend.viewModel,"_constructLegendElements",function(originalFunction){
          return function(activeLayerInfo){
            try {
              var k, element, elementInfo, infos2, cache;
              if (policyActionUtil.isPolicyActionLayer(activeLayerInfo.layer)) {
                cache = (AppContext.paInUseCache && AppContext.paInUseCache[activeLayerInfo.layer.id]) || {};
                activeLayerInfo.buildLegendElementsForRenderer(activeLayerInfo.layer.renderer).then(
                  function() {
                    if (activeLayerInfo.legendElements && activeLayerInfo.legendElements.length === 1) {
                      element = activeLayerInfo.legendElements[0];
                      if (element && element.infos) {
                        infos2 = [];
                        for (k=0;k<element.infos.length;k++) {
                          elementInfo = element.infos[k];
                          if (cache[elementInfo.value]) infos2.push(elementInfo);
                        }
                        element.infos = infos2;
                        activeLayerInfo.notifyChange("ready");
                      }
                    }
                  },
                  function(ex) {
                    console.error(ex)
                  }
                )
              } else {
                originalFunction.call(this,activeLayerInfo);
              }
            } catch(ex) {
              console.error("V4Helper::_constructLegendElements error",ex);
            }
          };
        });
      }

      return legend;
    },

    newSceneView: function(webScene,container) {
      var view = new SceneView({
        map: webScene,
        container: container
      });
      view.popup.autoAlignmentEnabled = true;
      view.popup.dockOptions = {
        buttonEnabled: false,
        breakpoint: false
      };
      var isRTL = window.document.dir === 'rtl';
      if (isRTL) {
        view.ui.move("zoom","top-right");
        view.ui.move("compass","top-right");
      }
      return view;
    },

    newWebScene: function(wsJson) {
      return new WebScene({
        resourceInfo: wsJson
      });
    },

    updateV3Extent: function(sceneView) {
      var v3map = AppContext ? AppContext.map: null;
      var v3ext = this.getV3Extent(sceneView);
      if (v3map && v3ext) {
        return v3map.setExtent(v3ext,false);
      } else {
        var dfd = new Deferred();
        dfd.resolve(false);
        return dfd;
      }
    },

    zoomToOpLayer: function(webScene,sceneView,sceneOpLayer) {
      try {
        if (webScene && sceneView) {
          var self = this;
          var layer = webScene.findLayerById(sceneOpLayer.id);
          if (layer && layer.fullExtent && sceneView.spatialReference) {
            var v3ext = this.asV3Extent(layer.fullExtent);
            geoUtil.projectExtent(v3ext,sceneView.spatialReference.wkid
            ).then(function(v3prj) {
              var v4ext = self.asV4Extent(v3prj);
              sceneView.goTo({
                target: v4ext,
              });
            }).otherwise(function(err){
              console.warn("Error while projecting extent");
              console.warn(err);
            });
          }
        }
      } catch(ex) {
        console.warn("Error zooming to WebScene layer");
        console.warn(ex);
      }
    }

	});

	return oThisClass;
});