/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (c) 2025 Martin Davis
 * Copyright (C) 2025 Paul Ramsey <pramsey@cleverelephant.ca>
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************/

#pragma once

#include <geos/geom/Envelope.h>
#include <geos/constants.h>
#include <geos/index/quadtree/Quadtree.h>

#include <vector>
#include <memory>

// Forward declarations
namespace geos {
namespace geom {
    class Geometry;
    class GeometryFactory;
    class LineString;
    class LinearRing;
    class Polygon;
}
namespace operation {
namespace relateng {
    class RelateNG;
}
}
namespace index {
namespace quadtree {
}
}
}


namespace geos {     // geos.
namespace coverage { // geos.coverage

class CleanCoverage {

    using Envelope = geos::geom::Envelope;
    using Geometry = geos::geom::Geometry;
    using GeometryFactory = geos::geom::GeometryFactory;
    using LineString = geos::geom::LineString;
    using LinearRing = geos::geom::LinearRing;
    using Polygon = geos::geom::Polygon;
    using RelateNG = geos::operation::relateng::RelateNG;
    using Quadtree = geos::index::quadtree::Quadtree;


public:

    // Classes

    class CleanArea {

    private:

        // Members
        std::vector<const Polygon*> polys;
        Envelope env;

    public:

        // Methods
        void add(const Polygon* poly);
        const Envelope* getEnvelope();
        double getBorderLength(const Polygon* adjPoly);
        double getArea();
        bool isAdjacent(RelateNG& rel);
        std::unique_ptr<Geometry> getUnion();

    }; // CleanArea


    class MergeStrategy {

    public:

        virtual ~MergeStrategy() = default;

        virtual std::size_t getTarget() const = 0;

        virtual void checkMergeTarget(
            std::size_t areaIndex,
            CleanArea* cleanArea,
            const Polygon* poly) = 0;

    }; // MergeStrategy


    class BorderMergeStrategy : public MergeStrategy {

    private:

        std::size_t m_targetIndex = INDEX_UNKNOWN;
        double m_targetBorderLen;

    public:

        BorderMergeStrategy() {};

        std::size_t getTarget()  const override {
            return m_targetIndex;
        };

        void checkMergeTarget(std::size_t areaIndex, CleanArea* area, const Polygon* poly) override {
            double borderLen = area == nullptr ? 0.0 : area->getBorderLength(poly);
            if (m_targetIndex == INDEX_UNKNOWN || borderLen > m_targetBorderLen) {
                m_targetIndex = areaIndex;
                m_targetBorderLen = borderLen;
            }
        };

    }; // BorderStrategy


    class AreaMergeStrategy : public MergeStrategy {

    private:

        std::size_t m_targetIndex = INDEX_UNKNOWN;
        double m_targetArea;
        bool m_isMax;

    public:

        AreaMergeStrategy(bool isMax) : m_isMax(isMax) {};

        std::size_t getTarget() const override {
            return m_targetIndex;
        }

        void checkMergeTarget(std::size_t areaIndex, CleanArea* area, const Polygon* poly) override {
            (void)poly;
            double areaVal = area == nullptr ? 0.0 : area->getArea();
            bool isBetter = m_isMax
                ? areaVal > m_targetArea
                : areaVal < m_targetArea;
            if (m_targetIndex == INDEX_UNKNOWN || isBetter) {
                m_targetIndex = areaIndex;
                m_targetArea = areaVal;
            }
        }

    }; // AreaMergeStrategy


    class IndexMergeStrategy : public MergeStrategy {

    private:

        std::size_t m_targetIndex = INDEX_UNKNOWN;
        bool m_isMax;

    public:

        IndexMergeStrategy(bool isMax) : m_isMax(isMax) {};

        std::size_t getTarget()  const override {
            return m_targetIndex;
        }

        void checkMergeTarget(std::size_t areaIndex, CleanArea* area, const Polygon* poly) override {
            (void)area;
            (void)poly;
            bool isBetter = m_isMax
                ? areaIndex > m_targetIndex
                : areaIndex < m_targetIndex;
            if (isBetter) {
                m_targetIndex = areaIndex;
            }
        }
    }; // MergeStrategy


private:

    // Members

    /**
     * The areas in the clean coverage.
     * Entries may be null, if no resultant corresponded to the input area.
     */
    std::vector<std::unique_ptr<CleanArea>> cov;
    //-- used for finding areas to merge gaps
    std::unique_ptr<Quadtree> covIndex = nullptr;

    void mergeGap(const Polygon* gap);

    CleanArea* findMaxBorderLength(const Polygon* poly, std::vector<CleanArea*>& areas);

    std::vector<CleanArea*> findAdjacentAreas(const Geometry* poly);

    void createIndex();


public:

    // Methods

    CleanCoverage(std::size_t size);

    void add(std::size_t i, const Polygon* poly);

    void mergeOverlap(const Polygon* overlap,
        MergeStrategy& mergeStrategy,
        std::vector<std::size_t>& parentIndexes);

    static std::size_t findMergeTarget(const Polygon* poly,
        MergeStrategy& strategy,
        std::vector<std::size_t>& parentIndexes,
        std::vector<std::unique_ptr<CleanArea>>& cov);

    void mergeGaps(std::vector<const Polygon*>& gaps);

    std::vector<std::unique_ptr<Geometry>> toCoverage(const GeometryFactory* geomFactory);

    /**
     * Disable copy construction and assignment. Apparently needed to make this
     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
     */
    CleanCoverage(const CleanCoverage&) = delete;
    CleanCoverage& operator=(const CleanCoverage&) = delete;


};

} // namespace geos.coverage
} // namespace geos