///////////////////////////////////////////////////////////////////////////
// Copyright © 2014 - 2018 Esri. All Rights Reserved.
//
// Licensed under the Apache License Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
///////////////////////////////////////////////////////////////////////////

define([
  'dojo/_base/declare',
  'dojo/_base/lang',
  'dojo/_base/array',
  'dojo/Deferred',
  'dojo/DeferredList',
  'jimu/utils',
  'esri/request',
  'esri/geometry/webMercatorUtils',
  'esri/geometry/Polygon',
  'esri/geometry/Polyline',
  'jimu/portalUtils',
  'jimu/tokenUtils',
  'jimu/dijit/Message'
],
  function (declare, lang, array, Deferred, DeferredList, utils, esriRequest,
    webMercatorUtils, Polygon, Polyline, portalUtils, tokenUtils, Message) {
    var Snapshot = declare('Snapshot', null, {
      _portal: null,
      _portalUrl: "",
      _layerArray: [],
      _originMapId: "",
      _originAppId: "",
      _credential: null,

      name: "",
      appendTimeStamp: null,
      baseMap: null,
      tags: "",
      description: "",
      shareWith: null,
      logo: "",
      time: null,

      //options
      //shareWith: {everyone: bool, org: bool, groups: "comma seperated list of group IDs"},
      //  shareWith is expected to follow "share item (as item owner)" props
      //  http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/Share_Item_as_item_owner/02r30000007s000000/
      //folderOptions: folderOptions will be passed to CreateFolder in the _createFolder function
      //  http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/Create_Folder/02r300000074000000/
      //mapTitle: str,
      //mapExtent: {},
      //data: [{
      //  graphics: [<Object>],
      //  renderer: <Object>,
      //  infoTemplate: <Object>,
      //  fields: [],
      //  tags: [],
      //  description: str,
      //  name: str,
      //  visibleOnStartup: bool,
      //  appendTimeStamp: bool,
      //  typeIdField: str,
      //  types: [],
      //  minScale: int,
      //  maxScale: int
      //}]

      constructor: function (appConfig, map) {
        this.map = map;
        this.appConfig = appConfig;
        this._originAppId = appConfig.appId;
        this._originMapId = map.itemId;
        this._mapItemInfo = map.itemInfo;
        this._portalUrl = appConfig.portalUrl;
        this._portal = portalUtils.getPortal(this._portalUrl);
        this._baseUrl = this._portalUrl + 'sharing/rest/';
        this.nls = lang.mixin({}, window.jimuNls.drawBox, window.jimuNls.snapshot);
      },

      createSnapShot: function (options) {
        this.ids = [];
        this.layerArray = [];
        this.time = this._getDateString(Date.now());
        var _name = options.appendTimeStamp && options.name ? options.name + "_" + this.time : options.name;
        this.name = _name || this._mapItemInfo.item.title + "_" + this.time; //if no name is specified in options always append timestamp to avoid duplicate name issues
        this.extent = options.mapExtent || this.map.extent;
        this.logo = options.logo || this.appConfig.logo;
        this.mapName = options.mapTitle || this.name;
        this.shareWith = options.shareWith || { everyone: false, org: false, groups: "" };

        var folderOptions = options.folderOptions;
        //make sure the required ones have a value
        folderOptions.name = options.folderOptions.name || this.name;
        folderOptions.title = options.folderOptions.title || this.name;
        folderOptions.description = options.folderOptions.description || this.name;

        //reverse to preserve inital order as we will push to another array later
        var data = options.data.reverse();

        return this._createSnapshot(folderOptions, data);
      },

      _createSnapshot: function (folderOptions, data) {
        var def = new Deferred();
        this._portal.getUser()
          .then(lang.hitch(this, this._processUser), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._createFolder, folderOptions), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._createItems, data), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._addLayers), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._createMap, this._mapItemInfo), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._processMap), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._shareItems), function (err) { def.reject(err); })
          .then(lang.hitch(this, this._showMessage), function(err) { def.reject(err); })
          .then(function() {
            def.resolve();
          });
        return def;
      },

      _processUser: function (user) {
        var def = new Deferred();
        this.user = user;
        this.groups = user.groups;
        def.resolve();
        return def;
      },

      _createFolder: function (folderOptions) {
        var def = new Deferred();
        var args = {
          url: this._baseUrl + 'content/users/' + this.user.username + '/createFolder',
          content: lang.mixin({
            f: 'json'
          }, folderOptions),
          handleAs: 'json',
          callbackParamName: 'callback'
        };
        if (this._isValidCredential()) {
          args.content.token = this._credential.token;
        }
        esriRequest(args, {
          usePost: true
        }).then(lang.hitch(this, function (response) {
          if (response.success) {
            this.folder = response.folder;
            if (this.folder && this.folder.id) {
              this.ids.push(this.folder.id);
            }
            def.resolve(response.folder);
          } else {
            console.log(response);
            def.reject(response);
          }
        }), lang.hitch(this, function (err) {
          def.reject(err);
        }));
        return def;
      },

      _createItems: function (data) {
        var def = new Deferred();
        var defArray = [];
        array.forEach(data, lang.hitch(this, function (dataItem) {
          if (dataItem.graphics && dataItem.graphics.length > 0) {
            defArray.push(this._createLayerItem(dataItem));
          }
        }));
        var itemList = [];
        var defList = new DeferredList(defArray);
        defList.then(lang.hitch(this, function (defResults) {
          for (var r = 0; r < defResults.length; r++) {
            var featureSet = defResults[r][1];
            itemList.push(featureSet);
          }
          def.resolve(itemList);
        }), lang.hitch(this, function (err) {
          def.reject(err);
        }));
        return def;
      },

      _addLayers: function (items) {
        var def = new Deferred();
        var defArray = [];
        for (var i = 0; i < items.length; i++) {
          defArray.push(this.user.addItem(items[i], this.folder.id));
        }
        var layerList = [];
        var defList = new DeferredList(defArray);
        defList.then(lang.hitch(this, function (defResults) {
          for (var r = 0; r < defResults.length; r++) {
            var featureSet = defResults[r][1];
            if (featureSet.success) {
              layerList.push(featureSet.id);
              this.ids.push(featureSet.id);
            }
          }
          def.resolve(layerList);
        }), lang.hitch(this, function (err) {
          def.reject(err);
        }));
        return def;
      },

      _createMap: function (mapItemInfo, layers) {
        var itemData = mapItemInfo.itemData;
        var title = this.name;
        var baseMapLayers = [];
        for (var i = 0; i < itemData.baseMap.baseMapLayers.length; i++) {
          var bml = itemData.baseMap.baseMapLayers[i];
          baseMapLayers.push({
            "id": bml.id,
            "layerType": bml.layerType,
            "url": bml.url,
            "visibility": bml.visibility,
            "opacity": bml.opacity,
            "title": bml.title,
            "styleUrl": bml.styleUrl,
            "itemId": bml.itemId
          });
        }
        var baseMap = {
          "baseMapLayers": baseMapLayers
        };
        var operationalLayers = [];
        for (var j = 0; j < this.layerArray.length; j++) {
          var l = this.layerArray[j];
          operationalLayers.push({
            id: l.layer.id,
            layerType: "ArcGISFeatureLayer",
            visibility: l.layer.visible,
            opacity: l.layer.opacity,
            title: l.label,
            type: "Feature Collection",
            itemId: layers[j]
          });
        }

        //TODO think through this
        var ext1 = webMercatorUtils.webMercatorToGeographic(this.extent);
        var webMap = {
          title: title,
          type: "Web Map",
          item: title,
          extent: ext1.xmin + "," + ext1.ymin + "," + ext1.xmax + "," + ext1.ymax,
          text: JSON.stringify({
            "operationalLayers": operationalLayers,
            "baseMap": baseMap,
            "spatialReference": this.map.spatialReference,
            "version": mapItemInfo && mapItemInfo.itemData && mapItemInfo.itemData.version ?
              mapItemInfo.itemData.version : "2.4"
          }),
          tags: this.name + "," + this.nls.snapshot_append,
          wabType: "HTML"
        };
        return this.user.addItem(webMap, this.folder.id);
      },

      _processMap: function (r) {
        var def = new Deferred();
        if (r.id) {
          this.ids.push(r.id);
        }
        if (r.success) {
          def.resolve(r.id);
        } else {
          def.reject('fail');
        }
        return def;
      },

      _shareItems: function (mapId) {
        var def = new Deferred();
        var args = {
          url: this._baseUrl + 'content/users/' + this.user.username + '/shareItems',
          content: {
            f: 'json',
            everyone: this.shareWith.everyone,
            org: this.shareWith.org,
            items: this.ids.join(),
            groups: this.shareWith.groups,
            confirmItemControl: this._validateGroupItemControl(this.shareWith.groups)
          },
          handleAs: 'json',
          callbackParamName: 'callback'
        };
        if (this._isValidCredential()) {
          args.content.token = this._credential.token;
        }
        esriRequest(args, {
          usePost: true
        }).then(lang.hitch(this, function (response) {
          if (response.results && response.results.length > 0) {
            def.resolve(this._portalUrl + 'home/webmap/viewer.html?webmap=' + mapId);
          } else {
            def.reject("fail");
          }
        }), lang.hitch(this, function (err) {
          def.reject(err);
        }));
        return def;
      },

      _validateGroupItemControl: function (groupIds) {
        var _groupIds = groupIds.split(',');
        var _groups = this.groups.filter(function (group) {
          var capabilities = group.capabilities || [];
          return _groupIds.indexOf(group.id) > -1 && capabilities.indexOf("updateitemcontrol") > -1;
        });
        return _groups.length > 0;
      },

      _showMessage: function (r) {
        var def = new Deferred();
        if (r === 'fail') {
          new Message({
            message: this.nls.snapshot_failed
          });
          def.reject(r);
        } else {
          new Message({
            message: '<a href="' + r + '" target="_blank">' + this.nls.snapshot_complete + '</a>'
          });
          def.resolve('success');
        }
        return def;
      },

      _getDateString: function (time) {
        var date = new Date(time);
        var _off = date.getTimezoneOffset();
        return utils.fieldFormatter.getFormattedDate(date, {
          dateFormat: 'shortDateShortTime'
        }) + " " + this.nls.utc + (_off < 0 ? "+" + (Math.abs(_off) / 60) : "-" + (_off / 60));
      },

      _checkCredential: function () {
        var isValid = tokenUtils.isValidCredential(this._credential);
        if (!isValid) {
          this._clearCredential();
        }
        return isValid;
      },

      _isValidCredential: function () {
        this._updateCredential();
        return this._checkCredential();
      },

      _updateCredential: function () {
        if (!this._checkCredential()) {
          this._credential = tokenUtils.getPortalCredential(this._portalUrl);
        }
      },

      _clearCredential: function () {
        this._credential = null;
      },

      _createLayerItem: function (dataItem) {
        var def = new Deferred();
        var layerDetailsDefault = {
          description: dataItem.name,
          name: dataItem.name,
          tags: [dataItem.name]
        };
        var t = this._createLayer(dataItem.graphics, lang.mixin({}, layerDetailsDefault, dataItem));
        def.resolve(t);
        return def;
      },

      /* jshint loopfunc:true */
      _createLayer: function (graphics, li) {
        var gl = {
          'point': "esriGeometryPoint",
          'polyline': "esriGeometryPolyline",
          'polygon': "esriGeometryPolygon"
        };
        var nls = this.nls;
        var time = this.time;
        var g = graphics[0];
        var gt = gl[typeof (g.geometry) !== 'undefined' ? g.geometry.type : g.type];
        var symbol = g.symbol ? g.symbol.toJson() : "";
        var features = [];
        var fields = [{
          name: "ObjectID",
          alias: "ObjectID",
          type: "esriFieldTypeOID"
        }, {
          name: nls.snapshot_append,
          alias: nls.snapshot_append,
          type: "esriFieldTypeString"
        }];
        if (li.fields && li.fields.length > 0) {
          array.forEach(li.fields, function(field) {
            fields.push({
              name: field.name,
              alias: field.alias,
              type: field.type,
              domain: field.domain
            });
          });
        }

        //Feature Collections do not support multi-part
        var i = 0;
        array.forEach(graphics, function (g) {
          var _parts;
          switch (gt) {
            case "esriGeometryPolyline":
              _parts = g.geometry.paths;
              break;
            case "esriGeometryPolygon":
              _parts = g.geometry.rings;
              break;
            case "esriGeometryPoint":
              _parts = [g.geometry];
              break;
          }
          var _i = 0;
          var newGeom;
          array.forEach(_parts, function (p) {
            switch (gt) {
              case "esriGeometryPolyline":
                newGeom = new Polyline(p);
                newGeom.spatialReference = g.geometry.spatialReference;
                break;
              case "esriGeometryPolygon":
                newGeom = new Polygon(p);
                newGeom.spatialReference = g.geometry.spatialReference;
                break;
              case "esriGeometryPoint":
                newGeom = p;
                break;
            }
            var f = {
              attributes: {
                ObjectID: i + _i
              },
              geometry: newGeom
            };
            f.attributes[nls.snapshot_append] = time;
            if (li.fields && li.fields.length > 0) {
              array.forEach(li.fields, function (field) {
                f.attributes[field.name] = g.attributes[field.name];
              });
            }
            features.push(f);
            _i += 1;
          });
          i += 1;
        });

        var extent = {
          xmin: this.extent.xmin,
          ymin: this.extent.ymin,
          xmax: this.extent.xmax,
          ymax: this.extent.ymax,
          spatialReference: this.extent.spatialReference
        };

        var renderer = li.renderer && li.renderer.toJson ? li.renderer.toJson() : li.renderer ?
          JSON.stringify(li.renderer) : {
            type: "simple",
            label: '',
            description: '',
            symbol: symbol
          };

        this.layerArray.push({
          layer: {
            id: li.name,
            label: li.name,
            opacity: 1,
            visible: li.visibleOnStartup
          },
          label: li.name
        });
        return {
          title: li.name,
          type: "Feature Collection",
          tags: li.tags,
          description: li.description,
          extent: extent,
          name: li.name,
          text: JSON.stringify({
            layers: [{
              layerDefinition: {
                name: li.name,
                geometryType: gt,
                objectIdField: "ObjectID",
                typeIdField: li.typeIdField,
                types: li.types,
                type: "Feature Layer",
                extent: extent,
                drawingInfo: {
                  renderer: renderer
                },
                fields: fields,
                minScale: li.minScale,
                maxScale: li.maxScale
              },
              popupInfo: li.infoTemplate && li.infoTemplate.info ?
                li.infoTemplate.info : li.infoTemplate ? li.infoTemplate : undefined,
              featureSet: {
                features: features,
                geometryType: gt
              }
            }]
          }),
          f: "json"
        };
      }
    });
    return Snapshot;
  });