Region.h

#ifndef _OVERSEER_REGION_H_
#define _OVERSEER_REGION_H_

#include <vector>
#include <queue>
#include <map>
#include <memory>
#include <iostream>
#include <algorithm>

#include "spatial/box_multimap.hpp"
#include "spatial/neighbor_iterator.hpp"
#include "spatial/ordered_iterator.hpp"
#include "sc2api/sc2_api.h"
#include "Tile.h"
#include "Region.h"

namespace Overseer{

    // class RegionEdge;

    typedef std::pair<sc2::Point2D, std::shared_ptr<Tile>> TilePosition;
    typedef std::pair<sc2::Point2D, sc2::Unit *> UnitPosition;
    typedef std::pair<sc2::Point2D, sc2::Point2D> PointPair;

    struct ComparePointPairs{
        bool operator()(const PointPair &l, const PointPair &r) const;
    };

    struct GreaterTile {
        bool operator()(std::shared_ptr<TilePosition> &a, std::shared_ptr<TilePosition> &b) const;
    };

    struct GreaterTileInstance {
        bool operator()(TilePosition &a, TilePosition &b) const;
    };


    enum EdgeType {
        cliff,
        impassible
    };

    class Region {
        public:

            Region();

            Region(size_t regionId, std::shared_ptr<TilePosition> tilePosition);

            size_t getArea() const;

            // std::vector<RegionEdge> getEdges();

            const std::vector<UnitPosition> getNeutralUnitPositions();

            size_t getId() const;

            void setId(size_t regionId);

            std::vector<TilePosition> getTilePositions() const;

            std::vector<sc2::Point2D> getPoints() const;

            void addTilePosition(std::shared_ptr<TilePosition> tilePosition);

            void addTilePosition(TilePosition& tilePosition);

            double getLargestDistanceToUnpathable() const;

            sc2::Point2D getMidPoint() const;

            void merge(Region region);

            void clear();

        private:
            std::vector<TilePosition> m_tilePositions;
            // std::vector<RegionEdge> m_edges;
            std::vector<UnitPosition> m_neutralUnitPositions;

            sc2::Point2D m_midPoint;

            std::map<PointPair, float, ComparePointPairs> m_pointDistances;

            float m_largestDistUnpathable;
            size_t m_id;
    };


    // TODO: Implement region edge.
    // class RegionEdge {
    //     public:
    //         //Returns the regions this edge separates
    //         const std::pair<const Region *, const Region *> & getRegions(){return m_regions;}
    //         const std::vector<TilePosition> getPoints(){return m_points;}
    //         EdgeType getEdgeType(){return m_edgeType;}
    //     private:
    //         std::pair<const Region *, const Region *> m_regions;
    //         std::vector<TilePosition> m_points;
    //         EdgeType m_edgeType;
    // };
}

#endif /* _OVERSEER_REGION_H_ */