import { Cartesian3 } from "../../Source/Cesium.js";
import { Color } from "../../Source/Cesium.js";
import { Credit } from "../../Source/Cesium.js";
import { Event } from "../../Source/Cesium.js";
import { JulianDate } from "../../Source/Cesium.js";
import { PolygonHierarchy } from "../../Source/Cesium.js";
import { RuntimeError } from "../../Source/Cesium.js";
import { CallbackProperty } from "../../Source/Cesium.js";
import { ConstantProperty } from "../../Source/Cesium.js";
import { EntityCollection } from "../../Source/Cesium.js";
import { GeoJsonDataSource } from "../../Source/Cesium.js";
import { HeightReference } from "../../Source/Cesium.js";
import { when } from "../../Source/Cesium.js";

describe("DataSources/GeoJsonDataSource", function () {
  var defaultMarkerSize;
  var defaultSymbol;
  var defaultMarkerColor;
  var defaultStroke;
  var defaultStrokeWidth;
  var defaultFill;
  var defaultClampToGround;

  beforeAll(function () {
    defaultMarkerSize = GeoJsonDataSource.markerSize;
    defaultSymbol = GeoJsonDataSource.markerSymbol;
    defaultMarkerColor = GeoJsonDataSource.markerColor;
    defaultStroke = GeoJsonDataSource.stroke;
    defaultStrokeWidth = GeoJsonDataSource.strokeWidth;
    defaultFill = GeoJsonDataSource.fill;
    defaultClampToGround = GeoJsonDataSource.clampToGround;
  });

  beforeEach(function () {
    GeoJsonDataSource.markerSize = defaultMarkerSize;
    GeoJsonDataSource.markerSymbol = defaultSymbol;
    GeoJsonDataSource.markerColor = defaultMarkerColor;
    GeoJsonDataSource.stroke = defaultStroke;
    GeoJsonDataSource.strokeWidth = defaultStrokeWidth;
    GeoJsonDataSource.fill = defaultFill;
    GeoJsonDataSource.clampToGround = defaultClampToGround;
  });

  var time = new JulianDate();

  function coordinatesToCartesian(coordinates) {
    return Cartesian3.fromDegrees(
      coordinates[0],
      coordinates[1],
      coordinates[2]
    );
  }

  function coordinatesArrayToCartesian(coordinates) {
    var result = [];
    for (var i = 0; i < coordinates.length; i++) {
      result.push(coordinatesToCartesian(coordinates[i]));
    }
    return result;
  }

  function multiLineToCartesian(geometry) {
    var coordinates = geometry.coordinates;
    var result = [];
    for (var i = 0; i < coordinates.length; i++) {
      result.push(coordinatesArrayToCartesian(coordinates[i]));
    }
    return result;
  }

  function polygonCoordinatesToCartesian(coordinates) {
    return coordinatesArrayToCartesian(coordinates);
  }

  function multiPolygonCoordinatesToCartesian(coordinates) {
    var result = [];
    for (var i = 0; i < coordinates.length; i++) {
      result.push(coordinatesArrayToCartesian(coordinates[i][0]));
    }
    return result;
  }

  var point = {
    type: "Point",
    coordinates: [102.0, 0.5],
  };

  var pointNamedCrs = {
    type: "Point",
    coordinates: [102.0, 0.5],
    crs: {
      type: "name",
      properties: {
        name: "EPSG:4326",
      },
    },
  };

  var pointNamedCrsOgc = {
    type: "Point",
    coordinates: [102.0, 0.5],
    crs: {
      type: "name",
      properties: {
        name: "urn:ogc:def:crs:OGC:1.3:CRS84",
      },
    },
  };

  var pointNamedCrsEpsg = {
    type: "Point",
    coordinates: [102.0, 0.5],
    crs: {
      type: "name",
      properties: {
        name: "urn:ogc:def:crs:EPSG::4326",
      },
    },
  };

  var pointCrsLinkHref = {
    type: "Point",
    coordinates: [102.0, 0.5],
    crs: {
      type: "link",
      properties: {
        href: "http://crs.invalid",
      },
    },
  };

  var pointCrsEpsg = {
    type: "Point",
    coordinates: [102.0, 0.5],
    crs: {
      type: "EPSG",
      properties: {
        code: 4326,
      },
    },
  };

  var lineString = {
    type: "LineString",
    coordinates: [
      [100.0, 0.0],
      [101.0, 1.0],
    ],
  };

  var polygon = {
    type: "Polygon",
    coordinates: [
      [
        [100.0, 0.0],
        [101.0, 0.0],
        [101.0, 1.0],
        [100.0, 1.0],
        [100.0, 0.0],
      ],
    ],
  };

  var polygonWithHoles = {
    type: "Polygon",
    coordinates: [
      [
        [100.0, 0.0],
        [101.0, 0.0],
        [101.0, 1.0],
        [100.0, 1.0],
        [100.0, 0.0],
      ],
      [
        [100.2, 0.2],
        [100.8, 0.2],
        [100.8, 0.8],
        [100.2, 0.8],
        [100.2, 0.2],
      ],
    ],
  };

  var polygonWithHeights = {
    type: "Polygon",
    coordinates: [
      [
        [100.0, 0.0, 1.0],
        [101.0, 0.0, 2.0],
        [101.0, 1.0, 1.0],
        [100.0, 1.0, 2.0],
        [100.0, 0.0, 3.0],
      ],
    ],
  };

  var multiPoint = {
    type: "MultiPoint",
    coordinates: [
      [100.0, 0.0],
      [101.0, 1.0],
      [101.0, 3.0],
    ],
  };

  var multiLineString = {
    type: "MultiLineString",
    coordinates: [
      [
        [100.0, 0.0],
        [101.0, 1.0],
      ],
      [
        [102.0, 2.0],
        [103.0, 3.0],
      ],
    ],
  };

  var multiPolygon = {
    type: "MultiPolygon",
    coordinates: [
      [
        [
          [102.0, 2.0],
          [103.0, 2.0],
          [103.0, 3.0],
          [102.0, 3.0],
          [102.0, 2.0],
        ],
      ],
      [
        [
          [100.0, 0.0],
          [101.0, 0.0],
          [101.0, 1.0],
          [100.0, 1.0],
          [100.0, 0.0],
        ],
      ],
    ],
  };

  var geometryCollection = {
    type: "GeometryCollection",
    geometries: [
      {
        type: "Point",
        coordinates: [100.0, 0.0],
      },
      {
        type: "LineString",
        coordinates: [
          [101.0, 0.0],
          [102.0, 1.0],
        ],
      },
    ],
  };

  var feature = {
    type: "Feature",
    geometry: point,
  };

  var featureWithNullName = {
    type: "Feature",
    geometry: point,
    properties: {
      name: null,
    },
  };

  var featureWithId = {
    id: "myId",
    type: "Feature",
    geometry: geometryCollection,
  };

  var featureUndefinedGeometry = {
    type: "Feature",
  };

  var featureNullGeometry = {
    type: "Feature",
    geometry: null,
  };

  var unknownGeometry = {
    type: "TimeyWimey",
    coordinates: [0, 0],
  };

  var featureUnknownGeometry = {
    type: "Feature",
    geometry: unknownGeometry,
  };

  var geometryCollectionUnknownType = {
    type: "GeometryCollection",
    geometries: [unknownGeometry],
  };

  var topoJson = {
    type: "Topology",
    transform: {
      scale: [1, 1],
      translate: [0, 0],
    },
    objects: {
      polygon: {
        type: "Polygon",
        arcs: [[0, 1, 2, 3]],
        properties: {
          myProps: 0,
        },
      },
      lineString: {
        type: "LineString",
        arcs: [4],
        properties: {
          myProps: 1,
        },
      },
    },
    arcs: [
      [
        [0, 0],
        [1, 0],
        [0, 1],
        [-1, 0],
        [0, -1],
      ],
      [
        [0, 0],
        [1, 0],
        [0, 1],
      ],
      [
        [1, 1],
        [-1, 0],
        [0, -1],
      ],
      [[1, 1]],
      [[0, 0]],
    ],
  };

  var mixedGeometries = {
    type: "GeometryCollection",
    geometries: [lineString, polygon, point],
  };

  it("default constructor has expected values", function () {
    var dataSource = new GeoJsonDataSource();
    expect(dataSource.changedEvent).toBeInstanceOf(Event);
    expect(dataSource.errorEvent).toBeInstanceOf(Event);
    expect(dataSource.clock).toBeUndefined();
    expect(dataSource.name).toBeUndefined();
    expect(dataSource.entities).toBeInstanceOf(EntityCollection);
    expect(dataSource.entities.values.length).toEqual(0);
    expect(dataSource.show).toBe(true);
    expect(dataSource.credit).toBeUndefined();
  });

  it("credit gets set from options", function () {
    return GeoJsonDataSource.load(point, {
      credit: "This is my credit",
    }).then(function (dataSource) {
      expect(dataSource.credit).toBeInstanceOf(Credit);
    });
  });

  it("setting name raises changed event", function () {
    var dataSource = new GeoJsonDataSource();

    var spy = jasmine.createSpy("changedEvent");
    dataSource.changedEvent.addEventListener(spy);

    var newName = "chester";
    dataSource.name = newName;
    expect(dataSource.name).toEqual(newName);
    expect(spy.calls.count()).toEqual(1);
    expect(spy).toHaveBeenCalledWith(dataSource);
  });

  it("show sets underlying entity collection show.", function () {
    var dataSource = new GeoJsonDataSource();

    dataSource.show = false;
    expect(dataSource.show).toBe(false);
    expect(dataSource.show).toEqual(dataSource.entities.show);

    dataSource.show = true;
    expect(dataSource.show).toBe(true);
    expect(dataSource.show).toEqual(dataSource.entities.show);
  });

  it("Works with null geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureNullGeometry).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(featureNullGeometry.properties);
      expect(entity.position).toBeUndefined();
    });
  });

  it("Works with feature", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(feature).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(feature.properties);
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(feature.geometry.coordinates)
      );
      expect(entity.billboard).toBeDefined();
    });
  });

  it("Creates default description from properties", function () {
    var featureWithProperties = {
      type: "Feature",
      geometry: point,
      properties: {
        prop1: "dog",
        prop2: "cat",
        prop3: "liger",
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithProperties).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.description).toBeDefined();
      var description = entity.description.getValue(time);
      expect(description).toContain("prop1");
      expect(description).toContain("prop2");
      expect(description).toContain("prop3");
      expect(description).toContain("dog");
      expect(description).toContain("cat");
      expect(description).toContain("liger");
    });
  });

  it("Creates custom description string from properties", function () {
    var featureWithProperties = {
      type: "Feature",
      geometry: point,
      properties: {
        prop1: "dog",
        prop2: "cat",
      },
    };

    function testDescribe(properties) {
      var desc = "";
      for (var key in properties) {
        if (properties.hasOwnProperty(key)) {
          var value = properties[key];
          desc += key + " = " + value + ". ";
        }
      }
      return desc;
    }

    var dataSource = new GeoJsonDataSource();
    var options = {
      describe: testDescribe,
    };
    return dataSource.load(featureWithProperties, options).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.description).toBeDefined();
      var description = entity.description.getValue(time);
      expect(description).toContain("prop1 = dog.");
      expect(description).toContain("prop2 = cat.");
    });
  });

  it("Creates custom description from properties, using a describeProperty", function () {
    var featureWithProperties = {
      type: "Feature",
      geometry: point,
      properties: {
        prop1: "dog",
        prop2: "cat",
      },
    };

    function testDescribe(properties) {
      var desc = "";
      for (var key in properties) {
        if (properties.hasOwnProperty(key)) {
          var value = properties[key];
          desc += key + " = " + value + "; ";
        }
      }
      return desc;
    }
    function createDescriptionCallback(describe, properties, nameProperty) {
      var description;
      return function (time, result) {
        if (!description) {
          description = describe(properties, nameProperty);
        }
        return description;
      };
    }
    function testDescribeProperty(properties, nameProperty) {
      return new CallbackProperty(
        createDescriptionCallback(testDescribe, properties, nameProperty),
        true
      );
    }

    var dataSource = new GeoJsonDataSource();
    var options = {
      describe: testDescribeProperty,
    };
    return dataSource.load(featureWithProperties, options).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.description).toBeDefined();
      var description = entity.description.getValue(time);
      expect(description).toContain("prop1 = dog;");
      expect(description).toContain("prop2 = cat;");
    });
  });

  it("Uses description if present", function () {
    var featureWithDescription = {
      type: "Feature",
      geometry: point,
      properties: {
        prop1: "dog",
        prop2: "cat",
        prop3: "liger",
        description: "This is my descriptiong!",
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithDescription).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.description).toBeDefined();
      expect(entity.description.getValue(time)).toEqual(
        featureWithDescription.properties.description
      );
    });
  });

  it("Handles null description", function () {
    var featureWithNullDescription = {
      type: "Feature",
      geometry: point,
      properties: {
        description: null,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithNullDescription).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.description).toBeUndefined();
    });
  });

  it('Does not use "name" property as the object\'s name if it is null', function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithNullName).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.name).toBeUndefined();
      expect(entity.properties.name.getValue()).toBe(
        featureWithNullName.properties.name
      );
      expect(entity.properties.getValue(time)).toEqual(
        featureWithNullName.properties
      );
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(featureWithNullName.geometry.coordinates)
      );
      expect(entity.billboard).toBeDefined();
    });
  });

  it("Works with feature with id", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithId).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.id).toEqual(featureWithId.id);
      entity = entityCollection.values[1];
      expect(entity.id).toEqual(featureWithId.id + "_2");
    });
  });

  it("Works with null id", function () {
    var geojson = {
      id: null,
      type: "Feature",
      geometry: null,
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geojson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.id).not.toEqual(null);
    });
  });

  it("Works with null properties", function () {
    var geojson = {
      type: "Feature",
      geometry: null,
      properties: null,
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geojson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBeUndefined();
    });
  });

  it("Has entity collection with link to data source", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithId).then(function () {
      var entityCollection = dataSource.entities;
      expect(entityCollection.owner).toEqual(dataSource);
    });
  });

  it("Has entity with link to entity collection", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(featureWithId).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.entityCollection).toEqual(entityCollection);
    });
  });

  it("Works with point geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(point).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(point.properties);
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(point.coordinates)
      );
      expect(entity.billboard).toBeDefined();
      expect(entity.billboard.image).toBeDefined();
    });
  });

  it("Works with point geometry clamped to ground", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(point, {
        clampToGround: true,
      })
      .then(function () {
        var entityCollection = dataSource.entities;
        var entity = entityCollection.values[0];
        expect(entity.properties).toBe(point.properties);
        expect(entity.position.getValue(time)).toEqual(
          coordinatesToCartesian(point.coordinates)
        );
        expect(entity.billboard).toBeDefined();
        expect(entity.billboard.image).toBeDefined();
        expect(entity.billboard.heightReference.getValue(time)).toBe(
          HeightReference.CLAMP_TO_GROUND
        );
      });
  });

  it("Works with point geometry with simplystyle", function () {
    var geojson = {
      type: "Point",
      coordinates: [102.0, 0.5],
      properties: {
        "marker-size": "large",
        "marker-symbol": "bus",
        "marker-color": "#ffffff",
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geojson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.billboard).toBeDefined();
      return when(
        dataSource._pinBuilder.fromMakiIconId("bus", Color.WHITE, 64)
      ).then(function (image) {
        expect(entity.billboard.image.getValue()).toBe(image);
      });
    });
  });

  it("Works with point geometry with null simplystyle", function () {
    var geojson = {
      type: "Point",
      coordinates: [102.0, 0.5],
      properties: {
        "marker-size": null,
        "marker-symbol": null,
        "marker-color": null,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geojson).then(function () {
      var image = dataSource._pinBuilder.fromColor(
        GeoJsonDataSource.markerColor,
        GeoJsonDataSource.markerSize
      );
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.billboard).toBeDefined();
      expect(entity.billboard.image.getValue()).toBe(image);
    });
  });

  it("Works with point geometry and unknown simplystyle", function () {
    var geojson = {
      type: "Point",
      coordinates: [102.0, 0.5],
      properties: {
        "marker-size": "large",
        "marker-symbol": "notAnIcon",
        "marker-color": "#ffffff",
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geojson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.billboard).toBeDefined();
      return when(dataSource._pinBuilder.fromColor(Color.WHITE, 64)).then(
        function (image) {
          expect(entity.billboard.image.getValue()).toBe(image);
        }
      );
    });
  });

  it("Works with multipoint geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(multiPoint).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;
      var expectedPositions = coordinatesArrayToCartesian(
        multiPoint.coordinates
      );
      for (var i = 0; i < multiPoint.coordinates.length; i++) {
        var entity = entities[i];
        expect(entity.properties).toBe(multiPoint.properties);
        expect(entity.position.getValue(time)).toEqual(expectedPositions[i]);
        expect(entity.billboard).toBeDefined();
        expect(entity.billboard.image).toBeDefined();
      }
    });
  });

  it("Works with multipoint geometry clamped to ground", function () {
    GeoJsonDataSource.clampToGround = true;
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(multiPoint).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;
      var expectedPositions = coordinatesArrayToCartesian(
        multiPoint.coordinates
      );
      for (var i = 0; i < multiPoint.coordinates.length; i++) {
        var entity = entities[i];
        expect(entity.properties).toBe(multiPoint.properties);
        expect(entity.position.getValue(time)).toEqual(expectedPositions[i]);
        expect(entity.billboard).toBeDefined();
        expect(entity.billboard.image).toBeDefined();
        expect(entity.billboard.heightReference.getValue()).toBe(
          HeightReference.CLAMP_TO_GROUND
        );
      }
    });
  });

  it("Works with lineString geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(lineString).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(lineString.properties);
      expect(entity.polyline.positions.getValue(time)).toEqual(
        coordinatesArrayToCartesian(lineString.coordinates)
      );
      expect(entity.polyline.material.color.getValue(time)).toEqual(
        GeoJsonDataSource.stroke
      );
      expect(entity.polyline.width.getValue(time)).toEqual(2);
    });
  });

  it("Works with lineString geometry clamped to ground", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(lineString, {
        clampToGround: true,
      })
      .then(function () {
        var entityCollection = dataSource.entities;
        var entity = entityCollection.values[0];
        expect(entity.properties).toBe(lineString.properties);
        expect(entity.polyline.positions.getValue(time)).toEqual(
          coordinatesArrayToCartesian(lineString.coordinates)
        );
        expect(entity.polyline.material.color.getValue(time)).toEqual(
          GeoJsonDataSource.stroke
        );
        expect(entity.polyline.width.getValue(time)).toEqual(2);
        expect(entity.polyline.clampToGround.getValue(time)).toEqual(true);
      });
  });

  it("Works with multiLineString geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(multiLineString).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;
      var lines = multiLineToCartesian(multiLineString);
      for (var i = 0; i < multiLineString.coordinates.length; i++) {
        var entity = entities[i];
        expect(entity.properties).toBe(multiLineString.properties);
        expect(entity.polyline.positions.getValue(time)).toEqual(lines[i]);
        expect(entity.polyline.material.color.getValue(time)).toEqual(
          Color.YELLOW
        );
        expect(entity.polyline.width.getValue(time)).toEqual(2);
      }
    });
  });

  it("Works with multiLineString geometry clamped to ground", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(multiLineString, {
        clampToGround: true,
      })
      .then(function () {
        var entityCollection = dataSource.entities;
        var entities = entityCollection.values;
        var lines = multiLineToCartesian(multiLineString);
        for (var i = 0; i < multiLineString.coordinates.length; i++) {
          var entity = entities[i];
          expect(entity.properties).toBe(multiLineString.properties);
          expect(entity.polyline.positions.getValue(time)).toEqual(lines[i]);
          expect(entity.polyline.material.color.getValue(time)).toEqual(
            Color.YELLOW
          );
          expect(entity.polyline.width.getValue(time)).toEqual(2);
          expect(entity.polyline.clampToGround.getValue(time)).toEqual(true);
        }
      });
  });

  it("Works with polygon geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(polygon).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(polygon.properties);
      expect(entity.polygon.hierarchy.getValue(time)).toEqual(
        new PolygonHierarchy(
          polygonCoordinatesToCartesian(polygon.coordinates[0])
        )
      );
      expect(entity.polygon.perPositionHeight).toBeUndefined();
      expect(entity.polygon.material.color.getValue(time)).toEqual(
        GeoJsonDataSource.fill
      );
      expect(entity.polygon.outline.getValue(time)).toEqual(true);
      expect(entity.polygon.outlineWidth.getValue(time)).toEqual(
        GeoJsonDataSource.strokeWidth
      );
      expect(entity.polygon.outlineColor.getValue(time)).toEqual(
        GeoJsonDataSource.stroke
      );
      expect(entity.polygon.height).toBeInstanceOf(ConstantProperty);
    });
  });

  it("Works with polygon geometry clamped to ground", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(polygon, {
        clampToGround: true,
      })
      .then(function () {
        var entityCollection = dataSource.entities;
        var entity = entityCollection.values[0];
        expect(entity.properties).toBe(polygon.properties);
        expect(entity.polygon.hierarchy.getValue(time)).toEqual(
          new PolygonHierarchy(
            polygonCoordinatesToCartesian(polygon.coordinates[0])
          )
        );
        expect(entity.polygon.perPositionHeight).toBeUndefined();
        expect(entity.polygon.material.color.getValue(time)).toEqual(
          GeoJsonDataSource.fill
        );
        expect(entity.polygon.outline.getValue(time)).toEqual(true);
        expect(entity.polygon.outlineWidth.getValue(time)).toEqual(
          GeoJsonDataSource.strokeWidth
        );
        expect(entity.polygon.outlineColor.getValue(time)).toEqual(
          GeoJsonDataSource.stroke
        );
        expect(entity.polygon.height).toBeUndefined();
      });
  });

  it("Works with polygon geometry with Heights", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(polygonWithHeights).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(polygonWithHeights.properties);
      expect(entity.polygon.hierarchy.getValue(time)).toEqual(
        new PolygonHierarchy(
          polygonCoordinatesToCartesian(polygonWithHeights.coordinates[0])
        )
      );
      expect(entity.polygon.perPositionHeight.getValue(time)).toBe(true);
      expect(entity.polygon.material.color.getValue(time)).toEqual(
        GeoJsonDataSource.fill
      );
      expect(entity.polygon.outline.getValue(time)).toEqual(true);
      expect(entity.polygon.outlineWidth.getValue(time)).toEqual(
        GeoJsonDataSource.strokeWidth
      );
      expect(entity.polygon.outlineColor.getValue(time)).toEqual(
        GeoJsonDataSource.stroke
      );
    });
  });

  it("Works with polygon geometry with holes", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(polygonWithHoles).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(polygonWithHoles.properties);
      expect(entity.polygon.hierarchy.getValue(time)).toEqual(
        new PolygonHierarchy(
          polygonCoordinatesToCartesian(polygonWithHoles.coordinates[0]),
          [
            new PolygonHierarchy(
              polygonCoordinatesToCartesian(polygonWithHoles.coordinates[1])
            ),
          ]
        )
      );
    });
  });

  it("Works with multiPolygon geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(multiPolygon).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;
      var positions = multiPolygonCoordinatesToCartesian(
        multiPolygon.coordinates
      );
      for (var i = 0; i < multiPolygon.coordinates.length; i++) {
        var entity = entities[i];
        expect(entity.properties).toBe(multiPolygon.properties);
        expect(entity.polygon.hierarchy.getValue(time)).toEqual(
          new PolygonHierarchy(positions[i])
        );
      }
    });
  });

  it("Works with topojson geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(topoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;

      var polygon = entities[0];
      expect(polygon.properties.myProps.getValue()).toBe(
        topoJson.objects.polygon.properties.myProps
      );
      expect(polygon.properties.getValue(time)).toEqual(
        topoJson.objects.polygon.properties
      );

      expect(polygon.polygon.hierarchy).toBeDefined();

      var lineString = entities[1];
      expect(lineString.properties.myProps.getValue()).toBe(
        topoJson.objects.lineString.properties.myProps
      );
      expect(lineString.properties.getValue(time)).toEqual(
        topoJson.objects.lineString.properties
      );

      expect(lineString.polyline).toBeDefined();
    });
  });

  it("Can provide base styling options", function () {
    var options = {
      markerSize: 10,
      markerSymbol: "bus",
      markerColor: Color.GREEN,
      stroke: Color.ORANGE,
      strokeWidth: 8,
      fill: Color.RED,
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(mixedGeometries, options).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;

      var entity = entities[0];
      expect(entity.polyline.material.color.getValue()).toEqual(options.stroke);
      expect(entity.polyline.width.getValue()).toEqual(options.strokeWidth);

      entity = entities[1];
      expect(entity.polygon.material.color.getValue()).toEqual(options.fill);
      expect(entity.polygon.outlineColor.getValue()).toEqual(options.stroke);
      expect(entity.polygon.outlineWidth.getValue()).toEqual(
        options.strokeWidth
      );

      entity = entities[2];
      var expectedImage = dataSource._pinBuilder.fromMakiIconId(
        options.markerSymbol,
        options.markerColor,
        options.markerSize
      );
      expect(entity.billboard.image.getValue()).toEqual(expectedImage);
    });
  });

  it("Can set default graphics", function () {
    GeoJsonDataSource.markerSize = 10;
    GeoJsonDataSource.markerSymbol = "bus";
    GeoJsonDataSource.markerColor = Color.GREEN;
    GeoJsonDataSource.stroke = Color.ORANGE;
    GeoJsonDataSource.strokeWidth = 8;
    GeoJsonDataSource.fill = Color.RED;

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(mixedGeometries).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;

      var entity = entities[0];
      expect(entity.polyline.material.color.getValue()).toEqual(
        GeoJsonDataSource.stroke
      );
      expect(entity.polyline.width.getValue()).toEqual(
        GeoJsonDataSource.strokeWidth
      );

      entity = entities[1];
      expect(entity.polygon.material.color.getValue()).toEqual(
        GeoJsonDataSource.fill
      );
      expect(entity.polygon.outlineColor.getValue()).toEqual(
        GeoJsonDataSource.stroke
      );
      expect(entity.polygon.outlineWidth.getValue()).toEqual(
        GeoJsonDataSource.strokeWidth
      );

      entity = entities[2];
      var expectedImage = dataSource._pinBuilder.fromMakiIconId(
        GeoJsonDataSource.markerSymbol,
        GeoJsonDataSource.markerColor,
        GeoJsonDataSource.markerSize
      );
      expect(entity.billboard.image.getValue()).toEqual(expectedImage);
    });
  });

  it("Generates description", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(topoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entities = entityCollection.values;
      var polygon = entities[0];
      expect(polygon.description).toBeDefined();
    });
  });

  it("Works with geometrycollection", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geometryCollection).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.properties).toBe(geometryCollection.properties);
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(geometryCollection.geometries[0].coordinates)
      );
      expect(entity.billboard).toBeDefined();

      entity = entityCollection.values[1];
      expect(entity.properties).toBe(geometryCollection.properties);
      expect(entity.polyline.positions.getValue(time)).toEqual(
        coordinatesArrayToCartesian(
          geometryCollection.geometries[1].coordinates
        )
      );
    });
  });

  it("Works with named crs", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(pointNamedCrs).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(point.coordinates)
      );
    });
  });

  it("Works with named crs OGC:1.3:CRS84", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(pointNamedCrsOgc).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(point.coordinates)
      );
    });
  });

  it("Works with named crs EPSG::4326", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load(pointNamedCrsEpsg).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(point.coordinates)
      );
    });
  });

  it("Works with link crs href", function () {
    var projectedPosition = new Cartesian3(1, 2, 3);
    GeoJsonDataSource.crsLinkHrefs[
      pointCrsLinkHref.crs.properties.href
    ] = function (properties) {
      expect(properties).toBe(pointCrsLinkHref.crs.properties);
      return when(properties.href).then(function (href) {
        return function (coordinate) {
          expect(coordinate).toBe(pointCrsLinkHref.coordinates);
          return projectedPosition;
        };
      });
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(pointCrsLinkHref).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.position.getValue(time)).toEqual(projectedPosition);
    });
  });

  it("Works with EPSG crs", function () {
    var dataSource = new GeoJsonDataSource();

    return dataSource.load(pointCrsEpsg).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.position.getValue(time)).toEqual(
        coordinatesToCartesian(point.coordinates)
      );
    });
  });

  it("Works with polyline using simplestyle", function () {
    var geoJson = {
      type: "Feature",
      geometry: {
        type: "LineString",
        coordinates: [
          [100.0, 0.0],
          [101.0, 1.0],
        ],
      },
      properties: {
        title: "textMarker",
        description: "My description",
        stroke: "#aabbcc",
        "stroke-opacity": 0.5,
        "stroke-width": 5,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.name).toEqual(geoJson.properties.title);
      expect(entity.description.getValue(time)).toEqual(
        geoJson.properties.description
      );

      var expectedColor = Color.fromCssColorString(geoJson.properties.stroke);
      expectedColor.alpha = geoJson.properties["stroke-opacity"];
      expect(entity.polyline.material.color.getValue(time)).toEqual(
        expectedColor
      );
      expect(entity.polyline.width.getValue(time)).toEqual(
        geoJson.properties["stroke-width"]
      );
    });
  });

  it("Works with polyline using null simplestyle values", function () {
    var geoJson = {
      type: "Feature",
      geometry: {
        type: "LineString",
        coordinates: [
          [100.0, 0.0],
          [101.0, 1.0],
        ],
      },
      properties: {
        title: null,
        description: null,
        stroke: null,
        "stroke-opacity": null,
        "stroke-width": null,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.name).toBeUndefined();
      expect(entity.description).toBeUndefined();
      expect(entity.polyline.material.color.getValue(time)).toEqual(
        GeoJsonDataSource.stroke
      );
      expect(entity.polyline.width.getValue(time)).toEqual(
        GeoJsonDataSource.strokeWidth
      );
    });
  });

  it("Works with polygon using simplestyle", function () {
    var geoJson = {
      type: "Feature",
      geometry: {
        type: "Polygon",
        coordinates: [
          [
            [100.0, 0.0],
            [101.0, 0.0],
            [101.0, 1.0],
            [100.0, 1.0],
            [100.0, 0.0],
          ],
        ],
      },
      properties: {
        title: "textMarker",
        description: "My description",
        stroke: "#aabbcc",
        "stroke-opacity": 0.5,
        "stroke-width": 5,
        fill: "#ccaabb",
        "fill-opacity": 0.25,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.name).toEqual(geoJson.properties.title);
      expect(entity.description.getValue(time)).toEqual(
        geoJson.properties.description
      );

      var expectedFill = Color.fromCssColorString(geoJson.properties.fill);
      expectedFill.alpha = geoJson.properties["fill-opacity"];

      var expectedOutlineColor = Color.fromCssColorString(
        geoJson.properties.stroke
      );
      expectedOutlineColor.alpha = geoJson.properties["stroke-opacity"];

      expect(entity.polygon.material.color.getValue(time)).toEqual(
        expectedFill
      );
      expect(entity.polygon.outline.getValue(time)).toEqual(true);
      expect(entity.polygon.outlineWidth.getValue(time)).toEqual(5);
      expect(entity.polygon.outlineColor.getValue(time)).toEqual(
        expectedOutlineColor
      );
    });
  });

  it("Works with polygon using null simplestyle", function () {
    var geoJson = {
      type: "Feature",
      geometry: {
        type: "Polygon",
        coordinates: [
          [
            [100.0, 0.0],
            [101.0, 0.0],
            [101.0, 1.0],
            [100.0, 1.0],
            [100.0, 0.0],
          ],
        ],
      },
      properties: {
        title: null,
        description: null,
        stroke: null,
        "stroke-opacity": null,
        "stroke-width": null,
        fill: null,
        "fill-opacity": null,
      },
    };

    var dataSource = new GeoJsonDataSource();
    return dataSource.load(geoJson).then(function () {
      var entityCollection = dataSource.entities;
      var entity = entityCollection.values[0];
      expect(entity.name).toBeUndefined();
      expect(entity.description).toBeUndefined();
      expect(entity.polygon.material.color.getValue(time)).toEqual(
        GeoJsonDataSource.fill
      );
      expect(entity.polygon.outline.getValue(time)).toEqual(true);
      expect(entity.polygon.outlineWidth.getValue(time)).toEqual(
        GeoJsonDataSource.strokeWidth
      );
      expect(entity.polygon.outlineColor.getValue(time)).toEqual(
        GeoJsonDataSource.stroke
      );
    });
  });

  it("load works with a URL", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource.load("Data/test.geojson").then(function () {
      expect(dataSource.name).toEqual("test.geojson");
    });
  });

  it("Fails when encountering unknown geometry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(featureUnknownGeometry)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function () {});
  });

  it("Fails with undefined geomeetry", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(featureUndefinedGeometry)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function () {});
  });

  it("Fails with unknown geomeetry in geometryCollection", function () {
    var dataSource = new GeoJsonDataSource();
    return dataSource
      .load(geometryCollectionUnknownType)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function () {});
  });

  it("load throws with undefined geoJson", function () {
    var dataSource = new GeoJsonDataSource();
    expect(function () {
      dataSource.load(undefined);
    }).toThrowDeveloperError();
  });

  it("rejects unknown geometry", function () {
    return GeoJsonDataSource.load(unknownGeometry)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error).toBeInstanceOf(RuntimeError);
        expect(error.message).toContain(
          "Unsupported GeoJSON object type: TimeyWimey"
        );
      });
  });

  it("rejects invalid url", function () {
    return GeoJsonDataSource.load("invalid.geojson")
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error.statusCode).toBe(404);
      });
  });

  it("rejects null CRS", function () {
    var featureWithNullCrs = {
      type: "Feature",
      geometry: point,
      crs: null,
    };

    return GeoJsonDataSource.load(featureWithNullCrs).then(function (
      dataSource
    ) {
      expect(dataSource.entities.values.length).toBe(0);
    });
  });

  it("rejects unknown CRS", function () {
    var featureWithUnknownCrsType = {
      type: "Feature",
      geometry: point,
      crs: {
        type: "potato",
        properties: {},
      },
    };

    return GeoJsonDataSource.load(featureWithUnknownCrsType)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error).toBeInstanceOf(RuntimeError);
        expect(error.message).toContain("Unknown crs type: potato");
      });
  });

  it("rejects undefined CRS properties", function () {
    var featureWithUndefinedCrsProperty = {
      type: "Feature",
      geometry: point,
      crs: {
        type: "name",
      },
    };

    return GeoJsonDataSource.load(featureWithUndefinedCrsProperty)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error).toBeInstanceOf(RuntimeError);
        expect(error.message).toContain("crs.properties is undefined.");
      });
  });

  it("rejects unknown CRS name", function () {
    var featureWithUnknownCrsType = {
      type: "Feature",
      geometry: point,
      crs: {
        type: "name",
        properties: {
          name: "failMe",
        },
      },
    };

    return GeoJsonDataSource.load(featureWithUnknownCrsType)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error).toBeInstanceOf(RuntimeError);
        expect(error.message).toContain("Unknown crs name: failMe");
      });
  });

  it("rejects unknown CRS link", function () {
    var featureWithUnknownCrsType = {
      type: "Feature",
      geometry: point,
      crs: {
        type: "link",
        properties: {
          href: "failMe",
          type: "failMeTwice",
        },
      },
    };

    return GeoJsonDataSource.load(featureWithUnknownCrsType)
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function (error) {
        expect(error).toBeInstanceOf(RuntimeError);
        expect(error.message).toContain(
          'Unable to resolve crs link: {"href":"failMe","type":"failMeTwice"}'
        );
      });
  });

  it("load rejects loading non json file", function () {
    var dataSource = new GeoJsonDataSource();
    var spy = jasmine.createSpy("errorEvent");
    dataSource.errorEvent.addEventListener(spy);

    // Blue.png is not JSON
    return dataSource
      .load("Data/Images/Blue.png")
      .then(function () {
        fail("should not be called");
      })
      .otherwise(function () {
        expect(spy).toHaveBeenCalledWith(dataSource, jasmine.any(Error));
      });
  });

  it("load raises loading event", function () {
    var dataSource = new GeoJsonDataSource();
    var spy = jasmine.createSpy("loadingEvent");
    dataSource.loadingEvent.addEventListener(spy);

    var promise = dataSource.load("Data/test.geojson");
    expect(spy).toHaveBeenCalledWith(dataSource, true);
    expect(dataSource.isLoading).toBe(true);

    return promise.then(function () {
      expect(spy).toHaveBeenCalledWith(dataSource, false);
      expect(dataSource.isLoading).toBe(false);
    });
  });
});
