import LineString from '../../../../../src/ol/geom/LineString.js';
import MultiLineString from '../../../../../src/ol/geom/MultiLineString.js';
import MultiPolygon from '../../../../../src/ol/geom/MultiPolygon.js';
import Polygon from '../../../../../src/ol/geom/Polygon.js';
import RenderFeature from '../../../../../src/ol/render/Feature.js';

describe('ol.render.Feature', function () {
  const type = 'Point';
  const flatCoordinates = [0, 0];
  const ends = null;
  const properties = {foo: 'bar'};

  describe('Constructor', function () {
    it('creates an instance', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature).to.be.a(RenderFeature);
    });
  });

  describe('#get()', function () {
    it('returns a single property', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.get('foo')).to.be('bar');
    });
  });

  describe('#getEnds()', function () {
    it('returns the ends it was created with', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getEnds()).to.equal(ends);
    });
  });

  describe('#getExtent()', function () {
    it('returns the correct extent for a point', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getExtent()).to.eql([0, 0, 0, 0]);
    });

    it('caches the extent', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getExtent()).to.equal(feature.extent_);
    });

    it('returns the correct extent for a linestring', function () {
      const feature = new RenderFeature('LineString', [-1, -2, 2, 1], null, {});
      expect(feature.getExtent()).to.eql([-1, -2, 2, 1]);
    });
  });

  describe('#getFlatCoordinates()', function () {
    it('returns the flat coordinates it was created with', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getFlatCoordinates()).to.equal(flatCoordinates);
    });
  });

  describe('#getFlatInteriorPoint()', function () {
    it('returns correct point and caches it', function () {
      const polygon = new Polygon([
        [
          [0, 0],
          [0, 10],
          [10, 10],
          [10, 0],
          [0, 0],
        ],
      ]);
      const feature = new RenderFeature(
        'Polygon',
        polygon.getOrientedFlatCoordinates(),
        polygon.getEnds()
      );
      expect(feature.getFlatInteriorPoint()).to.eql([5, 5, 10]);
      expect(feature.getFlatInteriorPoint()).to.be(feature.flatInteriorPoints_);
    });
  });

  describe('#getFlatInteriorPoints()', function () {
    it('returns correct points and caches them', function () {
      const polygon = new MultiPolygon([
        [
          [
            [0, 0],
            [0, 10],
            [10, 10],
            [10, 0],
            [0, 0],
          ],
        ],
        [
          [
            [10, 0],
            [10, 10],
            [20, 10],
            [20, 0],
            [10, 0],
          ],
        ],
      ]);
      const feature = new RenderFeature(
        'MultiPolygon',
        polygon.getOrientedFlatCoordinates(),
        polygon.getEndss()
      );
      expect(feature.getFlatInteriorPoints()).to.eql([5, 5, 10, 15, 5, 10]);
      expect(feature.getFlatInteriorPoints()).to.be(
        feature.flatInteriorPoints_
      );
    });
  });

  describe('#getFlatMidpoint()', function () {
    it('returns correct point', function () {
      const line = new LineString([
        [0, 0],
        [0, 10],
        [10, 10],
        [10, 0],
        [0, 0],
      ]);
      const feature = new RenderFeature(
        'LineString',
        line.getFlatCoordinates()
      );
      expect(feature.getFlatMidpoint()).to.eql([10, 10]);
      expect(feature.getFlatMidpoint()).to.eql(feature.flatMidpoints_);
    });
  });

  describe('#getFlatMidpoints()', function () {
    it('returns correct points and caches them', function () {
      const line = new MultiLineString([
        [
          [0, 0],
          [0, 10],
          [10, 10],
          [10, 0],
          [0, 0],
        ],
        [
          [10, 0],
          [10, 10],
          [20, 10],
          [20, 0],
          [10, 0],
        ],
      ]);
      const feature = new RenderFeature(
        'MultiLineString',
        line.getFlatCoordinates(),
        line.getEnds()
      );
      expect(feature.getFlatMidpoints()).to.eql([10, 10, 20, 10]);
      expect(feature.getFlatMidpoints()).to.be(feature.flatMidpoints_);
    });
  });

  describe('#getGeometry()', function () {
    it('returns itself as geometry', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getGeometry()).to.equal(feature);
    });
  });

  describe('#getId()', function () {
    it('returns the feature id', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getId()).to.be('foo');
    });
  });

  describe('#getProperties()', function () {
    it('returns the properties it was created with', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getProperties()).to.equal(properties);
    });
  });

  describe('#getSimplifiedGeometry()', function () {
    it('returns itself as simplified geometry', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getSimplifiedGeometry()).to.equal(feature);
    });
  });

  describe('#getStride()', function () {
    it('returns 2', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getStride()).to.be(2);
    });
  });

  describe('#getStyleFunction()', function () {
    it('returns undefined', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getStyleFunction()).to.be(undefined);
    });
  });

  describe('#getType()', function () {
    it('returns the type it was created with', function () {
      const feature = new RenderFeature(
        type,
        flatCoordinates,
        ends,
        properties,
        'foo'
      );
      expect(feature.getType()).to.equal(type);
    });
  });
});