/*******************************************************************************
 * Copyright (c) 2015 Voyager Search and MITRE
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Apache License, Version 2.0 which
 * accompanies this distribution and is available at
 *    http://www.apache.org/licenses/LICENSE-2.0.txt
 ******************************************************************************/

package org.locationtech.spatial4j.shape.impl;

import org.locationtech.spatial4j.context.SpatialContext;
import org.locationtech.spatial4j.distance.DistanceUtils;
import org.locationtech.spatial4j.shape.Point;
import org.locationtech.spatial4j.shape.Rectangle;
import org.locationtech.spatial4j.shape.SpatialRelation;

import java.util.Formatter;
import java.util.Locale;

/**
 * A circle as it exists on the surface of a sphere.
 */
public class GeoCircle extends CircleImpl {
  private GeoCircle inverseCircle;//when distance reaches > 1/2 way around the world, cache the inverse.
  private double horizAxisY;//see getYAxis

  public GeoCircle(Point p, double radiusDEG, SpatialContext ctx) {
    super(p, radiusDEG, ctx);
    assert ctx.isGeo();
    init();
  }

  @Override
  public void reset(double x, double y, double radiusDEG) {
    super.reset(x, y, radiusDEG);
    init();
  }

  private void init() {
    if (radiusDEG > 90) {
      //--spans more than half the globe
      assert enclosingBox.getWidth() == 360;
      double backDistDEG = 180 - radiusDEG;
      if (backDistDEG > 0) {
        double backRadius = 180 - radiusDEG;
        double backX = DistanceUtils.normLonDEG(getCenter().getX() + 180);
        double backY = DistanceUtils.normLatDEG(getCenter().getY() + 180);
        //Shrink inverseCircle as small as possible to avoid accidental overlap.
        // Note that this is tricky business to come up with a value small enough
        // but not too small or else numerical conditioning issues become a problem.
        backRadius -= Math.max(Math.ulp(Math.abs(backY)+backRadius), Math.ulp(Math.abs(backX)+backRadius));
        if (inverseCircle != null) {
          inverseCircle.reset(backX, backY, backRadius);
        } else {
          inverseCircle = new GeoCircle(ctx.makePoint(backX, backY), backRadius, ctx);
        }
      } else {
        inverseCircle = null;//whole globe
      }
      horizAxisY = getCenter().getY();//although probably not used
    } else {
      inverseCircle = null;
      double _horizAxisY = ctx.getDistCalc().calcBoxByDistFromPt_yHorizAxisDEG(getCenter(), radiusDEG, ctx);
      //some rare numeric conditioning cases can cause this to be barely beyond the box
      if (_horizAxisY > enclosingBox.getMaxY()) {
        horizAxisY = enclosingBox.getMaxY();
      } else if (_horizAxisY < enclosingBox.getMinY()) {
        horizAxisY = enclosingBox.getMinY();
      } else {
        horizAxisY = _horizAxisY;
      }
      //assert enclosingBox.relate_yRange(horizAxis,horizAxis,ctx).intersects();
    }
  }

  @Override
  protected double getYAxis() {
    return horizAxisY;
  }

  /**
   * Called after bounding box is intersected.
   * @param bboxSect INTERSECTS or CONTAINS from enclosingBox's intersection
   * @return DISJOINT, CONTAINS, or INTERSECTS (not WITHIN)
   */
  @Override
  protected SpatialRelation relateRectanglePhase2(Rectangle r, SpatialRelation bboxSect) {

    if (inverseCircle != null) {
      return inverseCircle.relate(r).inverse();
    }

    //if a pole is wrapped, we have a separate algorithm
    if (enclosingBox.getWidth() == 360) {
      return relateRectangleCircleWrapsPole(r, ctx);
    }

    //This is an optimization path for when there are no dateline or pole issues.
    if (!enclosingBox.getCrossesDateLine() && !r.getCrossesDateLine()) {
      return super.relateRectanglePhase2(r, bboxSect);
    }

    //Rectangle wraps around the world longitudinally creating a solid band; there are no corners to test intersection
    if (r.getWidth() == 360) {
      return SpatialRelation.INTERSECTS;
    }

    //do quick check to see if all corners are within this circle for CONTAINS
    int cornersIntersect = numCornersIntersect(r);
    if (cornersIntersect == 4) {
      //ensure r's x axis is within c's.  If it doesn't, r sneaks around the globe to touch the other side (intersect).
      SpatialRelation xIntersect = r.relateXRange(enclosingBox.getMinX(), enclosingBox.getMaxX());
      if (xIntersect == SpatialRelation.WITHIN)
        return SpatialRelation.CONTAINS;
      return SpatialRelation.INTERSECTS;
    }

    //INTERSECT or DISJOINT ?
    if (cornersIntersect > 0)
      return SpatialRelation.INTERSECTS;

    //Now we check if one of the axis of the circle intersect with r.  If so we have
    // intersection.

    /* x axis intersects  */
    if ( r.relateYRange(getYAxis(), getYAxis()).intersects() // at y vertical
          && r.relateXRange(enclosingBox.getMinX(), enclosingBox.getMaxX()).intersects() )
      return SpatialRelation.INTERSECTS;

    /* y axis intersects */
    if (r.relateXRange(getXAxis(), getXAxis()).intersects()) { // at x horizontal
      double yTop = getCenter().getY()+ radiusDEG;
      assert yTop <= 90;
      double yBot = getCenter().getY()- radiusDEG;
      assert yBot >= -90;
      if (r.relateYRange(yBot, yTop).intersects())//back bottom
        return SpatialRelation.INTERSECTS;
    }

    return SpatialRelation.DISJOINT;
  }

  private SpatialRelation relateRectangleCircleWrapsPole(Rectangle r, SpatialContext ctx) {
    //This method handles the case where the circle wraps ONE pole, but not both.  For both,
    // there is the inverseCircle case handled before now.  The only exception is for the case where
    // the circle covers the entire globe, and we'll check that first.
    if (radiusDEG == 180)//whole globe
      return SpatialRelation.CONTAINS;

    //Check if r is within the pole wrap region:
    double yTop = getCenter().getY() + radiusDEG;
    if (yTop > 90) {
      double yTopOverlap = yTop - 90;
      assert yTopOverlap <= 90;
      if (r.getMinY() >= 90 - yTopOverlap)
        return SpatialRelation.CONTAINS;
    } else {
      double yBot = point.getY() - radiusDEG;
      if (yBot < -90) {
        double yBotOverlap = -90 - yBot;
        assert yBotOverlap <= 90;
        if (r.getMaxY() <= -90 + yBotOverlap)
          return SpatialRelation.CONTAINS;
      } else {
        //This point is probably not reachable ??
        assert yTop == 90 || yBot == -90;//we simply touch a pole
        //continue
      }
    }

    //If there are no corners to check intersection because r wraps completely...
    if (r.getWidth() == 360)
      return SpatialRelation.INTERSECTS;

    //Check corners:
    int cornersIntersect = numCornersIntersect(r);
    // (It might be possible to reduce contains() calls within nCI() to exactly two, but this intersection
    //  code is complicated enough as it is.)
    double frontX = getCenter().getX();
    if (cornersIntersect == 4) {//all
      double backX = frontX <= 0 ? frontX + 180 : frontX - 180;
      if (r.relateXRange(backX, backX).intersects())
        return SpatialRelation.INTERSECTS;
      else
        return SpatialRelation.CONTAINS;
    } else if (cornersIntersect == 0) {//none
      if (r.relateXRange(frontX, frontX).intersects())
        return SpatialRelation.INTERSECTS;
      else
        return SpatialRelation.DISJOINT;
    } else//partial
      return SpatialRelation.INTERSECTS;
  }

  /** Returns either 0 for none, 1 for some, or 4 for all. */
  private int numCornersIntersect(Rectangle r) {
    //We play some logic games to avoid calling contains() which can be expensive.
    boolean bool;//if true then all corners intersect, if false then no corners intersect
    // for partial, we exit early with 1 and ignore bool.
    bool = (contains(r.getMinX(),r.getMinY()));
    if (contains(r.getMinX(),r.getMaxY())) {
      if (!bool)
        return 1;//partial
    } else {
      if (bool)
        return 1;//partial
    }
    if (contains(r.getMaxX(),r.getMinY())) {
      if (!bool)
        return 1;//partial
    } else {
      if (bool)
        return 1;//partial
    }
    if (contains(r.getMaxX(),r.getMaxY())) {
      if (!bool)
        return 1;//partial
    } else {
      if (bool)
        return 1;//partial
    }
    return bool?4:0;
  }

  @Override
  public String toString() {
    //Add distance in km, which may be easier to recognize.
    double distKm = DistanceUtils.degrees2Dist(radiusDEG,  DistanceUtils.EARTH_MEAN_RADIUS_KM);
    //instead of String.format() so that we get consistent output no matter the locale
    String dStr = new Formatter(Locale.ROOT).format("%.1f\u00B0 %.2fkm", radiusDEG, distKm).toString();
    return "Circle(" + point + ", d=" + dStr + ')';
  }
}
