#include "RadiantTest.h"

#include "imap.h"
#include "ibrush.h"
#include "entitylib.h"
#include "algorithm/Scene.h"

namespace test
{

using CsgTest = RadiantTest;

TEST_F(CsgTest, CSGMergeTwoRegularWorldspawnBrushes)
{
    loadMap("csg_merge.map");

    // Locate the first worldspawn brush
    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Try to merge the two brushes with the "1" and "2" materials
    auto firstBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto secondBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "2");

    ASSERT_TRUE(Node_getIBrush(firstBrush)->getNumFaces() == 5);
    ASSERT_TRUE(Node_getIBrush(secondBrush)->getNumFaces() == 5);

    // Select the brushes and merge them
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(firstBrush, true);
    Node_setSelected(secondBrush, true);

    // CSG merge
    GlobalCommandSystem().executeCommand("CSGMerge");

    // The two brushes should be gone, replaced by a new one
    ASSERT_TRUE(firstBrush->getParent() == nullptr);
    ASSERT_TRUE(secondBrush->getParent() == nullptr);

    // The merged brush will carry both materials
    auto brushWithMaterial1 = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto brushWithMaterial2 = algorithm::findFirstBrushWithMaterial(worldspawn, "2");

    ASSERT_TRUE(brushWithMaterial1 == brushWithMaterial2);
    ASSERT_TRUE(Node_getIBrush(brushWithMaterial1)->getNumFaces() == 6);
}

TEST_F(CsgTest, CSGMergeFourRegularWorldspawnBrushes)
{
    loadMap("csg_merge.map");

    // Locate the first worldspawn brush
    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Try to merge the two brushes with the "1" and "2" materials
    std::vector<scene::INodePtr> brushes = {
        algorithm::findFirstBrushWithMaterial(worldspawn, "1"),
        algorithm::findFirstBrushWithMaterial(worldspawn, "2"),
        algorithm::findFirstBrushWithMaterial(worldspawn, "3"),
        algorithm::findFirstBrushWithMaterial(worldspawn, "4")
    };

    // Check the correct setup
    for (const auto& brush : brushes)
    {
        ASSERT_TRUE(Node_getIBrush(brush)->getNumFaces() == 5);
    }

    // Select the brushes and merge them
    GlobalSelectionSystem().setSelectedAll(false);
    for (const auto& brush : brushes)
    {
        Node_setSelected(brush, true);
    }

    // CSG merge
    GlobalCommandSystem().executeCommand("CSGMerge");

    // All brushes should be gone, replaced by a new one
    for (const auto& brush : brushes)
    {
        ASSERT_TRUE(brush->getParent() == nullptr);
    }

    // The combined brush should be a 6-sided cuboid
    auto brushWithMaterial1 = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    ASSERT_TRUE(Node_getIBrush(brushWithMaterial1)->getNumFaces() == 6);
}

TEST_F(CsgTest, CSGMergeTwoFuncStaticBrushes)
{
    loadMap("csg_merge.map");

    // Locate the func_static in the map
    EntityNodeFindByClassnameWalker walker("func_static");
    GlobalSceneGraph().root()->traverse(walker);

    auto entity = walker.getEntityNode();

    // Try to merge the two brushes with the "1" and "2" materials
    auto firstBrush = algorithm::findFirstBrushWithMaterial(entity, "1");
    auto secondBrush = algorithm::findFirstBrushWithMaterial(entity, "2");

    ASSERT_TRUE(Node_getIBrush(firstBrush)->getNumFaces() == 5);
    ASSERT_TRUE(Node_getIBrush(secondBrush)->getNumFaces() == 5);

    // Select the brushes and merge them
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(firstBrush, true);
    Node_setSelected(secondBrush, true);

    // CSG merge
    GlobalCommandSystem().executeCommand("CSGMerge");

    // The two brushes should be gone, replaced by a new one
    ASSERT_TRUE(firstBrush->getParent() == nullptr);
    ASSERT_TRUE(secondBrush->getParent() == nullptr);

    // The merged brush will carry both materials
    auto brushWithMaterial1 = algorithm::findFirstBrushWithMaterial(entity, "1");
    auto brushWithMaterial2 = algorithm::findFirstBrushWithMaterial(entity, "2");

    ASSERT_TRUE(brushWithMaterial1 == brushWithMaterial2);
    ASSERT_TRUE(Node_getIBrush(brushWithMaterial1)->getNumFaces() == 6);

    // They should still be children of the same entity
    ASSERT_TRUE(brushWithMaterial1->getParent() == entity);
    ASSERT_TRUE(brushWithMaterial2->getParent() == entity);
}

// #5344: Check that selecting a couple of brushes will only merge those
// which share the same parent entity
TEST_F(CsgTest, CSGMergeBrushesOfMixedEntitySelection)
{
    loadMap("csg_merge.map");

    // Locate the func_static in the map
    EntityNodeFindByClassnameWalker walker("func_static");
    GlobalSceneGraph().root()->traverse(walker);

    auto entity = walker.getEntityNode();
    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Select the mergeable brushes of both entities carrying the "1" and "2" materials
    std::vector<scene::INodePtr> brushes = {
        algorithm::findFirstBrushWithMaterial(entity, "1"),
        algorithm::findFirstBrushWithMaterial(entity, "2"),
        algorithm::findFirstBrushWithMaterial(worldspawn, "1"),
        algorithm::findFirstBrushWithMaterial(worldspawn, "2")
    };

    // Check the correct setup
    for (const auto& brush : brushes)
    {
        ASSERT_TRUE(Node_getIBrush(brush)->getNumFaces() == 5);
    }

    // Select the brushes and merge them
    GlobalSelectionSystem().setSelectedAll(false);

    for (const auto& brush : brushes)
    {
        Node_setSelected(brush, true);
    }

    // CSG merge
    GlobalCommandSystem().executeCommand("CSGMerge");

    // All brushes should be gone, replaced by TWO new ones
    for (const auto& brush : brushes)
    {
        ASSERT_TRUE(brush->getParent() == nullptr);
    }

    // The merged brush will carry both materials
    auto funcBrush1 = algorithm::findFirstBrushWithMaterial(entity, "1");
    auto funcBrush2 = algorithm::findFirstBrushWithMaterial(entity, "2");

    ASSERT_TRUE(funcBrush1);
    ASSERT_TRUE(funcBrush1 == funcBrush2);
    ASSERT_TRUE(Node_getIBrush(funcBrush1)->getNumFaces() == 6);

    // Same for the worldspawn entity
    auto worldBrush1 = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto worldBrush2 = algorithm::findFirstBrushWithMaterial(worldspawn, "2");

    ASSERT_TRUE(worldBrush1);
    ASSERT_TRUE(worldBrush1 == worldBrush2);
    ASSERT_TRUE(Node_getIBrush(worldBrush1)->getNumFaces() == 6);
}

// Issue #5336: Crash when using CSG Merge on brushes that are part of worldspawn and a func_static
TEST_F(CsgTest, CSGMergeWithFuncStatic)
{
    loadMap("csg_merge_with_func_static.map");

    // Locate the first worldspawn brush
    auto firstBrush = algorithm::getNthChild(GlobalMapModule().getWorldspawn(), 0);
    ASSERT_TRUE(firstBrush);

    // Locate the func_static in the map
    EntityNodeFindByClassnameWalker walker("func_static");
    GlobalSceneGraph().root()->traverse(walker);

    auto entityNode = walker.getEntityNode();
    ASSERT_TRUE(entityNode);
    ASSERT_TRUE(entityNode->hasChildNodes());

    // Select both of them, the order is important
    Node_setSelected(firstBrush, true);
    Node_setSelected(entityNode, true);

    // CSG merge
    GlobalCommandSystem().executeCommand("CSGMerge");

    // No merge should have happened since the brushes 
    // are not part of the same entity
    // So assume the scene didn't change
    ASSERT_TRUE(algorithm::getNthChild(GlobalMapModule().getWorldspawn(), 0) == firstBrush);

    EntityNodeFindByClassnameWalker walker2("func_static");
    GlobalSceneGraph().root()->traverse(walker2);

    ASSERT_TRUE(walker.getEntityNode());
    ASSERT_TRUE(walker.getEntityNode()->hasChildNodes());
}

TEST_F(CsgTest, CSGIntersectTwoOverlappingBrushes)
{
    loadMap("csg_intersect.map");

    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Find the two overlapping brushes with materials "1" and "2"
    auto firstBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto secondBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "2");

    ASSERT_TRUE(firstBrush != nullptr);
    ASSERT_TRUE(secondBrush != nullptr);
    ASSERT_TRUE(Node_getIBrush(firstBrush)->getNumFaces() == 6);
    ASSERT_TRUE(Node_getIBrush(secondBrush)->getNumFaces() == 6);

    // Select the brushes and intersect them
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(firstBrush, true);
    Node_setSelected(secondBrush, true);

    // CSG intersect
    GlobalCommandSystem().executeCommand("CSGIntersect");

    // The two brushes should be gone, replaced by a new one
    ASSERT_TRUE(firstBrush->getParent() == nullptr);
    ASSERT_TRUE(secondBrush->getParent() == nullptr);

    // The intersection should have created a new brush
    // It should have materials from the first brush (since we started with that)
    auto resultBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    ASSERT_TRUE(resultBrush != nullptr);

    // The result should be a valid 6-sided brush (the intersection of two cubes is a cube)
    ASSERT_TRUE(Node_getIBrush(resultBrush)->getNumFaces() == 6);
}

TEST_F(CsgTest, CSGIntersectNonOverlappingBrushes)
{
    loadMap("csg_intersect.map");

    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Find brush "1" and the non-overlapping brush "3"
    auto firstBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto nonOverlappingBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "3");

    ASSERT_TRUE(firstBrush != nullptr);
    ASSERT_TRUE(nonOverlappingBrush != nullptr);

    // Select the brushes
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(firstBrush, true);
    Node_setSelected(nonOverlappingBrush, true);

    // CSG intersect - should fail silently because brushes don't overlap
    GlobalCommandSystem().executeCommand("CSGIntersect");

    // The original brushes should still exist (operation failed, no changes)
    ASSERT_TRUE(firstBrush->getParent() != nullptr);
    ASSERT_TRUE(nonOverlappingBrush->getParent() != nullptr);
}

TEST_F(CsgTest, CSGIntersectContainedBrush)
{
    loadMap("csg_intersect.map");

    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Find brush "1" (large) and brush "4" (small, contained within "1")
    auto largeBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    auto smallBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "4");

    ASSERT_TRUE(largeBrush != nullptr);
    ASSERT_TRUE(smallBrush != nullptr);
    ASSERT_TRUE(Node_getIBrush(largeBrush)->getNumFaces() == 6);
    ASSERT_TRUE(Node_getIBrush(smallBrush)->getNumFaces() == 6);

    // Select the brushes
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(largeBrush, true);
    Node_setSelected(smallBrush, true);

    // CSG intersect
    GlobalCommandSystem().executeCommand("CSGIntersect");

    // The two brushes should be gone
    ASSERT_TRUE(largeBrush->getParent() == nullptr);
    ASSERT_TRUE(smallBrush->getParent() == nullptr);

    // The result should be a brush equal in size to the small brush
    // The result will have material "4" since those faces define the intersection volume
    auto resultBrush = algorithm::findFirstBrushWithMaterial(worldspawn, "4");
    ASSERT_TRUE(resultBrush != nullptr);
    ASSERT_TRUE(Node_getIBrush(resultBrush)->getNumFaces() == 6);
}

TEST_F(CsgTest, CSGIntersectRequiresTwoBrushes)
{
    loadMap("csg_intersect.map");

    auto worldspawn = GlobalMapModule().getWorldspawn();

    // Find just one brush
    auto brush = algorithm::findFirstBrushWithMaterial(worldspawn, "1");
    ASSERT_TRUE(brush != nullptr);

    // Select only one brush
    GlobalSelectionSystem().setSelectedAll(false);
    Node_setSelected(brush, true);

    // CSG intersect - should fail silently because we need at least 2 brushes
    GlobalCommandSystem().executeCommand("CSGIntersect");

    // The original brush should still exist (operation failed, no changes)
    ASSERT_TRUE(brush->getParent() != nullptr);
}

}