Topology.h

// This file is part of Topologic software library.
// Copyright(C) 2019, Cardiff University and University College London
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

#pragma once

#include "TopologicalQuery.h"

#include <TopologicCore/include/Topology.h>

#pragma make_public(TopologicCore::Topology)
#pragma make_public(TopologicCore::TopologyPtr)

using namespace System;
using namespace System::Collections::Generic;

#ifdef TOPOLOGIC_DYNAMO
using namespace Autodesk::DesignScript::Runtime;
#endif

namespace Topologic
{
    ref class Aperture;
    ref class CellComplex;
    ref class Cell;
    ref class Shell;
    ref class Face;
    ref class Wire;
    ref class Edge;
    ref class Vertex;
    ref class Context;

    namespace Factories
    {
        ref class TopologyFactory;
    }

    public ref class Topology abstract : public TopologicalQuery
    {
    public:
#ifdef TOPOLOGIC_DYNAMO
        static Topology^ ByGeometry(Autodesk::DesignScript::Geometry::Geometry^ geometry, [DefaultArgument("0.0001")] double tolerance);

        [IsVisibleInDynamoLibrary(false)]
        static Topology^ ByPolySurface(Autodesk::DesignScript::Geometry::PolySurface^ polySurface);

        [IsVisibleInDynamoLibrary(false)]
        static Topology^ ByFaces(System::Collections::Generic::IEnumerable<Face^>^ faces);
#endif

        static List<Topology^>^ ByVerticesIndices(System::Collections::Generic::IEnumerable<Vertex^>^ vertices, System::Collections::Generic::IEnumerable<System::Collections::Generic::List<int>^>^ vertexIndices);

        property int Dimensionality
        {
            int get();
        }

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        property Object^ BasicGeometry
        {
            virtual Object^ get() abstract;
        }

        property Object^ Geometry
        {
            virtual Object^ get();
        }

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        Topology^ AddAttributesNoCopy(Dictionary<String^, Object^>^ attributes);

        property List<Topology^>^ Contents
        {
            List<Topology^>^ get();
        }

        property List<Aperture^>^ Apertures
        {
            List<Aperture^>^ get();
        }

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        property List<Topology^>^ SubContents
        {
            List<Topology^>^ get();
        }

        property List<Context^>^ Contexts
        {
            List<Context^>^ get();
        }

        /*/// <summary>
        Topology^ AddContent(Topology^ topology);*/
        
#ifdef TOPOLOGIC_DYNAMO
        Topology^ AddContents(List<Topology^>^ contentTopologies, [DefaultArgument("0")] int typeFilter);
#else
        Topology^ AddContents(List<Topology^>^ contentTopologies, int typeFilter);
#endif

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        Topology^ RemoveContent(Topology^ contentTopology);

        Topology^ RemoveContents(List<Topology^>^ contentTopologies);

        /*/// <summary>
        Topology^ RemoveContexts(List<Context^>^ contexts);*/

        Topology^ AddApertures(System::Collections::Generic::IEnumerable<Topology^>^ apertureTopologies);

        /*/// <summary>
        Topology^ AddContexts(List<Context^>^ contexts);*/

        /*/// <summary>
#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        Topology^ RemoveContext(Context^ context);*/

        List<Topology^>^ SharedTopologies(
            Topology^ topology, 
#ifdef TOPOLOGIC_DYNAMO
            [Autodesk::DesignScript::Runtime::DefaultArgument("255")] 
#endif
            int typeFilter);

        Topology^ Difference(Topology^ topology);

        Topology^ Impose(Topologic::Topology^ tool);

        Topology^ Imprint(Topology^ tool);

        Topology^ Intersect(Topology^ topology);

        Topology^ Merge(Topology^ topology);

        Topology^ SelfMerge();

        Topology^ Slice(Topology^ tool);

        Topology^ Divide(Topology^ tool);

        Topology^ Union(Topology^ topology);

        Topology^ XOR(Topology^ topology);

        property Vertex^ CenterOfMass
        {
            Vertex^ get();
        }

        property Vertex^ Centroid
        {
            Vertex^ get();
        }

        bool ExportToBRep(String^ path);

        static Topology^ ByImportedBRep(String^ path);

        String^ Analyze();

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        property bool IsReversed
        {
            bool get();
        }

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        property List<Topology^>^ SubTopologies
        {
            List<Topology^>^ get();
        }

        property List<Shell^>^ Shells
        {
            List<Shell^>^ get();
        }

        property List<Face^>^ Faces
        {
            List<Face^>^ get();
        }

        property List<Wire^>^ Wires
        {
            List<Wire^>^ get();
        }

        property List<Edge^>^ Edges
        {
            List<Edge^>^ get();
        }

        property List<Vertex^>^ Vertices
        {
            List<Vertex^>^ get();
        }

        property List<Cell^>^ Cells
        {
            List<Cell^>^ get();
        }

        property List<CellComplex^>^ CellComplexes
        {
            List<CellComplex^>^ get();
        }

        bool IsSame(Topology^ topology);

        Topology^ ClosestSimplestSubshape(Topology^ selector);

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
        Topology^ SelectSubtopology(Vertex^ selector,
            [Autodesk::DesignScript::Runtime::DefaultArgument("255")] int typeFilter);
#else
        Topology^ SelectSubtopology(Vertex^ selector, int typeFilter);
#endif
        
        generic <class T>
        where T: Topology
#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        T Copy();

        Topology^ ShallowCopy();

        property String^ TypeAsString
        {
            String^ get();
        }

        property int Type
        {
            int get();
        }

        static List<Topology^>^ Filter(List<Topology^>^ topologies, int typeFilter);

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        void RegisterFactory(const TopologicCore::Topology::Ptr& kpCoreTopology, Factories::TopologyFactory^ topologyFactory);

#ifdef TOPOLOGIC_DYNAMO
        [IsVisibleInDynamoLibrary(false)]
#endif
        void RegisterFactory(String^ rkGUID, Factories::TopologyFactory^ topologyFactory);

        Topology^ SetDictionary(Dictionary<String^, Object^>^ dictionary);

        Topology^ SetDictionaries(List<Vertex^>^ selectors, List<Dictionary<String^, Object^>^>^ dictionaries, 
#ifdef TOPOLOGIC_DYNAMO
            [Autodesk::DesignScript::Runtime::DefaultArgument("255")]
#endif
        int typeFilter);

        property System::Collections::Generic::Dictionary<String^, Object^>^ Dictionary
        {
            System::Collections::Generic::Dictionary<String^, Object^>^ get();
        }

    public protected:
        static Topology^ ByCoreTopology(const std::shared_ptr<TopologicCore::Topology>& kpCoreTopology);

        Object^ CleanupGeometryOutput(List<Object^>^ geometry);

    protected:
        Topology();
        virtual ~Topology();
    };
}