#include <string>

#include "hoops_license.h"
#include "sc_store.h"
#include "sc_assemblytree.h"

class ApplicationLogger: public SC::Store::Logger {
public:
    virtual void
    Message(const char* message) const
    {
        printf("%s\n", message);
    }
};

static void
AddSquareFace(SC::Store::Mesh& mesh, uint32_t const* point_indices, uint32_t normal_index)
{
    mesh.face_elements.emplace_back();
    SC::Store::MeshElement& face = mesh.face_elements.back();

    // Add first face triangle
    for (size_t i = 0; i < 3; ++i) {
        face.indices.push_back(point_indices[i]);
        face.indices.push_back(normal_index);
    }

    // Add second face triangle
    for (size_t i = 0; i < 3; ++i) {
        face.indices.push_back(point_indices[(i + 2) % 4]);
        face.indices.push_back(normal_index);
    }

    mesh.polyline_elements.emplace_back();
    SC::Store::MeshElement& edges = mesh.polyline_elements.back();

    // Add face edges
    for (size_t i = 0; i < 5; ++i) {
        edges.indices.push_back(point_indices[i % 4]);
    }
}

static SC::Store::MeshKey
CreateCubeMesh(SC::Store::Model& model)
{
    using SC::Store::Mesh;

    Mesh mesh;
    mesh.flags = (Mesh::Bits)(Mesh::ClockwiseWinding | Mesh::FaceNormals | Mesh::Manifold);

    SC::Store::Point points[] = {
        { 0, 0, 1 }, // 0
        { 1, 0, 1 }, // 1
        { 0, 0, 0 }, // 2
        { 1, 0, 0 }, // 3
        { 1, 1, 1 }, // 4
        { 1, 1, 0 }, // 5
        { 0, 1, 1 }, // 6
        { 0, 1, 0 }, // 7
    };
    mesh.points      = points;
    mesh.point_count = 8;

    SC::Store::Normal normals[] = {
        { 0, -1, 0 }, // 0
        { 0, 0, 1 },  // 1
        { 0, 1, 0 },  // 2
        { 0, 0, -1 }, // 3
        { 1, 0, 0 },  // 4
        { -1, 0, 0 }, // 5
    };
    mesh.normals      = normals;
    mesh.normal_count = 6;

    {
        uint32_t point_indices[] = { 0, 1, 3, 2 };
        uint32_t normal_index    = 0;
        AddSquareFace(mesh, point_indices, normal_index);
    }
    {
        uint32_t point_indices[] = { 6, 4, 1, 0 };
        uint32_t normal_index    = 1;
        AddSquareFace(mesh, point_indices, normal_index);
    }
    {
        uint32_t point_indices[] = { 7, 5, 4, 6 };
        uint32_t normal_index    = 2;
        AddSquareFace(mesh, point_indices, normal_index);
    }
    {
        uint32_t point_indices[] = { 2, 3, 5, 7 };
        uint32_t normal_index    = 3;
        AddSquareFace(mesh, point_indices, normal_index);
    }
    {
        uint32_t point_indices[] = { 1, 4, 5, 3 };
        uint32_t normal_index    = 4;
        AddSquareFace(mesh, point_indices, normal_index);
    }
    {
        uint32_t point_indices[] = { 6, 0, 2, 7 };
        uint32_t normal_index    = 5;
        AddSquareFace(mesh, point_indices, normal_index);
    }

    return model.Insert(mesh);
}

int
CubesSampleLayersFilters(const std::string& model_path)
{
    std::string model_name = "cubes_sample_layers_filters";

    ApplicationLogger logger;

    try {
        // Open the cache.
        SC::Store::Database::SetLicense(HOOPS_LICENSE);
        SC::Store::Cache cache = SC::Store::Database::Open(logger);

        std::string file_path_string = model_path;
        file_path_string += "/";
        file_path_string += model_name;

        // Does the model in question exist?
        if (cache.Exists(file_path_string.c_str())) {
            printf("Model already exists.\n");
            return 1;
        }

        // Author assembly tree : Create root node.
        SC::Store::AssemblyTree assembly_tree(logger);
        uint32_t                root_id = 0;
        assembly_tree.CreateAssemblyTreeRoot(root_id);
        assembly_tree.SetNodeName(root_id, "cubes sample");

        // Create and open the model we care about.
        SC::Store::Model model = cache.Open(file_path_string.c_str());

        SC::Store::InclusionKey model_inclusion_key = model.Include(model);

        SC::Store::MeshKey mesh_key = CreateCubeMesh(model);
        {
            SC::Store::Matrix3d matrix = {
                1, 0, 0, //
                0, 1, 0, //
                0, 0, 1, //
                0, 0, 0, //
            };
            SC::Store::MatrixKey matrix_key = model.Insert(matrix);

            SC::Store::Color       color(1, 0, 0, 1);
            SC::Store::MaterialKey material_key = model.Insert(color);

            SC::Store::InstanceKey instance_key =
                model.Instance(mesh_key, matrix_key, material_key, material_key);

            // Author assembly tree : Create child node.
            uint32_t child_node = 0;
            assembly_tree.CreateChild(root_id, child_node);
            assembly_tree.SetNodeName(child_node, "first cube");
            // Create body instance node.
            uint32_t body_instance_node = 0;
            assembly_tree.CreateAndAddBodyInstance(child_node, body_instance_node);
            // Register mesh instance.
            assembly_tree.SetBodyInstanceMeshInstanceKey(
                body_instance_node, SC::Store::InstanceInc(model_inclusion_key, instance_key));
            // Register matrix.
            assembly_tree.SetNodeLocalTransform(child_node, matrix);

			//Add layer
			assembly_tree.AddLayerToNode(child_node, 1, "Layer 1");
			assembly_tree.SetNodeLayerId(body_instance_node, 1);
        }
        {
            SC::Store::Matrix3d matrix = {
                1,    0,    1.1f, //
                0.7f, 1,    0,    //
                0,    0.3f, 1,    //
                3,    0,    0,    //
            };
            SC::Store::MatrixKey matrix_key = model.Insert(matrix);

            SC::Store::Color       color(0, 1, 0, 1);
            SC::Store::MaterialKey material_key = model.Insert(color);

            SC::Store::InstanceKey instance_key =
                model.Instance(mesh_key, matrix_key, material_key, material_key);

            // Author assembly tree : Create child node.
            uint32_t child_node = 0;
            assembly_tree.CreateChild(root_id, child_node);
            assembly_tree.SetNodeName(child_node, "second cube");
            // Create body instance node.
            uint32_t body_instance_node = 0;
            assembly_tree.CreateAndAddBodyInstance(child_node, body_instance_node);
            // Register mesh instance.
            assembly_tree.SetBodyInstanceMeshInstanceKey(
                body_instance_node, SC::Store::InstanceInc(model_inclusion_key, instance_key));
            // Register matrix.
            assembly_tree.SetNodeLocalTransform(child_node, matrix);

			//Add layer
			assembly_tree.AddLayerToNode(child_node, 2, "Layer 2");
			assembly_tree.SetNodeLayerId(body_instance_node, 2);
        }
        {
            SC::Store::Matrix3d matrix = {
                1, 0, 0, //
                0, 2, 0, //
                0, 0, 3, //
                3, 2, 1, //
            };
            SC::Store::MatrixKey matrix_key = model.Insert(matrix);

            SC::Store::Color       color(0, 0, 1, 1);
            SC::Store::MaterialKey material_key = model.Insert(color);

            SC::Store::InstanceKey instance_key =
                model.Instance(mesh_key, matrix_key, material_key, material_key);

            // Author assembly tree : Create child node.
            uint32_t child_node = 0;
            assembly_tree.CreateChild(root_id, child_node);
            assembly_tree.SetNodeName(child_node, "third cube");

            // Create body instance node.
            uint32_t body_instance_node = 0;
            assembly_tree.CreateAndAddBodyInstance(child_node, body_instance_node);
            // Register mesh instance.
            assembly_tree.SetBodyInstanceMeshInstanceKey(
                body_instance_node, SC::Store::InstanceInc(model_inclusion_key, instance_key));
            // Register matrix.
            assembly_tree.SetNodeLocalTransform(child_node, matrix);

			//Add layer
			assembly_tree.AddLayerToNode(child_node, 3, "Layer 3");
			assembly_tree.SetNodeLayerId(body_instance_node, 3);
	
        }

		//Add filters
	    //Filter 1 for Layer 1 and Layer 2
		SC::Store::FilterData scFilterData1;
		scFilterData1.isDisplayFilter = true;
		scFilterData1.filterName = "Filter 1";
		scFilterData1.isActive = true;

		SC::Store::LayerFilterItemData&  scFilterLayers1 = scFilterData1.layerFilterItemData;
		scFilterLayers1.isInclusive = true;

		scFilterLayers1.layers.push_back(1);
		scFilterLayers1.layers.push_back(2);

		assembly_tree.AddFilterToNode(root_id, scFilterData1);

		//Filter 2 for Layer 2 and Layer 3
		SC::Store::FilterData scFilterData2;
		scFilterData2.isDisplayFilter = true;
		scFilterData2.filterName = "Filter 2";
		scFilterData2.isActive = false;

		SC::Store::LayerFilterItemData&  scFilterLayers2 = scFilterData2.layerFilterItemData;
		scFilterLayers2.isInclusive = true;

		scFilterLayers2.layers.push_back(2);
		scFilterLayers2.layers.push_back(3);
		
		assembly_tree.AddFilterToNode(root_id, scFilterData2);

        // Serialize authored content to model.
        assembly_tree.SerializeToModel(model);

        // Prepare the model for streaming.
        model.PrepareStream();
    } catch (std::exception const& e) {
        std::string message("Exception: ");
        message.append(e.what());
        message.append("\n");
        logger.Message(message.c_str());
        return 1;
    }

    return 0;
}