/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.geometry.euclidean.twod;
  
  import org.apache.commons.geometry.core.RegionLocation;
  import org.apache.commons.geometry.core.Transform;
  import org.apache.commons.geometry.core.partitioning.Split;
  import org.apache.commons.numbers.core.Precision;
  
  /** Class representing a line segment in 2D Euclidean space. A line segment is a portion of
   * a line with finite start and end points.
   *
   * <p>Instances of this class are guaranteed to be immutable.</p>
   * @see Lines
   * @see <a href="https://en.wikipedia.org/wiki/Line_segment">Line Segment</a>
   */
  public final class Segment extends LineConvexSubset {
  
      /** Start point for the segment. */
      private final Vector2D startPoint;
  
      /** End point for the segment. */
      private final Vector2D endPoint;
  
      /** Construct a new instance from a line and two points on the line. Callers are responsible for
       * ensuring that the given points lie on the line and are in order of increasing abscissa.
       * No validation is performed.
       * @param line line for the segment
       * @param startPoint segment start point
       * @param endPoint segment end point
       */
      Segment(final Line line, final Vector2D startPoint, final Vector2D endPoint) {
          super(line);
  
          this.startPoint = startPoint;
          this.endPoint = endPoint;
      }
  
      /** {@inheritDoc}
       *
       * <p>This method always returns {@code false}.</p>
       */
      @Override
      public boolean isFull() {
          return false;
      }
  
      /** {@inheritDoc}
       *
       * <p>This method always returns {@code false}.</p>
       */
      @Override
      public boolean isInfinite() {
          return false;
      }
  
      /** {@inheritDoc}
       *
       * <p>This method always returns {@code true}.</p>
       */
      @Override
      public boolean isFinite() {
          return true;
      }
  
      /** {@inheritDoc} */
      @Override
      public double getSize() {
          return startPoint.distance(endPoint);
      }
  
      /** {@inheritDoc} */
      @Override
      public Vector2D getCentroid() {
          return startPoint.lerp(endPoint, 0.5);
      }
  
      /** {@inheritDoc} */
      @Override
      public Vector2D getStartPoint() {
          return startPoint;
      }
  
      /** {@inheritDoc} */
      @Override
     public double getSubspaceStart() {
         return getLine().abscissa(startPoint);
     }
 
     /** {@inheritDoc} */
     @Override
     public Vector2D getEndPoint() {
         return endPoint;
     }
 
     /** {@inheritDoc} */
     @Override
     public double getSubspaceEnd() {
         return getLine().abscissa(endPoint);
     }
 
     /** {@inheritDoc} */
     @Override
     public Bounds2D getBounds() {
         return Bounds2D.builder()
                 .add(startPoint)
                 .add(endPoint)
                 .build();
     }
 
     /** {@inheritDoc} */
     @Override
     public Segment transform(final Transform<Vector2D> transform) {
         final Vector2D t1 = transform.apply(getStartPoint());
         final Vector2D t2 = transform.apply(getEndPoint());
 
         final Line tLine = getLine().transform(transform);
 
         return new Segment(tLine, t1, t2);
     }
 
     /** {@inheritDoc} */
     @Override
     public Segment reverse() {
         return new Segment(getLine().reverse(), endPoint, startPoint);
     }
 
     /** {@inheritDoc} */
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder();
         sb.append(getClass().getSimpleName())
             .append("[startPoint= ")
             .append(getStartPoint())
             .append(", endPoint= ")
             .append(getEndPoint())
             .append(']');
 
         return sb.toString();
     }
 
     /** {@inheritDoc} */
     @Override
     RegionLocation classifyAbscissa(final double abscissa) {
         final Precision.DoubleEquivalence precision = getPrecision();
         final int startCmp = precision.compare(abscissa, getSubspaceStart());
         if (startCmp > 0) {
             final int endCmp = precision.compare(abscissa, getSubspaceEnd());
             if (endCmp < 0) {
                 return RegionLocation.INSIDE;
             } else if (endCmp == 0) {
                 return RegionLocation.BOUNDARY;
             }
         } else if (startCmp == 0) {
             return RegionLocation.BOUNDARY;
         }
 
         return RegionLocation.OUTSIDE;
     }
 
     /** {@inheritDoc} */
     @Override
     double closestAbscissa(final double abscissa) {
         return Math.max(getSubspaceStart(), Math.min(getSubspaceEnd(), abscissa));
     }
 
     /** {@inheritDoc} */
     @Override
     Split<LineConvexSubset> splitOnIntersection(final Line splitter, final Vector2D intersection) {
         final Line line = getLine();
 
         final Precision.DoubleEquivalence splitterPrecision = splitter.getPrecision();
 
         final int startCmp = splitterPrecision.compare(splitter.offset(startPoint), 0.0);
         final int endCmp = splitterPrecision.compare(splitter.offset(endPoint), 0.0);
 
         if (startCmp == 0 && endCmp == 0) {
             // the entire segment is directly on the splitter line
             return new Split<>(null, null);
         } else if (startCmp < 1 && endCmp < 1) {
             // the entire segment is on the minus side
             return new Split<>(this, null);
         } else if (startCmp > -1 && endCmp > -1) {
             // the entire segment is on the plus side
             return new Split<>(null, this);
         }
 
         // we need to split the line
         final Segment startSegment = new Segment(line, startPoint, intersection);
         final Segment endSegment = new Segment(line, intersection, endPoint);
 
         final Segment minus = (startCmp > 0) ? endSegment : startSegment;
         final Segment plus = (startCmp > 0) ? startSegment : endSegment;
 
         return new Split<>(minus, plus);
     }
 }