class Rectangle

  attr_accessor :p1, :p2

  def initialize(p1,p2)
    @p1 = p1
    @p2 = p2
  end

  def overlap_rectangle(rect)
    xs = {
      my1: p1[0],
      my2: p2[0],
      other1: rect.p1[0],
      other2: rect.p2[0]
    }
    ys = {
      my1: p1[1],
      my2: p2[1],
      other1: rect.p1[1],
      other2: rect.p2[1]
    }

    x_interval = interval(xs)
    y_interval = interval(ys)
    p1 = [x_interval[0], y_interval[0]]
    p2 = [x_interval[1], y_interval[1]]
    Rectangle.new(p1,p2)
  end

  def interval(points)
    sorted_keys = sorted_keys_by_value(points)
    interval = [0,0]
    if no_overlap(sorted_keys, points)
      interval = [0,0]
    elsif share_edges(points)
      interval = min_max(points)
    else
      sorted_keys.each_cons(3) do |keys|
        if keys[1].to_s[0...-1] != keys[2].to_s[0...-1]
          interval = [points[keys[1]], points[keys[0]]]#[hi,low] 
        end
      end 
    end
    interval 
  end

  def sorted_keys_by_value(points)
    sorted_keys = [] 
    points.values.sort.uniq.reverse.each do |val|
      #simple points.key(val) fails when keys share a value so do this
      points.select{|k,v| v == val}.each do |k,v|
        sorted_keys << k
      end
    end
    sorted_keys
  end

  def min_max(points)
    [points.values.min, points.values.max]
  end

  def share_edges(points)
    points.values.uniq.length == 2 
  end

  def no_overlap(sorted_points,points)
    whos = sorted_points.map {|p| p.to_s[0...-1]}
    (whos[0] == whos[1]) && (whos[2] == whos[3]) \
    && points.values.uniq.length > 2
  end

end

require 'minitest/autorun'
require_relative 'rectangle'

class RectangleTest < MiniTest::Unit::TestCase

  def test_1
    a = Rectangle.new([2,3],[5,8])
    b = Rectangle.new([4,4],[9,9])
    n = a.overlap_rectangle(b)
    assert_equal [4,4], n.p1
    assert_equal [5,8], n.p2
  end

  def test_2
    a = Rectangle.new([0,0],[9,9])
    b = Rectangle.new([2,3],[4,7])
    n = a.overlap_rectangle(b)
    assert_equal [2,3], n.p1
    assert_equal [4,7], n.p2
  end

  def test_3
    a = Rectangle.new([0,0],[9,9])
    b = Rectangle.new([2,3],[9,9])
    n = a.overlap_rectangle(b)
    assert_equal [2,3], n.p1
    assert_equal [9,9], n.p2
  end
  def test_4
    a = Rectangle.new([1,3],[9,9])
    b = Rectangle.new([0,0],[9,9])
    n = a.overlap_rectangle(b)
    assert_equal [1,3], n.p1
    assert_equal [9,9], n.p2
  end
  def test_5
    a = Rectangle.new([1,3],[9,9])
    b = Rectangle.new([-2,-8],[5,8])
    n = a.overlap_rectangle(b)
    assert_equal [1,3], n.p1
    assert_equal [5,8], n.p2
  end
  def test_6
    a = Rectangle.new([1,3],[9,9])
    b = Rectangle.new([-1,5],[7,7])
    n = a.overlap_rectangle(b)
    assert_equal [1,5], n.p1
    assert_equal [7,7], n.p2
  end

  def test_7
    a = Rectangle.new([1,3],[4,4])
    b = Rectangle.new([5,5],[7,7])
    n = a.overlap_rectangle(b)
    assert_equal [0,0], n.p1
    assert_equal [0,0], n.p2
  end
  def test_jj
    a = Rectangle.new([1,3],[4,4])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [2,3], n.p1
    assert_equal [4,4], n.p2
  end
  def test_same
    a = Rectangle.new([2,2],[4,4])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [2,2], n.p1
    assert_equal [4,4], n.p2
  end

  def test_almost_same
    a = Rectangle.new([3,2],[4,4])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [4,4], n.p2
    assert_equal [3,2], n.p1
  end
  def test_almost_same2
    a = Rectangle.new([2,3],[4,4])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [4,4], n.p2
    assert_equal [2,3], n.p1
  end
  def test_almost_same3
    a = Rectangle.new([2,2],[4,3])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [2,2], n.p1
    assert_equal [4,3], n.p2
  end
  def test_almost_same4
    a = Rectangle.new([2,2],[3,4])
    b = Rectangle.new([2,2],[4,4])
    n = a.overlap_rectangle(b)
    assert_equal [2,2], n.p1
    assert_equal [3,4], n.p2
  end
end

# convenience ctor
def r(x1,y1,x2,y2) Rect.new Point.new(x1,y1), Point.new(x2,y2); end

Point = Struct.new(:x, :y)

Rect = Struct.new(:p1, :p2) do

  def intersection(r2)
    # just checking the disjoint case here
    xs = x_points + r2.x_points
    ys = y_points + r2.y_points
    return nil if disjoint(xs) || disjoint(ys)

    # these three lines are really the whole implementation
    xs = xs.sort
    ys = ys.sort
    r(xs[1], ys[1],xs[2], ys[2])
  end

  def x_points() [p1.x, p2.x].sort; end

  def y_points() [p1.y, p2.y].sort; end

  def disjoint(_s) _s == _s.sort; end

end

###############################
# TESTS BELOW
# (pure ruby cause lol require)
###############################

r1 = r(0,0,  6,4) 
r2 = r(4,2,  13,8)
expected_intersection = r(4,2,  6,4)
puts expected_intersection == r1.intersection(r2) ? "Pass" : "Fail"

r1 = r(0,0,  6,4) 
r2 = r(3,1,  8,3)
expected_intersection = r(3,1,  6,3)
puts expected_intersection == r1.intersection(r2) ? "Pass" : "Fail"

r1 = r(0,0,  6,4) 
r2 = r(1,1,   3,3)
expected_intersection = r(1,1,   3,3)
puts expected_intersection == r1.intersection(r2) ? "Pass" : "Fail"

r1 = r(0,0,  6,4) 
r2 = r(6,0,  7,3)
expected_intersection = nil
puts expected_intersection == r1.intersection(r2) ? "Pass" : "Fail"

Rect.prototype.intersects_rect = function (rc)
{
  return !(rc.right < this.left || rc.bottom < this.top || rc.left > this.right || rc.top > this.bottom);
};