import { defined } from "../../../Source/Cesium.js";
import { TimeInterval } from "../../../Source/Cesium.js";
import createViewer from "../../createViewer.js";
import DomEventSimulator from "../../DomEventSimulator.js";
import pollToPromise from "../../pollToPromise.js";
import { viewerDragDropMixin } from "../../../Source/Cesium.js";

describe(
  "Widgets/Viewer/viewerDragDropMixin",
  function () {
    var container;
    var viewer;
    beforeEach(function () {
      container = document.createElement("div");
      container.id = "container";
      container.style.display = "none";
      document.body.appendChild(container);

      //Impersonate FileReader for drag and drop tests
      var fakeFileReader = jasmine.createSpyObj("FileReader", ["readAsText"]);
      fakeFileReader.readAsText = function (file) {
        if (defined(file.czmlString)) {
          this.onload({
            target: {
              result: file.czmlString,
            },
          });
        } else {
          this.onerror({
            target: {
              error: file.errorMessage,
            },
          });
        }
      };
      spyOn(window, "FileReader").and.returnValue(fakeFileReader);
    });

    afterEach(function () {
      if (viewer && !viewer.isDestroyed()) {
        viewer = viewer.destroy();
      }

      document.body.removeChild(container);
    });

    it("mixin sets default values", function () {
      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);
      expect(viewer.dropTarget).toBe(viewer.container);
      expect(viewer.dropEnabled).toEqual(true);
      expect(viewer.clearOnDrop).toEqual(true);
      expect(viewer.clampToGround).toEqual(true);
      expect(viewer.flyToOnDrop).toEqual(true);
    });

    it("clearOnDrop defaults to true when dataSourceBrowser is not used", function () {
      viewer = createViewer(container, {
        dataSourceBrowser: false,
      });
      viewer.extend(viewerDragDropMixin);
      expect(viewer.clearOnDrop).toEqual(true);
    });

    it("mixin sets option values", function () {
      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin, {
        dropTarget: document.body,
        clearOnDrop: false,
        clampToGround: false,
        flyToOnDrop: false,
      });
      expect(viewer.dropTarget).toBe(document.body);
      expect(viewer.dropEnabled).toEqual(true);
      expect(viewer.clearOnDrop).toEqual(false);
      expect(viewer.clampToGround).toEqual(false);
      expect(viewer.flyToOnDrop).toEqual(false);
    });

    it("mixin works with dropTarget id string", function () {
      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin, {
        dropTarget: "container",
      });
      expect(viewer.dropTarget).toBe(container);
    });

    var czml1 = [
      {
        id: "document",
        version: "1.0",
        clock: {
          interval: "2000-01-01/2001-01-01",
        },
      },
      {
        id: "test",
      },
    ];

    var czml2 = [
      {
        id: "document",
        version: "1.0",
        clock: {
          interval: "2000-01-02/2001-01-02",
        },
      },
      {
        id: "test2",
      },
    ];

    it("handleDrop processes drop event", function () {
      var mockEvent = {
        dataTransfer: {
          files: [
            {
              name: "czml1.czml",
              czmlString: JSON.stringify(czml1),
            },
          ],
        },
        stopPropagation: function () {},
        preventDefault: function () {},
      };

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);

      DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

      return pollToPromise(function () {
        return viewer.dataSources.length === 1;
      }).then(function () {
        var dataSource = viewer.dataSources.get(0);
        var interval = TimeInterval.fromIso8601({
          iso8601: czml1[0].clock.interval,
        });
        expect(dataSource.entities.getById("test")).toBeDefined();
        expect(dataSource.clock.startTime).toEqual(interval.start);
        expect(dataSource.clock.stopTime).toEqual(interval.stop);
      });
    });

    it("handleDrop processes drop event with multiple files", function () {
      var mockEvent = {
        dataTransfer: {
          files: [
            {
              name: "czml1.czml",
              czmlString: JSON.stringify(czml1),
            },
            {
              name: "czml2.czml",
              czmlString: JSON.stringify(czml2),
            },
          ],
        },
        stopPropagation: function () {},
        preventDefault: function () {},
      };

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);

      DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

      return pollToPromise(function () {
        return viewer.dataSources.length === 2;
      }).then(function () {
        var source1 = viewer.dataSources.get(0);
        var source2 = viewer.dataSources.get(1);
        expect(source1.entities.getById("test")).toBeDefined();
        expect(source2.entities.getById("test2")).toBeDefined();
        //Interval of first file should be used.
        var interval = TimeInterval.fromIso8601({
          iso8601: czml1[0].clock.interval,
        });
        expect(source1.clock.startTime).toEqual(interval.start);
        expect(source1.clock.stopTime).toEqual(interval.stop);
      });
    });

    it("handleDrop obeys clearOnDrop", function () {
      var mockEvent = {
        dataTransfer: {
          files: [
            {
              name: "czml1.czml",
              czmlString: JSON.stringify(czml1),
            },
            {
              name: "czml2.czml",
              czmlString: JSON.stringify(czml2),
            },
          ],
        },
        stopPropagation: function () {},
        preventDefault: function () {},
      };

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);

      DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

      return pollToPromise(function () {
        return viewer.dataSources.length === 2;
      }).then(function () {
        var source1 = viewer.dataSources.get(0);
        var source2 = viewer.dataSources.get(1);
        expect(source1.entities.getById("test")).toBeDefined();
        expect(source2.entities.getById("test2")).toBeDefined();
        //Interval of first file should be used.
        var interval = TimeInterval.fromIso8601({
          iso8601: czml1[0].clock.interval,
        });
        expect(source1.clock.startTime).toEqual(interval.start);
        expect(source1.clock.stopTime).toEqual(interval.stop);

        viewer.clearOnDrop = false;
        DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

        return pollToPromise(function () {
          return viewer.dataSources.length === 4;
        }).then(function () {
          var source1 = viewer.dataSources.get(0);
          var source2 = viewer.dataSources.get(1);
          var source3 = viewer.dataSources.get(2);
          var source4 = viewer.dataSources.get(3);

          expect(source1.entities.getById("test")).toBeDefined();
          expect(source2.entities.getById("test2")).toBeDefined();
          expect(source3.entities.getById("test")).toBeDefined();
          expect(source4.entities.getById("test2")).toBeDefined();

          viewer.clearOnDrop = true;
          DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

          return pollToPromise(function () {
            return viewer.dataSources.length === 2;
          }).then(function () {
            var source1 = viewer.dataSources.get(0);
            var source2 = viewer.dataSources.get(1);
            expect(source1.entities.getById("test")).toBeDefined();
            expect(source2.entities.getById("test2")).toBeDefined();
            //Interval of first file should be used.
            var interval = TimeInterval.fromIso8601({
              iso8601: czml1[0].clock.interval,
            });
            expect(source1.clock.startTime).toEqual(interval.start);
            expect(source1.clock.stopTime).toEqual(interval.stop);
          });
        });
      });
    });

    it("dropError is raised on exception", function () {
      var mockEvent = {
        dataTransfer: {
          files: [
            {
              name: "czml1.czml",
              czmlString: "bad JSON",
            },
          ],
        },
        stopPropagation: function () {},
        preventDefault: function () {},
      };

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);

      var spyListener = jasmine.createSpy("listener");

      viewer.dropError.addEventListener(spyListener);
      DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

      return pollToPromise(function () {
        return spyListener.calls.any();
      }).then(function () {
        expect(spyListener).toHaveBeenCalledWith(
          viewer,
          "czml1.czml",
          jasmine.any(SyntaxError)
        );

        viewer.dropError.removeEventListener(spyListener);
      });
    });

    it("dropError is raised FileReader error", function () {
      var mockEvent = {
        dataTransfer: {
          files: [
            {
              name: "czml1.czml",
              errorMessage: "bad JSON",
            },
          ],
        },
        stopPropagation: function () {},
        preventDefault: function () {},
      };

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);

      var spyListener = jasmine.createSpy("listener");

      viewer.dropError.addEventListener(spyListener);
      DomEventSimulator.fireMockEvent(viewer._handleDrop, mockEvent);

      return pollToPromise(function () {
        return spyListener.calls.any();
      }).then(function () {
        expect(spyListener).toHaveBeenCalledWith(
          viewer,
          mockEvent.dataTransfer.files[0].name,
          mockEvent.dataTransfer.files[0].errorMessage
        );

        viewer.dropError.removeEventListener(spyListener);
      });
    });

    function MockContainer() {
      var events = {};
      this.events = events;

      this.addEventListener = function (name, func, bubble) {
        events[name] = {
          func: func,
          bubble: bubble,
        };
      };

      this.removeEventListener = function (name, func, bubble) {
        var subscribed = events[name];
        expect(subscribed.func).toBe(func);
        expect(subscribed.bubble).toEqual(bubble);
        delete events[name];
      };
    }

    it("enable/disable subscribes to provided dropTarget.", function () {
      var dropTarget = new MockContainer();

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin, {
        dropTarget: dropTarget,
      });

      expect(dropTarget.events.drop).toBeDefined();
      expect(dropTarget.events.dragenter).toBeDefined();
      expect(dropTarget.events.dragover).toBeDefined();
      expect(dropTarget.events.dragexit).toBeDefined();

      viewer.dropEnabled = false;
      expect(dropTarget.events.drop).toBeUndefined();
      expect(dropTarget.events.dragenter).toBeUndefined();
      expect(dropTarget.events.dragover).toBeUndefined();
      expect(dropTarget.events.dragexit).toBeUndefined();

      viewer.dropEnabled = true;
      expect(dropTarget.events.drop).toBeDefined();
      expect(dropTarget.events.dragenter).toBeDefined();
      expect(dropTarget.events.dragover).toBeDefined();
      expect(dropTarget.events.dragexit).toBeDefined();
    });

    it("can set new dropTarget.", function () {
      var dropTarget1 = new MockContainer();
      var dropTarget2 = new MockContainer();

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin, {
        dropTarget: dropTarget1,
      });

      expect(dropTarget1.events.drop).toBeDefined();
      expect(dropTarget1.events.dragenter).toBeDefined();
      expect(dropTarget1.events.dragover).toBeDefined();
      expect(dropTarget1.events.dragexit).toBeDefined();

      viewer.dropTarget = dropTarget2;
      expect(dropTarget1.events.drop).toBeUndefined();
      expect(dropTarget1.events.dragenter).toBeUndefined();
      expect(dropTarget1.events.dragover).toBeUndefined();
      expect(dropTarget1.events.dragexit).toBeUndefined();

      expect(dropTarget2.events.drop).toBeDefined();
      expect(dropTarget2.events.dragenter).toBeDefined();
      expect(dropTarget2.events.dragover).toBeDefined();
      expect(dropTarget2.events.dragexit).toBeDefined();
    });

    it("can set proxy.", function () {
      var proxy = {};

      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin, {
        proxy: proxy,
      });
      expect(viewer.proxy).toBe(proxy);
    });

    it("throws with undefined viewer", function () {
      expect(function () {
        viewerDragDropMixin(undefined);
      }).toThrowDeveloperError();
    });

    it("throws with non-existant string container", function () {
      viewer = createViewer(container);
      expect(function () {
        viewer.extend(viewerDragDropMixin, {
          dropTarget: "doesNotExist",
        });
      }).toThrowDeveloperError();
    });

    it("throws if dropTarget property already added by another mixin.", function () {
      viewer = createViewer(container);
      viewer.dropTarget = true;
      expect(function () {
        viewer.extend(viewerDragDropMixin);
      }).toThrowDeveloperError();
    });

    it("throws if dropEnabled property already added by another mixin.", function () {
      viewer = createViewer(container);
      viewer.dropEnabled = true;
      expect(function () {
        viewer.extend(viewerDragDropMixin);
      }).toThrowDeveloperError();
    });

    it("throws if dropError property already added by another mixin.", function () {
      viewer = createViewer(container);
      viewer.dropError = true;
      expect(function () {
        viewer.extend(viewerDragDropMixin);
      }).toThrowDeveloperError();
    });

    it("throws if clearOnDrop property already added by another mixin.", function () {
      viewer = createViewer(container);
      viewer.clearOnDrop = true;
      expect(function () {
        viewer.extend(viewerDragDropMixin);
      }).toThrowDeveloperError();
    });

    it("throws if flyToOnDrop property already added by another mixin.", function () {
      viewer = createViewer(container);
      viewer.flyToOnDrop = true;
      expect(function () {
        viewer.extend(viewerDragDropMixin);
      }).toThrowDeveloperError();
    });

    it("setting dropTarget to undefined throws exception", function () {
      viewer = createViewer(container);
      viewer.extend(viewerDragDropMixin);
      expect(function () {
        viewer.dropTarget = undefined;
      }).toThrowDeveloperError();
    });
  },
  "WebGL"
);