module UnicodePlot

# File lib/unicode_plot/renderer.rb, line 43
def self.border_types
  BORDER_MAP.keys
end

# File lib/unicode_plot/canvas.rb, line 167
def self.canvas_types
  Canvas::CANVAS_CLASS_MAP.keys
end

# File lib/unicode_plot/stemplot.rb, line 323
def stemplot(*args, scale: 10, **kw)
  case args.length
  when 1
    # Stemplot object
    plt = Stemplot.factory(args[0], scale: scale, **kw)
    # Dispatch to plot routine
    stemplot1!(plt, scale: scale, **kw)
  when 2
    # Stemplot object
    plt1 = Stemplot.factory(args[0], scale: scale)
    plt2 = Stemplot.factory(args[1], scale: scale)
    raise ArgumentError, "Plot types must be the same for back-to-back stemplot " +
          "#{plt1.class} != #{plt2.class}" unless plt1.class == plt2.class
    # Dispatch to plot routine
    stemplot2!(plt1, plt2, scale: scale, **kw)
  else
    raise ArgumentError, "Expecting one or two arguments"
  end
end

# File lib/unicode_plot/stemplot.rb, line 233
def stemplot1!(plt, 
               scale: 10,
               divider: "|",
               padchar: " ",
               trim: false,
               **_kw
              )

  stem_labels = plt.stems(all: !trim)
  label_len = stem_labels.map(&:length).max
  column_len = label_len + 1
  
  stem_labels.each do |stem|
    leaves = plt.leaves(stem).sort
    stemlbl = stem.rjust(label_len, padchar).ljust(column_len, padchar)
    puts stemlbl + divider + padchar + leaves.join
  end
  plt.print_key(scale, divider)
end

# File lib/unicode_plot/stemplot.rb, line 265
def stemplot2!(plt1, plt2,
               scale: 10,
               divider: "|",
               padchar: " ",
               trim: false,
               **_kw
              )
  stem_labels = plt1.class.sorted_stem_list( (plt1.raw_stems + plt2.raw_stems).uniq, all: !trim )
  label_len = stem_labels.map(&:length).max
  column_len = label_len + 1

  leftleaf_len = plt1.max_stem_length

  stem_labels.each do |stem|
    left_leaves = plt1.leaves(stem).sort.join('')
    right_leaves = plt2.leaves(stem).sort.join('')
    left_leaves_just = left_leaves.reverse.rjust(leftleaf_len, padchar)
    stem = stem.rjust(column_len, padchar).ljust(column_len+1, padchar)
    puts left_leaves_just + padchar + divider + stem + divider + padchar + right_leaves
  end

  plt1.print_key(scale, divider)

end

# File lib/unicode_plot/barplot.rb, line 123
                def barplot(*args,
                            width: Plot::DEFAULT_WIDTH,
                            color: Barplot::DEFAULT_COLOR,
                            symbol: Barplot::DEFAULT_SYMBOL,
                            border: :barplot,
                            xscale: nil,
                            xlabel: nil,
                            data: nil,
                            **kw)
  case args.length
  when 0
    data = Hash(data)
    keys = data.keys.map(&:to_s)
    heights = data.values
  when 2
    keys = Array(args[0])
    heights = Array(args[1])
  else
    raise ArgumentError, "invalid arguments"
  end

  unless keys.length == heights.length
    raise ArgumentError, "The given vectors must be of the same length"
  end
  unless heights.min >= 0
    raise ArgumentError, "All values have to be positive. Negative bars are not supported."
  end

  xlabel ||= ValueTransformer.transform_name(xscale)
  plot = Barplot.new(heights, width, color, symbol, xscale,
                     border: border, xlabel: xlabel,
                     **kw)
  keys.each_with_index do |key, i|
    plot.annotate_row!(:l, i, key)
  end

  plot
end

# File lib/unicode_plot/barplot.rb, line 177
                def barplot!(plot,
                             *args,
                             data: nil)
  case args.length
  when 0
    data = Hash(data)
    keys = data.keys.map(&:to_s)
    heights = data.values
  when 2
    keys = Array(args[0])
    heights = Array(args[1])
  else
    raise ArgumentError, "invalid arguments"
  end

  unless keys.length == heights.length
    raise ArgumentError, "The given vectors must be of the same length"
  end
  if keys.empty?
    raise ArgumentError, "Can't append empty array to barplot"
  end

  cur_idx = plot.n_rows
  plot.add_row!(heights)
  keys.each_with_index do |key, i|
    plot.annotate_row!(:l, cur_idx + i, key)
  end
  plot
end

# File lib/unicode_plot/boxplot.rb, line 94
                def boxplot(*args,
                            data: nil,
                            border: :corners,
                            color: Boxplot::DEFAULT_COLOR,
                            width: Plot::DEFAULT_WIDTH,
                            xlim: [0, 0],
                            **kw)
  case args.length
  when 0
    data = Hash(data)
    text = data.keys
    data = data.values
  when 1
    data = args[0]
  when 2
    text = Array(args[0])
    data = args[1]
  else
    raise ArgumentError, "wrong number of arguments"
  end

  case data[0]
  when Numeric
    data = [data]
  when Array
    # do nothing
  else
    data = data.to_ary
  end
  text ||= Array.new(data.length, "")

  unless text.length == data.length
    raise ArgumentError, "wrong number of text"
  end

  unless xlim.length == 2
    raise ArgumentError, "xlim must be a length 2 array"
  end

  min_x, max_x = Utils.extend_limits(data.map(&:minmax).flatten, xlim)
  width = [width, Boxplot::MIN_WIDTH].max

  plot = Boxplot.new(data[0], width, color, min_x, max_x,
                     border: border, **kw)
  (1 ... data.length).each do |i|
    plot.add_series!(data[i])
  end

  mean_x = (min_x + max_x) / 2.0
  min_x_str  = (Utils.roundable?(min_x) ? min_x.round : min_x).to_s
  mean_x_str = (Utils.roundable?(mean_x) ? mean_x.round : mean_x).to_s
  max_x_str  = (Utils.roundable?(max_x) ? max_x.round : max_x).to_s
  plot.annotate!(:bl, min_x_str, color: :light_black)
  plot.annotate!(:b,  mean_x_str, color: :light_black)
  plot.annotate!(:br, max_x_str, color: :light_black)

  text.each_with_index do |name, i|
    plot.annotate_row!(:l, i*3+1, name) if name.length > 0
  end

  plot
end

# File lib/unicode_plot/boxplot.rb, line 157
                def boxplot!(plot, *args, **kw)
  case args.length
  when 1
    data = args[0]
    name = kw[:name] || ""
  when 2
    name = args[0]
    data = args[1]
  else
    raise ArgumentError, "worng number of arguments"
  end

  if data.empty?
    raise ArgumentError, "Can't append empty array to boxplot"
  end

  plot.add_series!(data)

  plot.annotate_row!(:l, (plot.n_data - 1)*3+1, name) if name && name != ""

  min_x = plot.min_x
  max_x = plot.max_x
  mean_x = (min_x + max_x) / 2.0
  min_x_str  = (Utils.roundable?(min_x) ? min_x.round : min_x).to_s
  mean_x_str = (Utils.roundable?(mean_x) ? mean_x.round : mean_x).to_s
  max_x_str  = (Utils.roundable?(max_x) ? max_x.round : max_x).to_s
  plot.annotate!(:bl, min_x_str, color: :light_black)
  plot.annotate!(:b,  mean_x_str, color: :light_black)
  plot.annotate!(:br, max_x_str, color: :light_black)

  plot
end

# File lib/unicode_plot/stairs.rb, line 63
                def compute_stair_lines(x, y, style: :post)
  x_vex = Array.new(x.length * 2 - 1, 0)
  y_vex = Array.new(x.length * 2 - 1, 0)
  x_vex[0] = x[0]
  y_vex[0] = y[0]
  o = 0
  if style == :post
    (1 ... x.length).each do |i|
      x_vex[i + o] = x[i]
      x_vex[i + o + 1] = x[i]
      y_vex[i + o] = y[i-1]
      y_vex[i + o + 1] = y[i]
      o += 1
    end
  elsif style == :pre
    (1 ... x.length).each do |i|
      x_vex[i + o] = x[i-1]
      x_vex[i + o + 1] = x[i]
      y_vex[i + o] = y[i]
      y_vex[i + o + 1] = y[i]
      o += 1
    end
  end
  return [x_vex, y_vex]
end

# File lib/unicode_plot/densityplot.rb, line 2
                def densityplot(x, y, color: :auto, grid: false, name: "", **kw)
  plot = GridPlot.new(x, y, :density, grid: grid, **kw)
  scatterplot!(plot, x, y, color: color, name: name)
end

# File lib/unicode_plot/densityplot.rb, line 7
                def densityplot!(plot, x, y, **kw)
  scatterplot!(plot, x, y, **kw)
end

# File lib/unicode_plot/histogram.rb, line 4
                def histogram(x,
                              nbins: nil,
                              closed: :left,
                              symbol: "▇",
                              **kw)
  hist = x.histogram(*[nbins].compact, closed: closed)
  edge, counts = hist.edge, hist.weights
  labels = []
  bin_width = edge[1] - edge[0]
  pad_left, pad_right = 0, 0
  (0 ... edge.length).each do |i|
    val1 = Utils.float_round_log10(edge[i], bin_width)
    val2 = Utils.float_round_log10(val1 + bin_width, bin_width)
    a1 = val1.to_s.split('.', 2).map(&:length)
    a2 = val2.to_s.split('.', 2).map(&:length)
    pad_left  = [pad_left,  a1[0], a2[0]].max
    pad_right = [pad_right, a1[1], a2[1]].max
  end
  l_str = hist.closed == :right ? "(" : "["
  r_str = hist.closed == :right ? "]" : ")"
  counts.each_with_index do |n, i|
    val1 = Utils.float_round_log10(edge[i], bin_width)
    val2 = Utils.float_round_log10(val1 + bin_width, bin_width)
    a1 = val1.to_s.split('.', 2).map(&:length)
    a2 = val2.to_s.split('.', 2).map(&:length)
    labels[i] = "\e[90m#{l_str}\e[0m" +
                (" " * (pad_left - a1[0])) +
                val1.to_s +
                (" " * (pad_right - a1[1])) +
                "\e[90m, \e[0m" +
                (" " * (pad_left - a2[0])) +
                val2.to_s +
                (" " * (pad_right - a2[1])) +
                "\e[90m#{r_str}\e[0m"
  end
  xscale = kw.delete(:xscale)
  xlabel = kw.delete(:xlabel) ||
           ValueTransformer.transform_name(xscale, "Frequency")
  barplot(labels, counts,
          symbol: symbol,
          xscale: xscale,
          xlabel: xlabel,
          **kw)
end

# File lib/unicode_plot/lineplot.rb, line 33
                def lineplot(*args,
                             canvas: :braille,
                             color: :auto,
                             name: "",
                             **kw)
  case args.length
  when 1
    # y only
    y = Array(args[0])
    x = Array(1 .. y.length)
  when 2
    # x and y
    x = Array(args[0])
    y = Array(args[1])
  else
    raise ArgumentError, "wrong number of arguments"
  end

  case x[0]
  when Time, Date
    if x[0].is_a? Time
      d = x.map(&:to_f)
    else
      origin = Date.new(1, 1, 1)
      d = x.map {|xi| xi - origin }
    end
    plot = lineplot(d, y, canvas: canvas, color: color, name: name, **kw)
    xmin, xmax = x.minmax
    plot.annotate!(:bl, xmin.to_s, color: :light_black)
    plot.annotate!(:br, xmax.to_s, color: :light_black)
    plot
  else
    plot = Lineplot.new(x, y, canvas, **kw)
    lineplot!(plot, x, y, color: color, name: name)
  end
end

# File lib/unicode_plot/lineplot.rb, line 80
                def lineplot!(plot,
                              *args,
                              color: :auto,
                              name: "")
  case args.length
  when 1
    # y only
    y = Array(args[0])
    x = Array(1 .. y.length)
  when 2
    # x and y
    x = Array(args[0])
    y = Array(args[1])

    if x.length == 1 && y.length == 1
      # intercept and slope
      intercept = x[0]
      slope = y[0]
      xmin = plot.origin_x
      xmax = plot.origin_x + plot.plot_width
      ymin = plot.origin_y
      ymax = plot.origin_y + plot.plot_height
      x = [xmin, xmax]
      y = [intercept + xmin*slope, intercept + xmax*slope]
    end
  else
    raise ArgumentError, "wrong number of arguments"
  end

  case x[0]
  when Time, Date
    if x[0].is_a? Time
      d = x.map(&:to_f)
    else
      origin = Date.new(1, 1, 1)
      d = x.map {|xi| xi - origin }
    end
    lineplot!(plot, d, y, color: color, name: name)
  else
    color = color == :auto ? plot.next_color : color
    plot.annotate!(:r, name.to_s, color: color) unless name.nil? || name == ""
    plot.lines!(x, y, color)
  end
  plot
end

# File lib/unicode_plot/scatterplot.rb, line 5
                def scatterplot(*args,
                                canvas: :braille,
                                color: :auto,
                                name: "",
                                **kw)
  case args.length
  when 1
    # y only
    y = Array(args[0])
    x = Array(1 .. y.length)
  when 2
    # x and y
    x = Array(args[0])
    y = Array(args[1])
  else
    raise ArgumentError, "worng number of arguments"
  end

  plot = Scatterplot.new(x, y, canvas, **kw)
  scatterplot!(plot, x, y, color: color, name: name)
end

# File lib/unicode_plot/scatterplot.rb, line 27
                def scatterplot!(plot,
                                 *args,
                                 color: :auto,
                                 name: "")
  case args.length
  when 1
    # y only
    y = Array(args[0])
    x = Array(1 .. y.length)
  when 2
    # x and y
    x = Array(args[0])
    y = Array(args[1])
  else
    raise ArgumentError, "worng number of arguments"
  end

  color = color == :auto ? plot.next_color : color
  plot.annotate!(:r, name.to_s, color: color) unless name.nil? || name == ""
  plot.points!(x, y, color)
  plot
end

# File lib/unicode_plot/stairs.rb, line 52
                def stairs(xvec, yvec, style: :post, **kw)
  x_vex, y_vex = compute_stair_lines(xvec, yvec, style: style)
  lineplot(x_vex, y_vex, **kw)
end

# File lib/unicode_plot/stairs.rb, line 58
                def stairs!(plot, xvec, yvec, style: :post, **kw)
  x_vex, y_vex = compute_stair_lines(xvec, yvec, style: style)
  lineplot!(plot, x_vex, y_vex, **kw)
end

# File lib/unicode_plot/stemplot.rb, line 323
def stemplot(*args, scale: 10, **kw)
  case args.length
  when 1
    # Stemplot object
    plt = Stemplot.factory(args[0], scale: scale, **kw)
    # Dispatch to plot routine
    stemplot1!(plt, scale: scale, **kw)
  when 2
    # Stemplot object
    plt1 = Stemplot.factory(args[0], scale: scale)
    plt2 = Stemplot.factory(args[1], scale: scale)
    raise ArgumentError, "Plot types must be the same for back-to-back stemplot " +
          "#{plt1.class} != #{plt2.class}" unless plt1.class == plt2.class
    # Dispatch to plot routine
    stemplot2!(plt1, plt2, scale: scale, **kw)
  else
    raise ArgumentError, "Expecting one or two arguments"
  end
end

# File lib/unicode_plot/stemplot.rb, line 233
def stemplot1!(plt, 
               scale: 10,
               divider: "|",
               padchar: " ",
               trim: false,
               **_kw
              )

  stem_labels = plt.stems(all: !trim)
  label_len = stem_labels.map(&:length).max
  column_len = label_len + 1
  
  stem_labels.each do |stem|
    leaves = plt.leaves(stem).sort
    stemlbl = stem.rjust(label_len, padchar).ljust(column_len, padchar)
    puts stemlbl + divider + padchar + leaves.join
  end
  plt.print_key(scale, divider)
end

# File lib/unicode_plot/stemplot.rb, line 265
def stemplot2!(plt1, plt2,
               scale: 10,
               divider: "|",
               padchar: " ",
               trim: false,
               **_kw
              )
  stem_labels = plt1.class.sorted_stem_list( (plt1.raw_stems + plt2.raw_stems).uniq, all: !trim )
  label_len = stem_labels.map(&:length).max
  column_len = label_len + 1

  leftleaf_len = plt1.max_stem_length

  stem_labels.each do |stem|
    left_leaves = plt1.leaves(stem).sort.join('')
    right_leaves = plt2.leaves(stem).sort.join('')
    left_leaves_just = left_leaves.reverse.rjust(leftleaf_len, padchar)
    stem = stem.rjust(column_len, padchar).ljust(column_len+1, padchar)
    puts left_leaves_just + padchar + divider + stem + divider + padchar + right_leaves
  end

  plt1.print_key(scale, divider)

end