#include <nodes/FlowScene>

#include <functional>
#include <memory>
#include <utility>
#include <vector>

#include <nodes/Node>
#include <nodes/NodeDataModel>

#include <catch2/catch.hpp>

#include "ApplicationSetup.hpp"
#include "Stringify.hpp"
#include "StubNodeDataModel.hpp"

using QtNodes::Connection;
using QtNodes::DataModelRegistry;
using QtNodes::FlowScene;
using QtNodes::Node;
using QtNodes::NodeData;
using QtNodes::NodeDataModel;
using QtNodes::NodeDataType;
using QtNodes::PortIndex;
using QtNodes::PortType;

TEST_CASE("FlowScene triggers connections created or deleted", "[gui]")
{
  struct MockDataModel : StubNodeDataModel
  {
    unsigned int nPorts(PortType) const override { return 1; }

    void
    inputConnectionCreated(Connection const&) override
    {
      inputCreatedCalledCount++;
    }

    void
    inputConnectionDeleted(Connection const&) override
    {
      inputDeletedCalledCount++;
    }

    void
    outputConnectionCreated(Connection const&) override
    {
      outputCreatedCalledCount++;
    }

    void
    outputConnectionDeleted(Connection const&) override
    {
      outputDeletedCalledCount++;
    }

    int inputCreatedCalledCount  = 0;
    int inputDeletedCalledCount  = 0;
    int outputCreatedCalledCount = 0;
    int outputDeletedCalledCount = 0;

    void
    resetCallCounts()
    {
      inputCreatedCalledCount  = 0;
      inputDeletedCalledCount  = 0;
      outputCreatedCalledCount = 0;
      outputDeletedCalledCount = 0;
    }
  };

  auto setup = applicationSetup();

  FlowScene scene;

  Node& fromNode      = scene.createNode(std::make_unique<MockDataModel>());
  Node& toNode        = scene.createNode(std::make_unique<MockDataModel>());
  Node& unrelatedNode = scene.createNode(std::make_unique<MockDataModel>());

  auto& fromNgo      = fromNode.nodeGraphicsObject();
  auto& toNgo        = toNode.nodeGraphicsObject();
  auto& unrelatedNgo = unrelatedNode.nodeGraphicsObject();

  fromNgo.setPos(0, 0);
  toNgo.setPos(200, 20);
  unrelatedNgo.setPos(-100, -100);

  auto& from      = dynamic_cast<MockDataModel&>(*fromNode.nodeDataModel());
  auto& to        = dynamic_cast<MockDataModel&>(*toNode.nodeDataModel());
  auto& unrelated = dynamic_cast<MockDataModel&>(*unrelatedNode.nodeDataModel());


  SECTION("creating half a connection (not finishing the connection)")
  {
    auto connection = scene.createConnection(PortType::Out, fromNode, 0);

    CHECK(from.inputCreatedCalledCount == 0);
    CHECK(from.outputCreatedCalledCount == 0);

    CHECK(to.inputCreatedCalledCount == 0);
    CHECK(to.outputCreatedCalledCount == 0);

    CHECK(unrelated.inputCreatedCalledCount == 0);
    CHECK(unrelated.outputCreatedCalledCount == 0);

    scene.deleteConnection(*connection);
  }

  struct Creation
  {
    std::string                                  name;
    std::function<std::shared_ptr<Connection>()> createConnection;
  };

  Creation sceneCreation{"scene.createConnection",
                         [&] { return scene.createConnection(toNode, 0, fromNode, 0); }};

  Creation partialCreation{"scene.createConnection-by partial", [&] {
                             auto connection = scene.createConnection(PortType::Out, fromNode, 0);
                             connection->setNodeToPort(toNode, PortType::In, 0);

                             return connection;
                           }};

  struct Deletion
  {
    std::string                                      name;
    std::function<void(Connection & connection)> deleteConnection;
  };

  Deletion sceneDeletion{"scene.deleteConnection",
                         [&](Connection & c) { scene.deleteConnection(c); }};

  Deletion partialDragDeletion{"scene-deleteConnectionByDraggingOff",
                               [&](Connection & c)
                               {
                                 PortIndex portIndex = c.getPortIndex(PortType::In);
                                 Node * node = c.getNode(PortType::In);
                                 node->nodeState().getEntries(PortType::In)[portIndex].clear();
                                 c.clearNode(PortType::In);
                               }};

  SECTION("creating a connection")
  {
    std::vector<Creation> cases({sceneCreation, partialCreation});

    for (Creation const& create : cases)
    {
      SECTION(create.name)
      {
        auto connection = create.createConnection();

        CHECK(from.inputCreatedCalledCount == 0);
        CHECK(from.outputCreatedCalledCount == 1);

        CHECK(to.inputCreatedCalledCount == 1);
        CHECK(to.outputCreatedCalledCount == 0);

        CHECK(unrelated.inputCreatedCalledCount == 0);
        CHECK(unrelated.outputCreatedCalledCount == 0);

        scene.deleteConnection(*connection);
      }
    }
  }

  SECTION("deleting a connection")
  {
    std::vector<Deletion> cases({sceneDeletion, partialDragDeletion});

    for (auto const& deletion : cases)
    {
      SECTION("deletion: " + deletion.name)
      {
        Connection & connection = *sceneCreation.createConnection();

        from.resetCallCounts();
        to.resetCallCounts();

        deletion.deleteConnection(connection);

        // Here the Connection reference becomes dangling

        CHECK(from.inputDeletedCalledCount == 0);
        CHECK(from.outputDeletedCalledCount == 1);

        CHECK(to.inputDeletedCalledCount == 1);
        CHECK(to.outputDeletedCalledCount == 0);

        CHECK(unrelated.inputDeletedCalledCount == 0);
        CHECK(unrelated.outputDeletedCalledCount == 0);
      }
    }
  }
}


TEST_CASE("FlowScene's DataModelRegistry outlives nodes and connections", "[asan][gui]")
{
  class MockDataModel : public StubNodeDataModel
  {
  public:
    MockDataModel(int* const& incrementOnDestruction)
      : incrementOnDestruction(incrementOnDestruction)
    {
    }

    ~MockDataModel()
    {
      (*incrementOnDestruction)++;
    }

    // The reference ensures that we point into the memory that would be free'd
    // if the DataModelRegistry doesn't outlive this node
    int* const& incrementOnDestruction;
  };

  struct MockDataModelCreator
  {
    MockDataModelCreator(int* shouldBeAliveWhenAssignedTo)
      : shouldBeAliveWhenAssignedTo(shouldBeAliveWhenAssignedTo)
    {
    }

    auto
    operator()() const
    {
      return std::make_unique<MockDataModel>(shouldBeAliveWhenAssignedTo);
    }

    int* shouldBeAliveWhenAssignedTo;
  };

  int modelsDestroyed = 0;

  // Introduce a new scope, so that modelsDestroyed will be alive even after the
  // FlowScene is destroyed.
  {
    auto setup = applicationSetup();

    auto registry = std::make_shared<DataModelRegistry>();
    registry->registerModel(MockDataModelCreator(&modelsDestroyed));

    modelsDestroyed = 0;

    FlowScene scene(std::move(registry));

    auto& node = scene.createNode(scene.registry().create("name"));

    // On destruction, if this `node` outlives its MockDataModelCreator,
    // (if it outlives the DataModelRegistry), then we trigger undefined
    // behavior through use-after-free. ASAN will catch that.
  }

  CHECK(modelsDestroyed == 1);
}