#TODO
# All to layer 0
# Explode all Groups
# Generate new Group with all entities

# generate grats (bridges) within a template to prevent parts from disloging or falling out during lasercutting

#---------------------------------------------------------------------------------
# return first edge from edgeList that connects to vertex lastVertex
def self.FindConnectingEdge(lastVertex, edgeList)
  edgeList.each do |e|
    p3 = e.start.position
    p4 = e.end.position
    #puts "~~~~~~~~~" + p3.inspect + " " + p4.inspect
    if lastVertex == p3 or lastVertex == p4
      #puts "---" + p3.inspect + " " + p4.inspect
      return e
    end
  end
  return 0
end

#---------------------------------------------------------------------------------
# put connected edges into groups in group_buffer[][]
def self.SortConnectedEdgesIntoGroups(edge_buffer)
  group_buffer = []
  loop do
    break if edge_buffer.size === 0
    current_group_buffer = []
    e = edge_buffer[0]
    current_group_buffer << e
    edge_buffer.delete(e)
    last_vertex = e.end.position

    loop do
      e = FindConnectingEdge(last_vertex, edge_buffer)
      if e != 0
        current_group_buffer << e
        edge_buffer.delete(e)
        if last_vertex === e.start.position
          last_vertex = e.end.position
        else
        last_vertex = e.start.position
        end
      else
        group_buffer << current_group_buffer
        break
      end
    end
  end
  return group_buffer
end

#---------------------------------------------------------------------------------
# select all edges from selection
def self.SelectEdges(buffer)
  select_buffer = []
  buffer.each do |e|
      if e.is_a? Sketchup::Edge
        select_buffer << e
      end
  end
  return select_buffer
end

#---------------------------------------------------------------------------------
# meassure lengths of all edgegroups in edge_buffer[][] and return them in length_buffer[]
def self.CreateLengthBuffer(group_buffer)
  length_buffer = []
  group_buffer.each do |g|
    len = 0
    g.each do |e|
      p1 = e.start.position
      p2 = e.end.position
      d = p1.distance(p2)
      len = len + d
    end
    length_buffer << len
  end
  return length_buffer
end

#---------------------------------------------------------------------------------
# returns array of vertices for the new lines
def self.IntercutEdgeAtIndex(e,grat_breite)
  returnbuffer = []

  p1 = e.start.position
  p2 = e.end.position

  d = p1.distance(p2)
  b = d-grat_breite

  if d > grat_breite
    scale1 = (b / 2) / d
    scale2 = scale1 + (grat_breite / d)

    p3 = Geom::Point3d.linear_combination(scale1, p2, 1 - scale1, p1)
    p4 = Geom::Point3d.linear_combination(1-scale2, p1, scale2, p2)

    returnbuffer << p1 << p3 << p4 << p2
  else
    returnbuffer << p1 << p2
  end
  return returnbuffer
end

#---------------------------------------------------------------------------------
def self.select_longest_edge(edge_group)
  l_index = 0
  l_val = 0
  edge_group.each_with_index do |e,index|
    p1 = e.start.position
    p2 = e.end.position
    d = p1.distance(p2)
    if d > l_val
      l_val = d
      l_index = index
    end
  end
  return l_index
end

#---------------------------------------------------------------------------------
# returns returnbuffer[][] with first parameter being the deleted edges and second
# parameter the new vertices!
def self.CreateVerticsBufferWithGrates(group_buffer, length_buffer, mm_per_grat, grat_breite)
  returnbuffer = Array.new(2) { Array.new(0) }
  length_buffer.each_with_index do |val, index|
    #puts "#{val} => #{index}"

    if val <= mm_per_grat
      # if the group is shorter than the minimal length only do one grat
      edge_index = select_longest_edge(group_buffer[index])
      new_vetices = IntercutEdgeAtIndex(group_buffer[index][edge_index],grat_breite)
      returnbuffer[0] << group_buffer[index][edge_index]
      new_vetices.each do |v|
        returnbuffer[1] << v
      end
    else
      # do multiple equidistante grats
      num_grats = val / mm_per_grat.round
      avg_dist = val / num_grats

      current_dist = avg_dist / 2

      group_buffer[index].each do |e|
        p1 = e.start.position
        p2 = e.end.position
        d = p1.distance(p2)
        current_dist = current_dist + d

        if current_dist > avg_dist and d > grat_breite
          new_vetices = IntercutEdgeAtIndex(e,grat_breite)
          returnbuffer[0] << e
          new_vetices.each do |v|
            returnbuffer[1] << v
          end
          current_dist = current_dist - avg_dist
        end

      end

    end
  end
  return returnbuffer
end

#---------------------------------------------------------------------------------
def self.ReplaceOldEdgesWithNewEdges(delete_buffer, new_buffer)
  mod = Sketchup.active_model # Open model
  ent = mod.entities # All entities in model
  # delete old edges
  delete_buffer.each do |e|
      e.erase!
  end

  # add the new edges
  e1 = 0
  sw = 0
  new_buffer.each do |e|
    if sw === 0
      e1 = e
      sw = 1
     else
      ent.add_line(e1,e)
      sw = 0
    end
  end
end

#---------------------------------------------------------------------------------
def self.MakeGrats(sel,mm_per_grat,grat_breite)
  edge_buffer = SelectEdges(sel)

  group_buffer = SortConnectedEdgesIntoGroups(edge_buffer)
  #puts group_buffer.inspect

  length_buffer = CreateLengthBuffer(group_buffer)
  #puts length_buffer.inspect

  buffer = CreateVerticsBufferWithGrates(group_buffer,length_buffer,mm_per_grat,grat_breite)

  ReplaceOldEdgesWithNewEdges(buffer[0],buffer[1])

  puts "ENDE"
end