'use strict';

require('../../../../TestHelper');

/* global inject, bootstrapModeler */

var flatten = require('lodash/array/flatten');

var coreModule = require('lib/core'),
    moveModule = require('diagram-js/lib/features/move'),
    modelingModule = require('lib/features/modeling'),
    noTouchInteractionModule = { touchInteractionEvents: ['value', null ] };

var canvasEvent = require('../../../../util/MockEvents').createCanvasEvent;

describe('modeling/behavior - drop on connection', function() {

  var diagramXML = require('./DropOnFlowBehavior.bpmn');

  var testModules = [ noTouchInteractionModule, moveModule, modelingModule, coreModule ];

  beforeEach(bootstrapModeler(diagramXML, { modules: testModules }));


  describe('rules', function() {

    it('should be allowed for an IntermediateThrowEvent', inject(function(elementRegistry, bpmnRules, elementFactory) {

      // when
      var sequenceFlow = elementRegistry.get('SequenceFlow_1');
      var intermediateThrowEvent = elementFactory.createShape({ type: 'bpmn:IntermediateThrowEvent' });

      // then
      expect(bpmnRules.canCreate(intermediateThrowEvent, sequenceFlow)).to.be.true;
    }));

  });


  describe('execution', function() {

    describe('create', function() {

      it('should connect start -> target -> end', inject(function(modeling, elementRegistry, elementFactory) {

        // given
        var intermediateThrowEvent = elementFactory.createShape({ type: 'bpmn:IntermediateThrowEvent' });

        var startEvent = elementRegistry.get('StartEvent'),
            sequenceFlow = elementRegistry.get('SequenceFlow_1'),
            task = elementRegistry.get('Task_1');

        var originalWaypoints = sequenceFlow.waypoints;

        var dropPosition = { x: 340, y: 120 }; // first bendpoint

        // when
        var newShape = modeling.createShape(intermediateThrowEvent, dropPosition, sequenceFlow);

        // then

        var targetConnection = newShape.outgoing[0];

        // new incoming connection
        expect(newShape.incoming.length).to.equal(1);
        expect(newShape.incoming[0]).to.eql(sequenceFlow);

        // new outgoing connection
        expect(newShape.outgoing.length).to.equal(1);
        expect(targetConnection).to.be.ok;
        expect(targetConnection.type).to.equal('bpmn:SequenceFlow');

        expect(startEvent.outgoing[0]).to.equal(newShape.incoming[0]);
        expect(task.incoming[0]).to.equal(newShape.outgoing[0]);

        // split target at insertion point
        expect(sequenceFlow).to.have.waypoints(flatten([
          originalWaypoints.slice(0, 1),
          { x: 322, y: 120 }
        ]));

        expect(sequenceFlow).to.have.endDocking(dropPosition);

        expect(targetConnection).to.have.waypoints(flatten([
          { x: 340, y: 138 },
          originalWaypoints.slice(2)
        ]));

        expect(targetConnection).to.have.startDocking(dropPosition);
      }));


      it('should connect start -> target', inject(function(modeling, elementRegistry, elementFactory) {

        // given
        var endEventShape = elementFactory.createShape({ type: 'bpmn:EndEvent' });

        var sequenceFlow = elementRegistry.get('SequenceFlow_1');
        var originalWaypoints = sequenceFlow.waypoints;

        var dropPosition = { x: 340, y: 120 }; // first bendpoint

        // when
        var newShape = modeling.createShape(endEventShape, dropPosition, sequenceFlow);

        // then

        // new incoming connection
        expect(newShape.incoming.length).to.equal(1);
        expect(newShape.incoming[0]).to.eql(sequenceFlow);

        // no outgoing edges
        expect(newShape.outgoing.length).to.equal(0);

        // split target at insertion point
        expect(sequenceFlow).to.have.waypoints(flatten([
          originalWaypoints.slice(0, 1),
          { x: 322, y: 120 }
        ]));
      }));


      it('should connect target -> end', inject(function(modeling, elementRegistry, elementFactory) {

        // given
        var startEventShape = elementFactory.createShape({ type: 'bpmn:StartEvent' });

        var sequenceFlow = elementRegistry.get('SequenceFlow_1');
        var originalWaypoints = sequenceFlow.waypoints;

        var dropPosition = { x: 340, y: 120 }; // first bendpoint

        // when
        var newShape = modeling.createShape(startEventShape, dropPosition, sequenceFlow);

        // then

        // no incoming connection
        expect(newShape.incoming.length).to.equal(0);

        // no outgoing edges
        expect(newShape.outgoing.length).to.equal(1);
        expect(newShape.outgoing[0]).to.eql(sequenceFlow);

        // split target at insertion point
        expect(sequenceFlow).to.have.waypoints(flatten([
          { x: 340, y: 138 },
          originalWaypoints.slice(2)
        ]));
      }));


      it('should connect start -> target -> end (with bendpointBefore inside bbox)', inject(
        function(modeling, elementRegistry, elementFactory) {
          // given
          var taskShape = elementFactory.createShape({ type: 'bpmn:Task' }),
              sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              originalWaypoints = sequenceFlow.waypoints,
              dropPosition = { x: 340, y: 145 }; // 25 pixels below bendpoint

          // when
          modeling.createShape(taskShape, dropPosition, sequenceFlow);

          // then
          // split target but don't keep insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            originalWaypoints.slice(0, 1),
            { x: 290, y: 120 }
          ]));

          expect(sequenceFlow).to.have.endDocking({ x: 340, y: 120 });
        }
      ));


      it('should connect start -> target -> end (with bendpointAfter inside bbox)', inject(
        function(modeling, elementRegistry, elementFactory) {

          // given
          var taskShape = elementFactory.createShape({ type: 'bpmn:Task' }),
              sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              originalWaypoints = sequenceFlow.waypoints,
              dropPosition = { x: 340, y: 280 }; // 25 pixels above bendpoint

          // when
          var newShape = modeling.createShape(taskShape, dropPosition, sequenceFlow),
              targetConnection = newShape.outgoing[0];

          // then
          // split target but don't keep insertion point
          expect(targetConnection).to.have.waypoints(flatten([
            { x: 390, y: 299 },
            originalWaypoints.slice(3)
          ]));

          expect(targetConnection).to.have.startDocking({ x: 340, y: 299 });
        }
      ));

    });


    describe('move', function() {

      beforeEach(inject(function(dragging) {
        dragging.setOptions({ manual: true });
      }));

      it('should connect start -> target -> end', inject(function(dragging, move, elementRegistry, selection) {

        // given
        var intermediateThrowEvent = elementRegistry.get('IntermediateThrowEvent_foo');

        var startEvent = elementRegistry.get('StartEvent'),
            sequenceFlow = elementRegistry.get('SequenceFlow_1'),
            sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
            task = elementRegistry.get('Task_1');

        var originalWaypoints = sequenceFlow.waypoints;

        // when
        selection.select(intermediateThrowEvent);

        move.start(canvasEvent({ x: 0, y: 0 }), intermediateThrowEvent);

        dragging.hover({
          element: sequenceFlow,
          gfx: sequenceFlowGfx
        });

        dragging.move(canvasEvent({ x: 150, y: 0 }));

        dragging.end();

        // then
        var targetConnection = intermediateThrowEvent.outgoing[0];

        // new incoming connection
        expect(intermediateThrowEvent.incoming.length).to.equal(1);
        expect(intermediateThrowEvent.incoming[0]).to.eql(sequenceFlow);

        // new outgoing connection
        expect(intermediateThrowEvent.outgoing.length).to.equal(1);
        expect(targetConnection).to.be.ok;
        expect(targetConnection.type).to.equal('bpmn:SequenceFlow');

        expect(startEvent.outgoing[0]).to.equal(intermediateThrowEvent.incoming[0]);
        expect(task.incoming[0]).to.equal(intermediateThrowEvent.outgoing[0]);

        // split target at insertion point
        expect(sequenceFlow).to.have.waypoints(flatten([
          originalWaypoints.slice(0, 2),
          { x: 341, y: 192 }
        ]));

        expect(sequenceFlow).to.have.endDocking({ x: 341, y: 210 });

        expect(targetConnection).to.have.waypoints(flatten([
          { x: 341, y: 228 },
          originalWaypoints.slice(2)
        ]));

        expect(targetConnection).to.have.startDocking({ x: 341, y: 210 });
      }));


      it('should connect start -> target -> end (hovering parent)', inject(
        function(dragging, move, elementRegistry, selection, canvas) {

          // given
          var intermediateThrowEvent = elementRegistry.get('IntermediateThrowEvent_foo');

          var startEvent = elementRegistry.get('StartEvent'),
              sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              task = elementRegistry.get('Task_1'),
              rootElement = canvas.getRootElement(),
              rootElementGfx = elementRegistry.getGraphics(rootElement);

          var originalWaypoints = sequenceFlow.waypoints;

          // when
          selection.select(intermediateThrowEvent);

          move.start(canvasEvent({ x: 0, y: 0 }), intermediateThrowEvent);

          dragging.hover({
            element: rootElement,
            gfx: rootElementGfx
          });

          dragging.move(canvasEvent({ x: 150, y: 0 }));
          dragging.end();

          // then
          var targetConnection = intermediateThrowEvent.outgoing[0];

          // new incoming connection
          expect(intermediateThrowEvent.incoming.length).to.equal(1);
          expect(intermediateThrowEvent.incoming[0]).to.eql(sequenceFlow);

          // new outgoing connection
          expect(intermediateThrowEvent.outgoing.length).to.equal(1);
          expect(targetConnection).to.be.ok;
          expect(targetConnection.type).to.equal('bpmn:SequenceFlow');

          expect(startEvent.outgoing[0]).to.equal(intermediateThrowEvent.incoming[0]);
          expect(task.incoming[0]).to.equal(intermediateThrowEvent.outgoing[0]);

          // split target at insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            originalWaypoints.slice(0, 2),
            { x: 341, y: 192 }
          ]));

          expect(sequenceFlow).to.have.endDocking({ x: 341, y: 210 });

          expect(targetConnection).to.have.waypoints(flatten([
            { x: 341, y: 228 },
            originalWaypoints.slice(2)
          ]));

          expect(targetConnection).to.have.startDocking({ x: 341, y: 210 });
        }
      ));


      it('should connect start -> target -> end (with bendpointBefore inside bbox)', inject(
        function(elementRegistry, selection, move, dragging) {
          // given
          var task3 = elementRegistry.get('Task_3'),
              sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
              originalWaypoints = sequenceFlow.waypoints;

          // when
          selection.select(task3);

          move.start(canvasEvent({ x: 0, y: 0 }), task3);

          dragging.hover({
            element: sequenceFlow,
            gfx: sequenceFlowGfx
          });

          dragging.move(canvasEvent({ x: 150, y: -130 }));
          dragging.end();

          // then
          // split target but don't keep insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            originalWaypoints.slice(0, 2),
            { x: 341, y: 241 }
          ]));

          expect(sequenceFlow).to.have.endDocking({ x: 341, y: 281 });
        }
      ));


      it('should connect start -> target -> end (with bendpointAfter inside bbox)', inject(
        function(elementRegistry, selection, move, dragging) {
          // given
          var task3 = elementRegistry.get('Task_3'),
              sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
              originalWaypoints = sequenceFlow.waypoints;

          // when
          selection.select(task3);

          move.start(canvasEvent({ x: 0, y: 0 }), task3);

          dragging.hover({
            element: sequenceFlow,
            gfx: sequenceFlowGfx
          });

          dragging.move(canvasEvent({ x: 170, y: -110 }));
          dragging.end();

          // then
          // split target but don't keep insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            originalWaypoints.slice(0, 2),
            { x: 340, y: 261 }
          ]));

          expect(sequenceFlow).to.have.endDocking({ x: 340, y: 299 });
        }
      ));


      it('should connect start -> target', inject(
        function(modeling, elementRegistry, selection, move, dragging) {

          // given
          var endEventShape = elementRegistry.get('EndEvent_foo');

          var sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
              originalWaypoints = sequenceFlow.waypoints;

          // when
          selection.select(endEventShape);

          move.start(canvasEvent({ x: 0, y: 0 }), endEventShape);

          dragging.hover({
            element: sequenceFlow,
            gfx: sequenceFlowGfx
          });

          dragging.move(canvasEvent({ x: 150, y: 0 }));

          dragging.end();

          // then

          // new incoming connection
          expect(endEventShape.incoming.length).to.equal(1);
          expect(endEventShape.incoming[0]).to.eql(sequenceFlow);

          // no outgoing edges
          expect(endEventShape.outgoing.length).to.equal(0);

          // split target at insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            originalWaypoints.slice(0, 2),
            { x: 340, y: 281 }
          ]));
        }
      ));


      it('should connect target -> end', inject(
        function(modeling, elementRegistry, dragging, selection, move) {

          var startEventShape = elementRegistry.get('StartEvent_foo');

          var sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
              originalWaypoints = sequenceFlow.waypoints;

          // when
          selection.select(startEventShape);

          move.start(canvasEvent({ x: 0, y: 0 }), startEventShape);

          dragging.hover({
            element: sequenceFlow,
            gfx: sequenceFlowGfx
          });

          dragging.move(canvasEvent({ x: -215, y: 0 }));

          dragging.end();

          // then

          // no incoming connection
          expect(startEventShape.incoming.length).to.equal(0);

          // 1 outgoing connection
          expect(startEventShape.outgoing.length).to.equal(1);
          expect(startEventShape.outgoing[0]).to.eql(sequenceFlow);

          // split target at insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([
            { x: 338, y: 228 },
            originalWaypoints.slice(2)
          ]));
        }
      ));


      it('should undo', inject(
        function(modeling, elementRegistry, dragging, selection, move, commandStack) {

          // given
          var startEventShape = elementRegistry.get('StartEvent_foo');

          var sequenceFlow = elementRegistry.get('SequenceFlow_1'),
              sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow),
              originalWaypoints = sequenceFlow.waypoints;

          selection.select(startEventShape);

          move.start(canvasEvent({ x: 0, y: 0 }), startEventShape);

          dragging.hover({
            element: sequenceFlow,
            gfx: sequenceFlowGfx
          });

          dragging.move(canvasEvent({ x: -215, y: 0 }));

          dragging.end();

          // when
          commandStack.undo();

          // then

          // no incoming connection
          expect(startEventShape.incoming.length).to.equal(0);

          // no outgoing edges
          expect(startEventShape.outgoing.length).to.equal(0);

          // split target at insertion point
          expect(sequenceFlow).to.have.waypoints(flatten([ originalWaypoints ]));
        }
      ));

    });

  });


  describe('rules', function() {

    it('should not insert participant', inject(
      function(rules, elementRegistry, elementFactory) {

        // given
        var participantShape = elementFactory.createShape({ type: 'bpmn:Participant' });

        var sequenceFlow = elementRegistry.get('SequenceFlow_1');

        var dropPosition = { x: 340, y: 120 }; // first bendpoint

        // when
        var canDrop = rules.allowed('shape.create', {
          shape: participantShape,
          parent: sequenceFlow,
          dropPosition: dropPosition
        });

        // then
        expect(canDrop).to.be.false;
      }
    ));


    it('should not insert multiple with "move"', inject(
      function(elementRegistry, selection, move, dragging) {

        // given
        var intermediateThrowEvent = elementRegistry.get('IntermediateThrowEvent_foo'),
            endEventShape = elementRegistry.get('EndEvent_foo');

        var sequenceFlow = elementRegistry.get('SequenceFlow_1'),
            sequenceFlowGfx = elementRegistry.getGraphics(sequenceFlow);

        var intInitPosition = {
              x: intermediateThrowEvent.x,
              y: intermediateThrowEvent.y
            },
            endInitPosition = {
              x: endEventShape.x,
              y: endEventShape.y
            };

        selection.select([ intermediateThrowEvent, endEventShape ]);

        // when
        move.start(canvasEvent({ x: 0, y: 0 }), intermediateThrowEvent);

        dragging.hover({
          element: sequenceFlow,
          gfx: sequenceFlowGfx
        });

        dragging.move(canvasEvent({ x: -215, y: 0 }));

        dragging.end();

        // then
        expect(intermediateThrowEvent).to.have.position(intInitPosition);
        expect(endEventShape).to.have.position(endInitPosition);
      }
    ));


    it('should not insert on sequence flow label', inject(function(bpmnRules, elementRegistry) {

      // given
      var eventShape = elementRegistry.get('IntermediateThrowEvent_foo'),
          sequenceFlowLabel = elementRegistry.get('SequenceFlow_2').label;

      var dropPosition = { x: 675, y: 275 }; // sequence flow label

      // when
      var canInsert = bpmnRules.canInsert(eventShape, sequenceFlowLabel, dropPosition);

      // then
      expect(canInsert).to.be.false;
    }));

  });

});