var RegionList = (function(){

  var RegionList = {}
  var regions = RegionList.regions

  RegionList.build = function(){
    var segments = RegionList.getSortedSegments()

    var rooms = []
    var seen_rooms = {}
    var open_segments = []
    var closed_segments = []
    
    var segment, open_segment, x_segment, y_segments, overlapped, seen_segments

    for (var i = 0; i < segments.length; i++) {
      segment = segments[i]
      if (! segment.isVertical()) {
        continue
      }
      overlapped = false
      for (var j = 0; j < open_segments.length; j++) {
        open_segment = open_segments[j]
        if (segment.y.overlaps(open_segment.y)) {
          overlapped = true
          closed_segments.push(open_segments[j])
          open_segments.splice(j--, 1)

          x_segment = new vec2( open_segment.x.a, segment.x.b )
          y_segments = open_segment.y.split(segment.y, TOP, BOTTOM)
          
          seen_segments = {}

          y_segments.forEach(function(seg){
            seen_segments[ seg[0]+"" ] = true
            var room = new Rect( x_segment, seg[0] )

            if (seen_rooms[ room+"" ]) return;

            seen_rooms[ room+"" ] = true
            rooms.push(room)
            var new_seg = new Rect( segment.x, seg[0] )
            open_segments.unshift(new_seg)
            j++
          })

          y_segments = segment.y.split(open_segment.y, TOP, BOTTOM)
          y_segments.forEach(function(seg){
            if (seen_segments[ seg[0]+"" ]) return;
            var new_seg = new Rect( segment.x, seg[0] )
            open_segments.unshift(new_seg)
            j++
          })
        }
      }
      if (overlapped) {
        // sort open segments?
        open_segments = open_segments.sort(function(a,b){
          if (a.y.a < b.y.a) { return -1 }
          if (a.y.a == b.y.a) { return 0 }
          if (a.y.a > b.y.a) { return 1 }
        })
        
        if (open_segments.length < 2) { continue }
        
        for (var k = 1; k < open_segments.length; k++) {
          if (open_segments[k-1].y.containsVec(open_segments[k].y)) {
            open_segments.splice(k--, 1)
          }
          else if (open_segments[k-1].y.overlaps(open_segments[k].y)) {
            open_segments[k].y = open_segments[k].y.clone()
            console.log(open_segments[k-1].y+"", open_segments[k].y+"")
            open_segments[k].y.a = open_segments[k-1].y.b
          }
        }
      }
      else {
        open_segments.push(segment)
      }
    }
    
    for (var i = 0; i < segments.length; i++) {
      segment = segments[i]
      if (! segment.isHorizontal()) {
        continue
      }
    }

    return { rooms: rooms, open_segments: open_segments, segments: segments, closed_segments: closed_segments }
  }
  
  RegionList.getSortedSegments = function(){
    // get a list of all segments from these polylines
    var segments = shapes.getAllSegments()

    // re-orient them so they're either facing up or right and make them into rects
    segments = segments.map(function(segment){
      // vertical
      if (segment[0].a == segment[1].a) {
        if (segment[0].b > segment[1].b) {
          segment.push(segment.shift())
        }
      }
      // horizontal
      else if (segment[0].b == segment[1].b) {
        if (segment[0].a > segment[1].a) {
          segment.push(segment.shift())
        }
      }
      return new Rect( segment[0].a, segment[0].b, segment[1].a, segment[1].b )
    })
    
    return sort.rects_by_position(segments)
  }

  return RegionList
  
})()