module Mizlab

# File lib/mizlab.rb, line 78
def calculate_coordinates(sequence, mappings,
                          weights = nil, window_size = nil)
  # error detections
  if weights.is_a?(Hash) && window_size.nil?
    keys = weights.keys
    expect_window_size = keys[0].length
    if keys.any? { |k| k.length != expect_window_size }
      raise TypeError, "When not give `window_size`, `weights` must have same length keys"
    end
  end
  n_dimention = mappings.values[0].length
  if mappings.values.any? { |v| v.length != n_dimention }
    raise TypeError, "All of `mappings`.values must have same size"
  end

  mappings.each do |k, v|
    mappings[k] = v.map(&:to_f)
  end

  window_size = (if window_size.nil?
    unless weights.nil?
      weights.keys[0].length
    else
      3 # default
    end
  else
    window_size
  end)
  window_size -= 1
  weights = weights.nil? ? {} : weights
  weights.default = 1.0
  coordinates = Array.new(n_dimention) { [0.0] }
  sequence.length.times do |idx|
    start = idx < window_size ? 0 : idx - window_size
    vector = mappings[sequence[idx]].map { |v| v * weights[sequence[start..idx]] }
    vector.each_with_index do |v, j|
      coordinates[j].append(coordinates[j][-1] + v)
    end
  end
  return coordinates
end

# File lib/mizlab.rb, line 154
def fetch_taxon(taxonid)
  taxonid = taxonid.is_a?(Array) ? taxonid : [taxonid]
  taxonid.each do |id|
    obj = Bio::NCBI::REST::EFetch.taxonomy(id, "xml")
    hashed = xml_to_hash(REXML::Document.new(obj).root)
    if block_given?
      yield hashed[:TaxaSet][:Taxon][:LineageEx][:Taxon]
    else
      return hashed[:TaxaSet][:Taxon][:LineageEx][:Taxon]
    end
  end
end

# File lib/mizlab.rb, line 16
def getent(accessions, is_protein = false)
  accessions = accessions.is_a?(String) ? [accessions] : accessions
  accessions.each do |acc|
    ret = is_protein ? fetch_protein(acc) : fetch_nucleotide(acc)
    if block_given?
      yield ret
    else
      return ret
    end
    sleep(0.37) # Using 0.333... seconds, sometimes hit the NCBI rate limit
  end
end

# File lib/mizlab.rb, line 34
def getobj(accessions, is_protein = false)
  getent(accessions, is_protein) do |entry|
    parse(entry) do |o|
      if block_given?
        yield o
      else
        return o
      end
    end
  end
end

# File lib/mizlab.rb, line 124
def local_patterns(x_coordinates, y_coordinates)
  length = x_coordinates.length
  if length != y_coordinates.length
    raise TypeError, "The arguments must have same length."
  end

  filled_pixs = Set.new
  x_coordinates[...-1].zip(y_coordinates[...-1],
                           x_coordinates[1...],
                           y_coordinates[1...]) do |x_start, y_start, x_end, y_end|
    bresenham(x_start.truncate, y_start.truncate,
              x_end.truncate, y_end.truncate).each do |pix|
      filled_pixs.add("#{pix[0]}##{pix[1]}")
      # NOTE:
      # In set or hash, if including array make it so slow.
      # Prevend it by converting array into symbol or freezed string.
    end
  end

  local_pattern_list = [0] * 512
  get_patterns(filled_pixs) do |pattern|
    local_pattern_list[pattern] += 1
  end
  return local_pattern_list
end

# File lib/mizlab.rb, line 50
def savefile(filename, obj)
  if File.exists?(filename)
    yes = Set.new(["N", "n", "no"])
    no = Set.new(["Y", "y", "yes"])
    loop do
      print("#{filename} exists already. Overwrite? [y/n] ")
      inputed = gets.rstrip
      if yes.include?(inputed)
        return
      elsif no.include?(inputed)
        break
      end
      puts("You should input 'y' or 'n'")
    end
  end
  File.open(filename, "w") do |f|
    obj.tags.each do |t|
      f.puts(obj.get(t))
    end
  end
end

# File lib/mizlab.rb, line 224
def bresenham(x0, y0, x1, y1)
  if ![x0, y0, x1, y1].all? { |v| v.is_a?(Integer) }
    raise TypeError, "All of arguments must be Integer"
  end

  dx = x1 - x0
  dy = y1 - y0
  step_x = dx.positive? ? 1 : -1
  step_y = dy.positive? ? 1 : -1
  dx, dy = [dx, dy].map { |x| (x * 2).abs }

  lines = [[x0, y0]]

  if dx > dy
    fraction = dy - dx / 2
    while x0 != x1
      if fraction >= 0
        y0 += step_y
        fraction -= dx
      end
      x0 += step_x
      fraction += dy
      lines << [x0, y0]
    end
  else
    fraction = dx - dy / 2
    while y0 != y1
      if fraction >= 0
        x0 += step_x
        fraction -= dx
      end
      y0 += step_y
      fraction += dx
      lines << [x0, y0]
    end
  end
  return lines
end

# File lib/mizlab.rb, line 173
def fetch_nucleotide(accession)
  return Bio::NCBI::REST::EFetch.nucleotide(accession)
end

# File lib/mizlab.rb, line 169
def fetch_protein(accession)
  return Bio::NCBI::REST::EFetch.protein(accession)
end

# File lib/mizlab.rb, line 209
def get_centers(focused_x, focused_y)
  -1.upto(1) do |dy|
    1.downto(-1) do |dx|
      yield "#{focused_x + dx}##{focused_y + dy}"
    end
  end
end

# File lib/mizlab.rb, line 180
def get_patterns(filleds)
  unless filleds.is_a?(Set)
    raise TypeError, "The argument must be Set"
  end

  centers = Set.new
  filleds.each do |focused|
    x, y = focused.split("#").map(&:to_i)
    get_centers(x, y) do |center|
      if centers.include?(center)
        next
      end
      centers.add(center)
      binary = ""
      x, y = center.split("#").map(&:to_i)
      -1.upto(1) do |dy|
        1.downto(-1) do |dx|
          binary += filleds.include?("#{x + dx}##{y + dy}") ? "1" : "0"
        end
      end
      yield binary.to_i(2)
    end
  end
end

# File lib/mizlab.rb, line 266
def parse(entries)
  Bio::FlatFile.auto(StringIO.new(entries)).each_entry do |e|
    yield e
  end
end

# File lib/mizlab.rb, line 275
def xml_to_hash(element)
  value = (if element.has_elements?
    children = {}
    element.each_element do |e|
      children.merge!(xml_to_hash(e)) { |k, v1, v2| v1.is_a?(Array) ? v1 << v2 : [v1, v2] }
    end
    children
  else
    element.text
  end)
  return { element.name.to_sym => value }
end