#!/usr/bin/ruby
require "yaml"
require "erb"

class TODO < RuntimeError
end

def load_const(name, value, desc)
  "    # #{desc.to_s.chomp}\n" \
  "    Lignite::#{name} = #{value.inspect}\n\n"
end

def rendered_file(yml_hash)
  op_hash = yml_hash["ops"]

  result = <<RUBY
# This file is generated from ev3.yml. DO NOT EDIT.

module Lignite
  # Bytecodes implemented by EV3
  module Ev3Ops
#{rendered_ops(op_hash).chomp}
  end
end
RUBY
  result
end

# @return [String] Ruby code
def rendered_ops(op_hash)
  ss = op_hash.map do |oname, odata|
    rendered_op2(oname, odata)
  end
  ss.join "\n"
end

# @param oname [String] "PROGRAM_STOP"
# @return [String] Ruby code
def rendered_op2(oname, odata)
  ovalue = odata["value"]
  oparams = odata["params"]
  p1 = oparams.first
  if p1 && p1["type"] == "SUBP"
    commands = p1["commands"]
    s = ""
    commands.each do |cname, cdata|
      cdesc = cdata["desc"]
      cvalue = cdata["value"]
      s << load_const(cname, cvalue, cdesc)
      cparams = cdata["params"]
      s << rendered_op4("#{oname}_#{cname}".downcase, cdesc, ovalue, cvalue, cparams)
    end
    s << rendered_multiop(oname, commands)
    s
  else
    rendered_op4(oname.downcase, odata["desc"], ovalue, nil, oparams)
  end
end

# @return [String] Ruby code
def rendered_multiop(oname, commands)
  names = commands.map do |cname, cdata|
    csym = cname.downcase.to_sym
    cvalue = cdata["value"]
    [cvalue, csym]
  end.to_h

  osym = oname.downcase.to_sym

  multiplex_values = names.map do |cvalue, csym|
    "      #{cvalue} => #{csym.inspect},\n"
  end

  result = <<RUBY

    MULTIPLEX_#{oname} = {
#{multiplex_values.join("").chomp}
    }.freeze

    def #{osym}(*args)
      logger.debug "called #{osym} with \#{args.inspect}"
      cvalue = args.shift
      csym = MULTIPLEX_#{oname}.fetch(cvalue)
      __send__("#{osym}_\#{csym}", *args)
    end
RUBY
  result
end

def param_handler(par)
  par_type = par["type"]
  case par_type
  when "PAR8", "PAR16", "PAR32", "PARF"
    :param_simple
  when "PARNO"
    :param_multiple
  else
    raise TODO, "Unhandled param type #{par_type}"
  end
end

# @return [String] Ruby code
def method_docs(odesc, params)
  ss = params.map do |p|
    n = p["name"].downcase
    t = p["type"]
    "    # @param #{n} [#{t}] (#{p["dir"]}) #{p["desc"]}\n"
  end
  "    # #{odesc.to_s.chomp}\n" + ss.join("")
end

# @param oname [String] "move32_32"
# @param ovalue [Integer] 0x3A
# @param cvalue [Integer,nil]
# @return [String] Ruby code
def rendered_op4(oname, odesc, ovalue, cvalue, params) # rubocop:disable Metrics/MethodLength
  s = ""

  param_handlers = params.map { |par| param_handler(par) }

  param_names = params.map do |par|
    (par["type"] == "PARNO" ? "*" : "") + par["name"].downcase
  end
  param_decl = param_names.join ", "
  param_decl = "(#{param_decl})" unless param_decl.empty?

  s << method_docs(odesc, params)
  s << <<RUBY
    def #{oname}#{param_decl}
      logger.debug do
        args = [#{param_names.join ", "}]
        "called #{oname} with \#{args.inspect}"
      end

      bytes = u8(#{format("0x%02X", ovalue)})
RUBY
  s << "      bytes += param_simple(#{cvalue})\n" unless cvalue.nil?
  param_names.zip(param_handlers).each do |pname, phand|
    s << "      bytes += #{phand}(#{pname})\n"
  end
  s << <<RUBY
      logger.debug "returning bytecode: \#{bytes.inspect}"
      bytes
    end
RUBY
  s
rescue TODO => e
  "    # Could not define #{oname}: #{e.message}\n"
end

def whitespace_cleanup(s)
  s.lines.map(&:rstrip).join("\n") + "\n"
end

def render_erb_file(erb_filename, a_binding)
  safe = nil
  trim = "<>-"
  erb = ERB.new(File.read(erb_filename), safe, trim)
  out_filename = erb_filename.sub(/\.erb$/, "")
  header = "# This file is generated from its .erb template. DO NOT EDIT.\n\n"
  rendered = erb.result(a_binding)
  rendered = whitespace_cleanup(rendered)
  File.write(out_filename, header + rendered)
end

# run this via "rake ops"
yml = YAML.load_file(ARGV[0])
out_fn = ARGV[1]

rendered = rendered_file(yml)
rendered = whitespace_cleanup(rendered)
File.write(out_fn, rendered)

libdir = File.expand_path("..", out_fn)
render_erb_file("#{libdir}/defines.rb.erb", binding)
render_erb_file("#{libdir}/enums.rb.erb", binding)