/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2006 Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: noding/snapround/HotPixel.java r320 (JTS-1.12)
 *
 **********************************************************************/

#include <geos/algorithm/CGAlgorithmsDD.h>
#include <geos/algorithm/LineIntersector.h>
#include <geos/noding/NodedSegmentString.h>
#include <geos/geom/Coordinate.h>
#include <geos/noding/snapround/HotPixel.h>
#include <geos/io/WKTWriter.h>

#include <algorithm> // for std::min and std::max
#include <cassert>
#include <memory>

using namespace geos::algorithm;
using namespace geos::geom;

namespace geos {
namespace noding { // geos.noding
namespace snapround { // geos.noding.snapround

/*public*/
const geom::CoordinateXYZM&
HotPixel::getCoordinate() const
{
    return originalPt;
}

/* public */
bool
HotPixel::intersects(const CoordinateXY& p) const
{
    double x = scale(p.x);
    double y = scale(p.y);
    if (x >= hpx + TOLERANCE) return false;
    // check Left side
    if (x < hpx - TOLERANCE) return false;
    // check Top side
    if (y >= hpy + TOLERANCE) return false;
    // check Bottom side
    if (y < hpy - TOLERANCE) return false;
    // finally
    return true;
}

/*public*/
bool
HotPixel::intersects(const CoordinateXY& p0,
                     const CoordinateXY& p1) const
{
    if(scaleFactor == 1.0) {
        return intersectsScaled(p0.x, p0.y, p1.x, p1.y);
    }

    double sp0x = scale(p0.x);
    double sp0y = scale(p0.y);
    double sp1x = scale(p1.x);
    double sp1y = scale(p1.y);
    return intersectsScaled(sp0x, sp0y, sp1x, sp1y);
}

/*private*/
bool
HotPixel::intersectsScaled(double p0x, double p0y, double p1x, double p1y) const
{
    // determine oriented segment pointing in positive X direction
    double px = p0x;
    double py = p0y;
    double qx = p1x;
    double qy = p1y;
    if (px > qx) {
        px = p1x;
        py = p1y;
        qx = p0x;
        qy = p0y;
    }

    /**
    * Report false if segment env does not intersect pixel env.
    * This check reflects the fact that the pixel Top and Right sides
    * are open (not part of the pixel).
    */
    // check Right side
    double maxx = hpx + TOLERANCE;
    double segMinx = std::min(px, qx);
    if (segMinx >= maxx) return false;
    // check Left side
    double minx = hpx - TOLERANCE;
    double segMaxx = std::max(px, qx);
    if (segMaxx < minx) return false;
    // check Top side
    double maxy = hpy + TOLERANCE;
    double segMiny = std::min(py, qy);
    if (segMiny >= maxy) return false;
    // check Bottom side
    double miny = hpy - TOLERANCE;
    double segMaxy = std::max(py, qy);
    if (segMaxy < miny) return false;

    /**
    * Vertical or horizontal segments must now intersect
    * the segment interior or Left or Bottom sides.
    */
    // check vertical segment
    if (px == qx) {
        return true;
    }
    // check horizontal segment
    if (py == qy) {
        return true;
    }

    /**
    * Now know segment is not horizontal or vertical.
    *
    * Compute orientation WRT each pixel corner.
    * If corner orientation == 0,
    * segment intersects the corner.
    * From the corner and whether segment is heading up or down,
    * can determine intersection or not.
    *
    * Otherwise, check whether segment crosses interior of pixel side
    * This is the case if the orientations for each corner of the side are different.
    */
    int orientUL = CGAlgorithmsDD::orientationIndex(px, py, qx, qy, minx, maxy);
    if (orientUL == 0) {
        // upward segment does not intersect pixel interior
        if (py < qy) return false;
        // downward segment must intersect pixel interior
        return true;
    }

    int orientUR = CGAlgorithmsDD::orientationIndex(px, py, qx, qy, maxx, maxy);
    if (orientUR == 0) {
        // downward segment does not intersect pixel interior
        if (py > qy) return false;
        // upward segment must intersect pixel interior
        return true;
    }
    // check crossing Top side
    if (orientUL != orientUR) {
        return true;
    }

    int orientLL = CGAlgorithmsDD::orientationIndex(px, py, qx, qy, minx, miny);
    if (orientLL == 0) {
        // LL corner is the only one in pixel interior
        return true;
    }
    // check crossing Left side
    if (orientLL != orientUL) {
        return true;
    }

    int orientLR = CGAlgorithmsDD::orientationIndex(px, py, qx, qy, maxx, miny);
    if (orientLR == 0) {
        // upward segment does not intersect pixel interior
        if (py < qy) return false;
        // downward segment must intersect pixel interior
        return true;
    }

    // check crossing Bottom side
    if (orientLL != orientLR) {
        return true;
    }
    // check crossing Right side
    if (orientLR != orientUR) {
        return true;
    }

    // segment does not intersect pixel
    return false;
}

/*private*/
bool
HotPixel::intersectsPixelClosure(const Coordinate& p0, const Coordinate& p1) const
{
    LineIntersector li;
    std::array<Coordinate, 4> corner;

    double minx = hpx - TOLERANCE;
    double maxx = hpx + TOLERANCE;
    double miny = hpy - TOLERANCE;
    double maxy = hpy + TOLERANCE;

    corner[UPPER_RIGHT] = Coordinate(maxx, maxy);
    corner[UPPER_LEFT]  = Coordinate(minx, maxy);
    corner[LOWER_LEFT]  = Coordinate(minx, miny);
    corner[LOWER_RIGHT] = Coordinate(maxx, miny);

    li.computeIntersection(p0, p1, corner[UPPER_RIGHT], corner[UPPER_LEFT]);
    if (li.hasIntersection()) {
        return true;
    }
    li.computeIntersection(p0, p1, corner[UPPER_LEFT], corner[LOWER_LEFT]);
    if (li.hasIntersection()) {
        return true;
    }
    li.computeIntersection(p0, p1, corner[LOWER_LEFT], corner[LOWER_RIGHT]);
    if (li.hasIntersection()) {
        return true;
    }
    li.computeIntersection(p0, p1, corner[LOWER_RIGHT], corner[UPPER_RIGHT]);
    if (li.hasIntersection()) {
        return true;
    }

    return false;
}


std::ostream&
HotPixel::operator<< (std::ostream& os)
{
    os << "HP(" << io::WKTWriter::toPoint(originalPt) << ")";
    return os;
}


} // namespace geos.noding.snapround
} // namespace geos.noding
} // namespace geos