describe("geo.map", function() {

  describe('cdb.geo.MapLayer', function() {
    var layer;

    beforeEach(function() {
      layer  = new cdb.geo.MapLayer();
      layer.url = function() {return true};
      layer.sync = function() {return true};
    });
  });

  describe('GMapsBaseLayer', function() {
    it("should be type GMapsBase", function() {
      var layer = new cdb.geo.GMapsBaseLayer();
      expect(layer.get('type')).toEqual("GMapsBase");
    });
  });

  describe('TileLayer', function() {
    it("should be type tiled", function() {
      var layer = new cdb.geo.TileLayer();
      expect(layer.get('type')).toEqual("Tiled");
    });
  });

  describe('CartoDBLayer', function() {
    it("should be type CartoDB", function() {
      var layer = new cdb.geo.CartoDBLayer();
      expect(layer.get('type')).toEqual("CartoDB");
    });
  });

  describe('CartoDBGroupLayer', function() {
    it("should be type layergroup", function() {
      var layer = new cdb.geo.CartoDBGroupLayer();
      expect(layer.get('type')).toEqual("layergroup");
    });
  });

  describe("Layers", function() {
    var layers;

    beforeEach(function() {
      layers = new cdb.geo.Layers();
    });

    it("should compare equal layers correctly", function() {
      var layer1 = new cdb.geo.PlainLayer({ name: 'Positron' });
      var layer2 = new cdb.geo.PlainLayer({});
      var layer3 = new cdb.geo.PlainLayer({});
      var layer4 = new cdb.geo.PlainLayer({});

      expect(layer3.isEqual(layer4)).toBeTruthy();
      expect(layer1.isEqual(layer2)).not.toBeTruthy();

      layers.add(layer4);
      layers.add(layer3);

      expect(layer3.isEqual(layer4)).toBeTruthy();
    })

    it("should compare TileLayers", function() {
      var layer1 = new cdb.geo.TileLayer({ urlTemplate: 'urlTemplate', name: 'layer1', other: 'something' });
      var layer2 = new cdb.geo.TileLayer({ urlTemplate: 'urlTemplate', name: 'layer2', other: 'else' });

      expect(layer1.isEqual(layer2)).toBeFalsy();

      layer2.set({ name: 'layer1' }, { silent: true});

      expect(layer1.isEqual(layer2)).toBeTruthy();
    })

    it("should re-assign order when new layers are added to the collection", function() {
      var baseLayer = new cdb.geo.TileLayer();
      var layer1 = new cdb.geo.CartoDBLayer();
      var layer2 = new cdb.geo.CartoDBLayer();
      var layer3 = new cdb.geo.CartoDBLayer();

      // Sets the order to 0
      layers.add(baseLayer);

      expect(baseLayer.get('order')).toEqual(0);

      // Sets the order to 1
      layers.add(layer1);
      layers.add(layer2);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(1);
      expect(layer2.get('order')).toEqual(2);

      // Sets the order to 1 and re-orders the rest of the layers
      layers.add(layer3, { at: 1});

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(2);
      expect(layer2.get('order')).toEqual(3);
      expect(layer3.get('order')).toEqual(1);

      var torqueLayer = new cdb.geo.TorqueLayer({});

      // Torque layer should be at the top
      layers.add(torqueLayer);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(2);
      expect(layer2.get('order')).toEqual(3);
      expect(layer3.get('order')).toEqual(1);
      expect(torqueLayer.get('order')).toEqual(4);

      var tiledLayer = new cdb.geo.TileLayer({});

      // Tiled layer should be at the top
      layers.add(tiledLayer);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(2);
      expect(layer2.get('order')).toEqual(3);
      expect(layer3.get('order')).toEqual(1);
      expect(torqueLayer.get('order')).toEqual(4);
      expect(tiledLayer.get('order')).toEqual(5);

      var layer4 = new cdb.geo.CartoDBLayer({});
      layers.add(layer4);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(2);
      expect(layer2.get('order')).toEqual(3);
      expect(layer3.get('order')).toEqual(1);
      expect(layer4.get('order')).toEqual(4);
      expect(torqueLayer.get('order')).toEqual(5);
      expect(tiledLayer.get('order')).toEqual(6);
    });

    it("should re-assign order when new layers are removed from the collection", function() {
      var baseLayer = new cdb.geo.TileLayer();
      var layer1 = new cdb.geo.CartoDBLayer();
      var layer2 = new cdb.geo.CartoDBLayer();
      var torqueLayer = new cdb.geo.TorqueLayer({});
      var labelsLayer = new cdb.geo.TileLayer();

      // Sets the order to 0
      layers.add(baseLayer);
      layers.add(layer1);
      layers.add(layer2);
      layers.add(torqueLayer);
      layers.add(labelsLayer);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer1.get('order')).toEqual(1);
      expect(layer2.get('order')).toEqual(2);
      expect(torqueLayer.get('order')).toEqual(3);
      expect(labelsLayer.get('order')).toEqual(4);

      layers.remove(layer1);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer2.get('order')).toEqual(1);
      expect(torqueLayer.get('order')).toEqual(2);
      expect(labelsLayer.get('order')).toEqual(3);

      layers.remove(torqueLayer);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer2.get('order')).toEqual(1);
      expect(labelsLayer.get('order')).toEqual(2);

      layers.remove(labelsLayer);

      expect(baseLayer.get('order')).toEqual(0);
      expect(layer2.get('order')).toEqual(1);
    });
  });

  describe("Map", function() {
    var map;

    beforeEach(function() {
      map = new cdb.geo.Map();
    });

    it("should raise only one change event on setBounds", function() {
      var c = 0;
      map.bind('change:view_bounds_ne', function() {
        c++;
      });
      map.setBounds([[1,2],[1,2]]);
      expect(c).toEqual(1);
    });

    it("should not change center or zoom when the bounds are not ok", function() {
      var c = 0;
      map.bind('change:center', function() {
        c++;
      });
      map.setBounds([[1,2],[1,2]]);
      expect(c).toEqual(0);
    });

    it("should not change bounds when map size is 0", function() {
      map.set('zoom', 10);
      var bounds = [[43.100982876188546, 35.419921875], [60.23981116999893, 69.345703125]]
      map.fitBounds(bounds, {x: 0, y: 0});
      expect(map.get('zoom')).toEqual(10);
    });

    it("should adjust zoom to layer", function() {
      expect(map.get('maxZoom')).toEqual(40);
      expect(map.get('minZoom')).toEqual(0);

      var layer = new cdb.geo.PlainLayer({ minZoom: 5, maxZoom: 20 });
      map.layers.reset(layer);
      expect(map.get('maxZoom')).toEqual(20);
      expect(map.get('minZoom')).toEqual(5);

      var layer = new cdb.geo.PlainLayer({ minZoom: "7", maxZoom: "31" });
      map.layers.reset(layer);
      expect(map.get('maxZoom')).toEqual(31);
      expect(map.get('minZoom')).toEqual(7);
    });

    it("shouldn't set a NaN zoom", function() {
      var layer = new cdb.geo.PlainLayer({ minZoom: NaN, maxZoom: NaN });
      map.layers.reset(layer);
      expect(map.get('maxZoom')).toEqual(40);
      expect(map.get('minZoom')).toEqual(0);
    });

    it('should update the attributions of the map when layers are reset/added/removed', function() {

      map = new cdb.geo.Map();
      var DEFAULT_CARTO_ATTRIBUTION = '© <a href="https://carto.com/attributions" target="_blank">CARTO</a>';

      // Map has the default CARTO attribution
      expect(map.get('attribution')).toEqual([
        cdb.core.sanitize.html("© <a href='https://carto.com/attributions' target='_blank'>CARTO</a>")
      ]);

      var layer1 = new cdb.geo.CartoDBLayer({ attribution: 'attribution1' });
      var layer2 = new cdb.geo.CartoDBLayer({ attribution: 'attribution1' });
      var layer3 = new cdb.geo.CartoDBLayer({ attribution: 'wadus' });
      var layer4 = new cdb.geo.CartoDBLayer({ attribution: '' });

      map.layers.reset([ layer1, layer2, layer3, layer4 ]);

      // Attributions have been updated removing duplicated and empty attributions
      expect(map.get('attribution')).toEqual([
        "attribution1",
        "wadus",
        DEFAULT_CARTO_ATTRIBUTION
      ]);

      var layer = new cdb.geo.CartoDBLayer({ attribution: 'attribution2' });

      map.layers.add(layer);

      // The attribution of the new layer has been appended before the default CARTO attribution
      expect(map.get('attribution')).toEqual([
        "attribution1",
        "wadus",
        "attribution2",
        DEFAULT_CARTO_ATTRIBUTION
      ]);

      layer.set('attribution', 'new attribution');

      // The attribution of the layer has been updated in the map
      expect(map.get('attribution')).toEqual([
        "attribution1",
        "wadus",
        "new attribution",
        DEFAULT_CARTO_ATTRIBUTION
      ]);

      map.layers.remove(layer);

      expect(map.get('attribution')).toEqual([
        "attribution1",
        "wadus",
        DEFAULT_CARTO_ATTRIBUTION
      ]);

      // Addind a layer with the default attribution
      var layer = new cdb.geo.CartoDBLayer();

      map.layers.add(layer, { at: 0 });

      // Default CARTO only appears once and it's the last one
      expect(map.get('attribution')).toEqual([
        "attribution1",
        "wadus",
        DEFAULT_CARTO_ATTRIBUTION
      ]);
    })
  });

  describe('MapView', function() {

    beforeEach(function() {
      this.container = $('<div>').css('height', '200px');

      this.map = new cdb.geo.Map();
      this.mapView = new cdb.geo.MapView({
        el: this.container,
        map: this.map
      });
    });

    it('should be able to add a infowindow', function() {
      var infow = new cdb.geo.ui.Infowindow({mapView: this.mapView, model: new Backbone.Model()});
      this.mapView.addInfowindow(infow);

      expect(this.mapView._subviews[infow.cid]).toBeTruthy()
      expect(this.mapView._subviews[infow.cid] instanceof cdb.geo.ui.Infowindow).toBeTruthy()
    });

    it('should be able to retrieve the infowindows', function() {
      var infow = new cdb.geo.ui.Infowindow({mapView: this.mapView, model: new Backbone.Model()});
      this.mapView._subviews['irrelevant'] = new Backbone.View();
      this.mapView.addInfowindow(infow);

      var infowindows = this.mapView.getInfoWindows()

      expect(infowindows.length).toEqual(1);
      expect(infowindows[0]).toEqual(infow);
    });
  });
});