/**********************************************************************

 *

 * GEOS - Geometry Engine Open Source

 * http://geos.osgeo.org

 *

 * Copyright (C) 2021 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/export.h>

#include <geos/operation/buffer/BufferParameters.h>

#include <geos/geom/GeometryFactory.h>

#include <geos/constants.h>

// Forward declarations

namespace geos {

namespace geom {

class Coordinate;

class CoordinateSequence;

class Geometry;

class LineString;

class Polygon;

}

namespace operation {

namespace buffer {

class OffsetCurveSection;

class SegmentMCIndex;

}

}

}

namespace geos {

namespace operation {

namespace buffer {

/**

 * Computes an offset curve from a geometry.

 * An offset curve is a linear geometry which is offset a given distance

 * from the input.

 * If the offset distance is positive the curve lies on the left side of the input;

 * if it is negative the curve is on the right side.

 * The curve(s) have the same direction as the input line(s).

 *

 * The offset curve is based on the boundary of the buffer for the geometry

 * at the offset distance (see BufferOp).

 * The normal mode of operation is to return the sections of the buffer boundary

 * which lie on the raw offset curve

 * (obtained via rawOffset(LineString, double).

 * The offset curve will contain multiple sections

 * if the input self-intersects or has close approaches.

 * The computed sections are ordered along the raw offset curve.

 * Sections are disjoint.  They never self-intersect, but may be rings.

 *

 *   * For a LineString the offset curve is a linear geometry

 *     (LineString or MultiLineString).

 *   * For a Point or MultiPoint the offset curve is an empty LineString.

 *   * For a Polygon the offset curve is the boundary of the polygon buffer (which

 *     may be a MultiLineString.

 *   * For a collection the output is a MultiLineString containing

 *     the offset curves of the elements.

 *

 * In "joined" mode (see setJoined(bool))

 * the sections computed for each input line are joined into a single offset curve line.

 * The joined curve may self-intersect.

 * At larger offset distances the curve may contain "flat-line" artifacts

 * in places where the input self-intersects.

 *

 * Offset curves support setting the number of quadrant segments,

 * the join style, and the mitre limit (if applicable) via

 * the BufferParameters.

 *

 * @author Martin Davis

 *

 */

class GEOS_DLL OffsetCurve {

    using Coordinate = geos::geom::Coordinate;

    using CoordinateSequence = geos::geom::CoordinateSequence;

    using Geometry = geos::geom::Geometry;

    using GeometryFactory = geos::geom::GeometryFactory;

    using LineString = geos::geom::LineString;

    using Polygon = geos::geom::Polygon;

private:

    // Members

    const Geometry& inputGeom;

    double distance;

    bool isJoined = false;

    BufferParameters bufferParams;

    double matchDistance;

    const GeometryFactory* geomFactory;

    // Methods

    std::unique_ptr<Geometry> computePolygonCurve(

        const Polygon& polyGeom, double distance);

    std::unique_ptr<Geometry> computeCurve(

        const LineString& lineGeom, double distance);

    std::vector<std::unique_ptr<OffsetCurveSection>> computeSections(

        const LineString& lineGeom, double distance);

    std::unique_ptr<LineString> offsetSegment(

        const CoordinateSequence* pts, double distance);

    static std::unique_ptr<Polygon> getBufferOriented(

        const LineString& geom, double distance,

        BufferParameters& bufParams);

    /**

    * Extracts the largest polygon by area from a geometry.

    * Used here to avoid issues with non-robust buffer results

    * which have spurious extra polygons.

    *

    * @param geom a geometry

    * @return the polygon element of largest area

    */

    static const Polygon* extractMaxAreaPolygon(const Geometry* geom);

    void computeCurveSections(

        const CoordinateSequence* bufferRingPts,

        const CoordinateSequence& rawCurve,

        std::vector<std::unique_ptr<OffsetCurveSection>>& sections);

    /**

    * Matches the segments in a buffer ring to the raw offset curve

    * to obtain their match positions (if any).

    *

    * @param raw0 a raw curve segment start point

    * @param raw1 a raw curve segment end point

    * @param rawCurveIndex the index of the raw curve segment

    * @param bufferSegIndex the spatial index of the buffer ring segments

    * @param bufferPts the points of the buffer ring

    * @param rawCurvePos the raw curve positions of the buffer ring segments

    * @return the index of the minimum matched buffer segment

    */

    std::size_t matchSegments(

        const Coordinate& raw0, const Coordinate& raw1,

        std::size_t rawCurveIndex,

        SegmentMCIndex& bufferSegIndex,

        const CoordinateSequence* bufferPts,

        std::vector<double>& rawCurvePos);

    static double segmentMatchFrac(

        const Coordinate& p0,   const Coordinate& p1,

        const Coordinate& seg0, const Coordinate& seg1,

        double matchDistance);

    /**

    * This is only called when there is at least one ring segment matched

    * (so rawCurvePos has at least one entry != NOT_IN_CURVE).

    * The start index of the first section must be provided.

    * This is intended to be the section with lowest position

    * along the raw curve.

    * @param ringPts the points in a buffer ring

    * @param rawCurveLoc the position of buffer ring segments along the raw curve

    * @param startIndex the index of the start of a section

    * @param sections the list of extracted offset curve sections

    */

    void extractSections(

        const CoordinateSequence* ringPts,

        std::vector<double>& rawCurveLoc,

        std::size_t startIndex,

        std::vector<std::unique_ptr<OffsetCurveSection>>& sections);

    std::size_t findSectionStart(

        const std::vector<double>& loc,

        std::size_t end);

    std::size_t findSectionEnd(

        const std::vector<double>& loc,

        std::size_t start,

        std::size_t firstStartIndex);

    static std::size_t nextIndex(std::size_t i, std::size_t size);

    static std::size_t prevIndex(std::size_t i, std::size_t size);

public:

    // Constants

    static constexpr int MATCH_DISTANCE_FACTOR = 10000;

    /**

    * A QuadSegs minimum value that will prevent generating

    * unwanted offset curve artifacts near end caps.

    */

    static constexpr int MIN_QUADRANT_SEGMENTS = 8;

    /**

    * Creates a new instance for computing an offset curve for a geometry at a given distance.

    * with default quadrant segments (BufferParameters::DEFAULT_QUADRANT_SEGMENTS)

    * and join style (BufferParameters::JOIN_STYLE).

    *

    * @param geom the geometry to offset

    * @param dist the offset distance (positive for left, negative for right)

    *

    * @see BufferParameters

    */

    OffsetCurve(const Geometry& geom, double dist)

        : inputGeom(geom)

        , distance(dist)

        , matchDistance(std::abs(dist)/MATCH_DISTANCE_FACTOR)

        , geomFactory(geom.getFactory())

        {

            if (!std::isfinite(dist)) {

                throw util::IllegalArgumentException("OffsetCurve distance must be a finite value");

            }

        };

    /**

    * Creates a new instance for computing an offset curve for a geometry at a given distance.

    * setting the quadrant segments and join style and mitre limit

    * via {@link BufferParameters}.

    *

    * @param geom the geometry to offset

    * @param dist the offset distance (positive for left, negative for right)

    * @param bp the buffer parameters to use

    */

    OffsetCurve(const Geometry& geom, double dist, BufferParameters& bp)

        : inputGeom(geom)

        , distance(dist)

        , matchDistance(std::abs(dist)/MATCH_DISTANCE_FACTOR)

        , geomFactory(geom.getFactory())

        {

            if (!std::isfinite(dist)) {

                throw util::IllegalArgumentException("OffsetCurve distance must be a finite value");

            }

            //-- set buffer params, leaving cap style as the default CAP_ROUND

            /**

            * Prevent using a very small QuadSegs value, to avoid

            * offset curve artifacts near the end caps.

            */

            int quadSegs = bp.getQuadrantSegments();

            if (quadSegs < MIN_QUADRANT_SEGMENTS) {

                quadSegs = MIN_QUADRANT_SEGMENTS;

            }

            bufferParams.setQuadrantSegments(quadSegs);

            bufferParams.setJoinStyle( bp.getJoinStyle());

            bufferParams.setMitreLimit( bp.getMitreLimit());

        };

    /**

    * Computes a single curve line for each input linear component,

    * by joining curve sections in order along the raw offset curve.

    * The default mode is to compute separate curve sections.

    *

    * @param pIsJoined true if joined mode should be used.

    */

    void setJoined(bool pIsJoined);

    static std::unique_ptr<Geometry> getCurve(

        const Geometry& geom,

        double dist,

        int quadSegs,

        BufferParameters::JoinStyle joinStyle,

        double mitreLimit);

    static std::unique_ptr<Geometry> getCurve(

        const Geometry& geom, double dist);

    /**

    * Computes the offset curve of a geometry at a given distance,

    * joining curve sections into a single line for each input line.

    *

    * @param geom a geometry

    * @param dist the offset distance (positive for left, negative for right)

    * @return the joined offset curve

    */

    static std::unique_ptr<Geometry> getCurveJoined(

        const Geometry& geom, double dist);

    /**

    * Gets the computed offset curve lines.

    *

    * @return the offset curve geometry

    */

    std::unique_ptr<Geometry> getCurve();

    /**

    * Gets the raw offset curve for a line at a given distance.

    * The quadrant segments, join style and mitre limit can be specified

    * via BufferParameters.

    *

    * The raw offset line may contain loops and other artifacts which are

    * not present in the true offset curve.

    *

    * @param line the line to offset

    * @param distance the offset distance (positive for left, negative for right)

    * @param bufParams the buffer parameters to use

    * @return the raw offset curve points

    */

    static std::unique_ptr<CoordinateSequence> rawOffsetCurve(

        const LineString& line,

        double distance,

        BufferParameters& bufParams);

    /**

    * Gets the raw offset curve for a line at a given distance,

    * with default buffer parameters.

    *

    * @param line the line to offset

    * @param distance the offset distance (positive for left, negative for right)

    * @return the raw offset curve points

    */

    static std::unique_ptr<CoordinateSequence> rawOffset(

        const LineString& line,

        double distance);

};

} // namespace geos::operation::buffer

} // namespace geos::operation

} // namespace geos