# algorithms/distance.js

    "use strict";

    // let IntervalTree = require('flatten-interval-tree');
    import IntervalTree from '@flatten-js/interval-tree';
    import * as Intersection from '../algorithms/intersection';
    import Flatten from '../flatten';

    export class Distance {
        /**
         * Calculate distance and shortest segment between points
         * @param pt1
         * @param pt2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2point(pt1, pt2) {
            return pt1.distanceTo(pt2);
        }

        /**
         * Calculate distance and shortest segment between point and line
         * @param pt
         * @param line
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2line(pt, line) {
            let closest_point = pt.projectionOn(line);
            let vec = new Flatten.Vector(pt, closest_point);
            return [vec.length, new Flatten.Segment(pt, closest_point)];
        }

        /**
         * Calculate distance and shortest segment between point and circle
         * @param pt
         * @param circle
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2circle(pt, circle) {
            let [dist2center, shortest_dist] = pt.distanceTo(circle.center);
            if (Flatten.Utils.EQ_0(dist2center)) {
                return [circle.r, new Flatten.Segment(pt, circle.toArc().start)];
            } else {
                let dist = Math.abs(dist2center - circle.r);
                let v = new Flatten.Vector(circle.pc, pt).normalize().multiply(circle.r);
                let closest_point = circle.pc.translate(v);
                return [dist, new Flatten.Segment(pt, closest_point)];
            }
        }

        /**
         * Calculate distance and shortest segment between point and segment
         * @param pt
         * @param segment
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2segment(pt, segment) {
            /* Degenerated case of zero-length segment */
            if (segment.start.equalTo(segment.end)) {
                return Distance.point2point(pt, segment.start);
            }

            let v_seg = new Flatten.Vector(segment.start, segment.end);
            let v_ps2pt = new Flatten.Vector(segment.start, pt);
            let v_pe2pt = new Flatten.Vector(segment.end, pt);
            let start_sp = v_seg.dot(v_ps2pt);
            /* dot product v_seg * v_ps2pt */
            let end_sp = -v_seg.dot(v_pe2pt);
            /* minus dot product v_seg * v_pe2pt */

            let dist;
            let closest_point;
            if (Flatten.Utils.GE(start_sp, 0) && Flatten.Utils.GE(end_sp, 0)) {    /* point inside segment scope */
                let v_unit = segment.tangentInStart(); // new Flatten.Vector(v_seg.x / this.length, v_seg.y / this.length);
                /* unit vector ||v_unit|| = 1 */
                dist = Math.abs(v_unit.cross(v_ps2pt));
                /* dist = abs(v_unit x v_ps2pt) */
                closest_point = segment.start.translate(v_unit.multiply(v_unit.dot(v_ps2pt)));
                return [dist, new Flatten.Segment(pt, closest_point)];
            } else if (start_sp < 0) {                             /* point is out of scope closer to ps */
                return pt.distanceTo(segment.start);
            } else {                                               /* point is out of scope closer to pe */
                return pt.distanceTo(segment.end);
            }
        };

        /**
         * Calculate distance and shortest segment between point and arc
         * @param pt
         * @param arc
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2arc(pt, arc) {
            let circle = new Flatten.Circle(arc.pc, arc.r);
            let dist_and_segment = [];
            let dist, shortest_segment;
            [dist, shortest_segment] = Distance.point2circle(pt, circle);
            if (shortest_segment.end.on(arc)) {
                dist_and_segment.push(Distance.point2circle(pt, circle));
            }
            dist_and_segment.push(Distance.point2point(pt, arc.start));
            dist_and_segment.push(Distance.point2point(pt, arc.end));

            Distance.sort(dist_and_segment);

            return dist_and_segment[0];
        }

        /**
         * Calculate distance and shortest segment between segment and line
         * @param seg
         * @param line
         * @returns {Number | Segment}
         */
        static segment2line(seg, line) {
            let ip = seg.intersect(line);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];   // distance = 0, closest point is the first point
            }
            let dist_and_segment = [];
            dist_and_segment.push(Distance.point2line(seg.start, line));
            dist_and_segment.push(Distance.point2line(seg.end, line));

            Distance.sort(dist_and_segment);
            return dist_and_segment[0];

        }

        /**
         * Calculate distance and shortest segment between two segments
         * @param seg1
         * @param seg2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static segment2segment(seg1, seg2) {
            let ip = Intersection.intersectSegment2Segment(seg1, seg2);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];   // distance = 0, closest point is the first point
            }

            // Seg1 and seg2 not intersected
            let dist_and_segment = [];
            let dist_tmp, shortest_segment_tmp
            [dist_tmp, shortest_segment_tmp] = Distance.point2segment(seg2.start, seg1);
            dist_and_segment.push([dist_tmp, shortest_segment_tmp.reverse()]);
            [dist_tmp, shortest_segment_tmp] = Distance.point2segment(seg2.end, seg1);
            dist_and_segment.push([dist_tmp, shortest_segment_tmp.reverse()]);
            dist_and_segment.push(Distance.point2segment(seg1.start, seg2));
            dist_and_segment.push(Distance.point2segment(seg1.end, seg2));

            Distance.sort(dist_and_segment);
            return dist_and_segment[0];
        }

        /**
         * Calculate distance and shortest segment between segment and circle
         * @param seg
         * @param circle
         * @returns {Number | Segment} - distance and shortest segment
         */
        static segment2circle(seg, circle) {
            /* Case 1 Segment and circle intersected. Return the first point and zero distance */
            let ip = seg.intersect(circle);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            // No intersection between segment and circle

            /* Case 2. Distance to projection of center point to line bigger than radius
             * And projection point belong to segment
              * Then measure again distance from projection to circle and return it */
            let line = new Flatten.Line(seg.ps, seg.pe);
            let [dist, shortest_segment] = Distance.point2line(circle.center, line);
            if (Flatten.Utils.GE(dist, circle.r) && shortest_segment.end.on(seg)) {
                return Distance.point2circle(shortest_segment.end, circle);
            }
            /* Case 3. Otherwise closest point is one of the end points of the segment */
            else {
                let [dist_from_start, shortest_segment_from_start] = Distance.point2circle(seg.start, circle);
                let [dist_from_end, shortest_segment_from_end] = Distance.point2circle(seg.end, circle);
                return Flatten.Utils.LT(dist_from_start, dist_from_end) ?
                    [dist_from_start, shortest_segment_from_start] :
                    [dist_from_end, shortest_segment_from_end];
            }
        }

        /**
         * Calculate distance and shortest segment between segment and arc
         * @param seg
         * @param arc
         * @returns {Number | Segment} - distance and shortest segment
         */
        static segment2arc(seg, arc) {
            /* Case 1 Segment and arc intersected. Return the first point and zero distance */
            let ip = seg.intersect(arc);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            // No intersection between segment and arc
            let line = new Flatten.Line(seg.ps, seg.pe);
            let circle = new Flatten.Circle(arc.pc, arc.r);

            /* Case 2. Distance to projection of center point to line bigger than radius AND
             * projection point belongs to segment AND
               * distance from projection point to circle belongs to arc  =>
               * return this distance from projection to circle */
            let [dist_from_center, shortest_segment_from_center] = Distance.point2line(circle.center, line);
            if (Flatten.Utils.GE(dist_from_center, circle.r) && shortest_segment_from_center.end.on(seg)) {
                let [dist_from_projection, shortest_segment_from_projection] =
                    Distance.point2circle(shortest_segment_from_center.end, circle);
                if (shortest_segment_from_projection.end.on(arc)) {
                    return [dist_from_projection, shortest_segment_from_projection];
                }
            }
            /* Case 3. Otherwise closest point is one of the end points of the segment */
            let dist_and_segment = [];
            dist_and_segment.push(Distance.point2arc(seg.start, arc));
            dist_and_segment.push(Distance.point2arc(seg.end, arc));

            let dist_tmp, segment_tmp;
            [dist_tmp, segment_tmp] = Distance.point2segment(arc.start, seg);
            dist_and_segment.push([dist_tmp, segment_tmp.reverse()]);

            [dist_tmp, segment_tmp] = Distance.point2segment(arc.end, seg);
            dist_and_segment.push([dist_tmp, segment_tmp.reverse()]);

            Distance.sort(dist_and_segment);
            return dist_and_segment[0];
        }

        /**
         * Calculate distance and shortest segment between two circles
         * @param circle1
         * @param circle2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static circle2circle(circle1, circle2) {
            let ip = circle1.intersect(circle2);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            // Case 1. Concentric circles. Convert to arcs and take distance between two arc starts
            if (circle1.center.equalTo(circle2.center)) {
                let arc1 = circle1.toArc();
                let arc2 = circle2.toArc();
                return Distance.point2point(arc1.start, arc2.start);
            } else {
                // Case 2. Not concentric circles
                let line = new Flatten.Line(circle1.center, circle2.center);
                let ip1 = line.intersect(circle1);
                let ip2 = line.intersect(circle2);

                let dist_and_segment = [];

                dist_and_segment.push(Distance.point2point(ip1[0], ip2[0]));
                dist_and_segment.push(Distance.point2point(ip1[0], ip2[1]));
                dist_and_segment.push(Distance.point2point(ip1[1], ip2[0]));
                dist_and_segment.push(Distance.point2point(ip1[1], ip2[1]));

                Distance.sort(dist_and_segment);
                return dist_and_segment[0];
            }
        }

        /**
         * Calculate distance and shortest segment between two circles
         * @param circle
         * @param line
         * @returns {Number | Segment} - distance and shortest segment
         */
        static circle2line(circle, line) {
            let ip = circle.intersect(line);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            let [dist_from_center, shortest_segment_from_center] = Distance.point2line(circle.center, line);
            let [dist, shortest_segment] = Distance.point2circle(shortest_segment_from_center.end, circle);
            shortest_segment = shortest_segment.reverse();
            return [dist, shortest_segment];
        }

        /**
         * Calculate distance and shortest segment between arc and line
         * @param arc
         * @param line
         * @returns {Number | Segment} - distance and shortest segment
         */
        static arc2line(arc, line) {
            /* Case 1 Line and arc intersected. Return the first point and zero distance */
            let ip = line.intersect(arc);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            let circle = new Flatten.Circle(arc.center, arc.r);

            /* Case 2. Distance to projection of center point to line bigger than radius AND
             * projection point belongs to segment AND
               * distance from projection point to circle belongs to arc  =>
               * return this distance from projection to circle */
            let [dist_from_center, shortest_segment_from_center] = Distance.point2line(circle.center, line);
            if (Flatten.Utils.GE(dist_from_center, circle.r)) {
                let [dist_from_projection, shortest_segment_from_projection] =
                    Distance.point2circle(shortest_segment_from_center.end, circle);
                if (shortest_segment_from_projection.end.on(arc)) {
                    return [dist_from_projection, shortest_segment_from_projection];
                }
            } else {
                let dist_and_segment = [];
                dist_and_segment.push(Distance.point2line(arc.start, line));
                dist_and_segment.push(Distance.point2line(arc.end, line));

                Distance.sort(dist_and_segment);
                return dist_and_segment[0];
            }
        }

        /**
         * Calculate distance and shortest segment between arc and circle
         * @param arc
         * @param circle2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static arc2circle(arc, circle2) {
            let ip = arc.intersect(circle2);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            let circle1 = new Flatten.Circle(arc.center, arc.r);

            let [dist, shortest_segment] = Distance.circle2circle(circle1, circle2);
            if (shortest_segment.start.on(arc)) {
                return [dist, shortest_segment];
            } else {
                let dist_and_segment = [];

                dist_and_segment.push(Distance.point2circle(arc.start, circle2));
                dist_and_segment.push(Distance.point2circle(arc.end, circle2));

                Distance.sort(dist_and_segment);

                return dist_and_segment[0];
            }
        }

        /**
         * Calculate distance and shortest segment between two arcs
         * @param arc1
         * @param arc2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static arc2arc(arc1, arc2) {
            let ip = arc1.intersect(arc2);
            if (ip.length > 0) {
                return [0, new Flatten.Segment(ip[0], ip[0])];
            }

            let circle1 = new Flatten.Circle(arc1.center, arc1.r);
            let circle2 = new Flatten.Circle(arc2.center, arc2.r);

            let [dist, shortest_segment] = Distance.circle2circle(circle1, circle2);
            if (shortest_segment.start.on(arc1) && shortest_segment.end.on(arc2)) {
                return [dist, shortest_segment];
            } else {
                let dist_and_segment = [];

                let dist_tmp, segment_tmp;

                [dist_tmp, segment_tmp] = Distance.point2arc(arc1.start, arc2);
                if (segment_tmp.end.on(arc2)) {
                    dist_and_segment.push([dist_tmp, segment_tmp]);
                }

                [dist_tmp, segment_tmp] = Distance.point2arc(arc1.end, arc2);
                if (segment_tmp.end.on(arc2)) {
                    dist_and_segment.push([dist_tmp, segment_tmp]);
                }

                [dist_tmp, segment_tmp] = Distance.point2arc(arc2.start, arc1);
                if (segment_tmp.end.on(arc1)) {
                    dist_and_segment.push([dist_tmp, segment_tmp.reverse()]);
                }

                [dist_tmp, segment_tmp] = Distance.point2arc(arc2.end, arc1);
                if (segment_tmp.end.on(arc1)) {
                    dist_and_segment.push([dist_tmp, segment_tmp.reverse()]);
                }

                [dist_tmp, segment_tmp] = Distance.point2point(arc1.start, arc2.start);
                dist_and_segment.push([dist_tmp, segment_tmp]);

                [dist_tmp, segment_tmp] = Distance.point2point(arc1.start, arc2.end);
                dist_and_segment.push([dist_tmp, segment_tmp]);

                [dist_tmp, segment_tmp] = Distance.point2point(arc1.end, arc2.start);
                dist_and_segment.push([dist_tmp, segment_tmp]);

                [dist_tmp, segment_tmp] = Distance.point2point(arc1.end, arc2.end);
                dist_and_segment.push([dist_tmp, segment_tmp]);

                Distance.sort(dist_and_segment);

                return dist_and_segment[0];
            }
        }

        /**
         * Calculate distance and shortest segment between point and polygon
         * @param point
         * @param polygon
         * @returns {Number | Segment} - distance and shortest segment
         */
        static point2polygon(point, polygon) {
            let min_dist_and_segment = [Number.POSITIVE_INFINITY, new Flatten.Segment()];
            for (let edge of polygon.edges) {
                let [dist, shortest_segment] = (edge.shape instanceof Flatten.Segment) ?
                    Distance.point2segment(point, edge.shape) : Distance.point2arc(point, edge.shape);
                if (Flatten.Utils.LT(dist, min_dist_and_segment[0])) {
                    min_dist_and_segment = [dist, shortest_segment];
                }
            }
            return min_dist_and_segment;
        }

        static shape2polygon(shape, polygon) {
            let min_dist_and_segment = [Number.POSITIVE_INFINITY, new Flatten.Segment()];
            for (let edge of polygon.edges) {
                let [dist, shortest_segment] = shape.distanceTo(edge.shape);
                if (Flatten.Utils.LT(dist, min_dist_and_segment[0])) {
                    min_dist_and_segment = [dist, shortest_segment];
                }
            }
            return min_dist_and_segment;
        }

        /**
         * Calculate distance and shortest segment between two polygons
         * @param polygon1
         * @param polygon2
         * @returns {Number | Segment} - distance and shortest segment
         */
        static polygon2polygon(polygon1, polygon2) {
            let min_dist_and_segment = [Number.POSITIVE_INFINITY, new Flatten.Segment()];
            for (let edge1 of polygon1.edges) {
                for (let edge2 of polygon2.edges) {
                    let [dist, shortest_segment] = edge1.shape.distanceTo(edge2.shape);
                    if (Flatten.Utils.LT(dist, min_dist_and_segment[0])) {
                        min_dist_and_segment = [dist, shortest_segment];
                    }
                }
            }
            return min_dist_and_segment;
        }

        /**
         * Returns [mindist, maxdist] array of squared minimal and maximal distance between boxes
         * Minimal distance by x is
         *    (box2.xmin - box1.xmax), if box1 is left to box2
         *    (box1.xmin - box2.xmax), if box2 is left to box1
         *    0,                       if box1 and box2 are intersected by x
         * Minimal distance by y is defined in the same way
         *
         * Maximal distance is estimated as a sum of squared dimensions of the merged box
         *
         * @param box1
         * @param box2
         * @returns {Number | Number} - minimal and maximal distance
         */
        static box2box_minmax(box1, box2) {
            let mindist_x = Math.max(Math.max(box1.xmin - box2.xmax, 0), Math.max(box2.xmin - box1.xmax, 0));
            let mindist_y = Math.max(Math.max(box1.ymin - box2.ymax, 0), Math.max(box2.ymin - box1.ymax, 0));
            let mindist = mindist_x * mindist_x + mindist_y * mindist_y;

            let box = box1.merge(box2);
            let dx = box.xmax - box.xmin;
            let dy = box.ymax - box.ymin;
            let maxdist = dx * dx + dy * dy;

            return [mindist, maxdist];
        }

        static minmax_tree_process_level(shape, level, min_stop, tree) {
            // Calculate minmax distance to each shape in current level
            // Insert result into the interval tree for further processing
            // update min_stop with maxdist, it will be the new stop distance
            let mindist, maxdist;
            for (let node of level) {

                // [mindist, maxdist] = Distance.box2box_minmax(shape.box, node.max);
                // if (Flatten.Utils.GT(mindist, min_stop))
                //     continue;

                // Estimate min-max dist to the shape stored in the node.item, using node.item.key which is shape's box
                [mindist, maxdist] = Distance.box2box_minmax(shape.box, node.item.key);
                if (node.item.value instanceof Flatten.Edge) {
                    tree.insert([mindist, maxdist], node.item.value.shape);
                } else {
                    tree.insert([mindist, maxdist], node.item.value);
                }
                if (Flatten.Utils.LT(maxdist, min_stop)) {
                    min_stop = maxdist;                       // this will be the new distance estimation
                }
            }

            if (level.length === 0)
                return min_stop;

            // Calculate new level from left and right children of the current
            let new_level_left = level.map(node => node.left.isNil() ? undefined : node.left).filter(node => node !== undefined);
            let new_level_right = level.map(node => node.right.isNil() ? undefined : node.right).filter(node => node !== undefined);
            // Merge left and right subtrees and leave only relevant subtrees
            let new_level = [...new_level_left, ...new_level_right].filter(node => {
                // Node subtree quick reject, node.max is a subtree box
                let [mindist, maxdist] = Distance.box2box_minmax(shape.box, node.max);
                return (Flatten.Utils.LE(mindist, min_stop));
            });

            min_stop = Distance.minmax_tree_process_level(shape, new_level, min_stop, tree);
            return min_stop;
        }

        /**
         * Calculates sorted tree of [mindist, maxdist] intervals between query shape
         * and shapes of the planar set.
         * @param shape
         * @param set
         */
        static minmax_tree(shape, set, min_stop) {
            let tree = new IntervalTree();
            let level = [set.index.root];
            let squared_min_stop = min_stop < Number.POSITIVE_INFINITY ? min_stop * min_stop : Number.POSITIVE_INFINITY;
            squared_min_stop = Distance.minmax_tree_process_level(shape, level, squared_min_stop, tree);
            return tree;
        }

        static minmax_tree_calc_distance(shape, node, min_dist_and_segment) {
            let min_dist_and_segment_new, stop;
            if (node != null && !node.isNil()) {
                [min_dist_and_segment_new, stop] = Distance.minmax_tree_calc_distance(shape, node.left, min_dist_and_segment);

                if (stop) {
                    return [min_dist_and_segment_new, stop];
                }

                if (Flatten.Utils.LT(min_dist_and_segment_new[0], Math.sqrt(node.item.key.low))) {
                    return [min_dist_and_segment_new, true];   // stop condition
                }

                let [dist, shortest_segment] = Distance.distance(shape, node.item.value);
                // console.log(dist)
                if (Flatten.Utils.LT(dist, min_dist_and_segment_new[0])) {
                    min_dist_and_segment_new = [dist, shortest_segment];
                }

                [min_dist_and_segment_new, stop] = Distance.minmax_tree_calc_distance(shape, node.right, min_dist_and_segment_new);

                return [min_dist_and_segment_new, stop];
            }

            return [min_dist_and_segment, false];
        }

        /**
         * Calculates distance between shape and Planar Set of shapes
         * @param shape
         * @param {PlanarSet} set
         * @param {Number} min_stop
         * @returns {*}
         */
        static shape2planarSet(shape, set, min_stop = Number.POSITIVE_INFINITY) {
            let min_dist_and_segment = [min_stop, new Flatten.Segment()];
            let stop = false;
            if (set instanceof Flatten.PlanarSet) {
                let tree = Distance.minmax_tree(shape, set, min_stop);
                [min_dist_and_segment, stop] = Distance.minmax_tree_calc_distance(shape, tree.root, min_dist_and_segment);
            }
            return min_dist_and_segment;
        }

        static sort(dist_and_segment) {
            dist_and_segment.sort((d1, d2) => {
                if (Flatten.Utils.LT(d1[0], d2[0])) {
                    return -1;
                }
                if (Flatten.Utils.GT(d1[0], d2[0])) {
                    return 1;
                }
                return 0;
            });
        }

        static distance(shape1, shape2) {
            return shape1.distanceTo(shape2);
        }
    }

    Flatten.Distance = Distance;