#!/usr/bin/env ruby
# ======================================================================
# faust2sc - Generate language modules from Faust XML.
# Copyright (C) 2005-2008 Stefan Kersten
# ======================================================================
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
# USA
# ======================================================================

# TODO:
#  rexml is dog slow, maybe use libxml?

require 'getoptlong'
require 'rexml/document'

PROGRAM         = File.basename($0)
PROGRAM_VERSION = "1.1.0"

class Array
  def flatten1
    res = []
    self.each { |l|
      res += l
    }
    res
  end
end

module REXML
  class Element
    def to_i
      self.text.to_i
    end
    def to_f
      self.text.to_f
    end
  end
end

class String
  def encapitalize
    self[0..0].upcase + self[1..-1]
  end
  def decapitalize(greedy=false)
    unless greedy
      self[0..0].downcase + self[1..-1]
    else
      res = self.clone
      (0..res.size-1).each { |i|
        c = res[i]
        if 65 <= c && c <= 90
          res[i] = c + 32
        else
          break
        end
      }
      res
    end
  end
end

def print_error(str)
  $stderr.print("#{PROGRAM}[ERROR] #{str}")
end

def print_info(str)
  $stderr.print("#{PROGRAM}[INFO]  #{str}")
end

module Faust
  class Widget
    attr_reader :type, :id, :label, :init, :min, :max, :step
    def initialize(node)
      @type = node.attributes["type"]
      @id   = node.attributes["id"]
      if (node.elements["label"].text)
        @label = node.elements["label"].text
      else
        print_info("No label for widget ID #{id} - calling it widget#{id}\n")
        @label = "widget#{id}"
      end
      if (@label =~ /^[0-9]/)
        plabel = @label
        @label = @type + "_" + @label
        print_info("Widget label `#{plabel}' prefixed to become `#{@label}'\n")
      end
      dict = node.elements
      @init = dict["init"].to_f
      @min  = dict["min"].to_f
      @max  = dict["max"].to_f
      @step = dict["step"].to_f
      if (@type == "button")
        @max  = 1 # no metadata other than name for buttons
        @step = 1
      end
    end
  end

  class UI
    attr_reader :active_widgets, :passive_widgets
    def initialize(node)
      @active_widgets  = node.get_elements("//activewidgets/widget").collect  { |x| Widget.new(x) }
      @passive_widgets = node.get_elements("//passivewidgets/widget").collect { |x| Widget.new(x) }
    end
  end

  class Plugin
    attr_reader :path, :name, :author, :copyright, :license, :inputs, :outputs, :ui
    def initialize(path, node)
      @path = path
      %w(name author copyright license).each { |name|
        instance_variable_set("@#{name}", node.elements["/faust/#{name}"].text)
      }
      %w(inputs outputs).each { |name|
        instance_variable_set("@#{name}", node.elements["/faust/#{name}"].text.to_i)
      }
      @ui = UI.new(node.elements["/faust/ui"])
    end
    def total_inputs
      inputs + ui.active_widgets.size
    end
    def Plugin::from_file(path)
      self.new(path, REXML::Document.new(File.open(path) { |io| io.read }))
    end
  end

  class Generator
    attr_reader :plugins, :options
    def initialize(plugins, options)
      @plugins = plugins
      @options = options
    end
    def lang
      "unknown"
    end
    def generate(io)
      generate_header(io)
      generate_body(io)
      generate_footer(io)
    end
    def generate_header(io)
    end
    def generate_footer(io)
    end
    def generate_body(io)
      plugins.each_with_index { |plugin,i|
        if plugin
          begin
            print_info("Generating #{lang} code for #{plugin.name} ...\n")
            generate_plugin(io, plugin)
            if i < (plugins.size - 1)
              io.print("\n")
            end
          rescue
            print_error("#{$!}\n")
            $!.backtrace.each { |l| print_error(l + "\n") }
            print_error("Omitting #{plugin.path}\n")
          end
        end
      }
      io.print("\n")
    end
    def generate_plugin(io, plugin)
      raise "#{self.class}::generate_plugin() missing!"
    end
  end
  
  module Language
    IDENTIFIER_REGEXP = /^[a-z][a-zA-Z0-9_]*[a-zA-Z0-9]?$/
    def make_identifier(name)
      # gentle identifier massage
      # remove quotes
      name = name.sub(/^"([^"]*)"/, "\\1")
      # replace invalid chars with underscores
      name = name.downcase.gsub(/[^a-zA-Z0-9_]/, "_")
      # reduce multiple underscores to one
      name = name.gsub(/__+/, "_")
      # remove leading/terminating underscores
      name = name.sub(/(^_|_$)/, "")
      # move leading digits to the end
      name = name.sub(/^([0-9]+)_/, "") + ("_#{$1}" if $1).to_s
      # if digit(s) only, prepend alpha prefix
      if (name[0..0] =~ /^[0-9]/)
        pname = name
        name = "w" + name
        print_info("Widget label `#{pname}' prefixed to become `#{name}'\n")
      end
      unless name =~ IDENTIFIER_REGEXP
        raise "invalid identifier: \"#{name}\""
      end
      name
    end
    def make_unique(list)
      # bad, bad, bad
      list = list.clone
      res = []
      ids = {}
      while hd = list.shift
        if ids.has_key?(hd)
          ids[hd] = id = ids[hd] + 1
        else
          if list.include?(hd)
            ids[hd] = id = 0
          end
        end
        res << (id ? "#{hd}_#{id}" : hd)
      end
      res
    end
    module_function :make_identifier, :make_unique
  end
  
  module Haskell
    INDENT = " " * 4
    
    def mk_function_names(plugin)
      fname = plugin.name.decapitalize(true)
      lname = fname + "'"
      [lname, fname]
    end
    module_function :mk_function_names
    
    class PluginGenerator
      attr_reader :plugin
      def initialize(plugin)
        @plugin = plugin
      end
      def generate(io)
        lname, fname = Haskell.mk_function_names(plugin)
        gen_curry_func(io, lname, fname)
        io << "\n"
        gen_list_func(io, lname)
      end
      def gen_ugen(io, name, rate, inputs, num_outputs)
        io << "UGen.mkUGen #{rate} \"#{name}\" #{inputs} (replicate #{num_outputs} #{rate}) (UGen.Special 0) Nothing"
        io << "\n"
      end
      def gen_curry_func(io, lname, fname)
        args = mk_args(plugin.total_inputs)
        decs = args.collect { "UGen" } + ["UGen"] # add result type
        io << "#{fname} :: #{decs.join(" -> ")}\n"
        io << "#{fname} #{args.join(" ")} = #{lname} [#{args.join(',')}]\n"
      end
      def gen_list_func(io, fname)
        io << "#{fname} :: [UGen] -> UGen\n"
        io << "#{fname} args = "
        gen_ugen(io, plugin.name, "UGen.AR", "args", plugin.outputs)
      end
      
      protected
      def mk_args(n, x="x")
        (1..n).collect { |i| "#{x}#{i}" }
      end
    end # PluginGenerator
    
    class Generator < Faust::Generator
      def initialize(plugins, options)
        super(plugins, options)
        @module = options["prefix"]
      end
      def lang
        "haskell"
      end
      def generate_header(io)
        gen_module(io, plugins.collect { |p| Haskell.mk_function_names(p) }.flatten1)
        io << "\n"
        gen_imports(io)
        io << "\n"
      end
      def generate_plugin(io, plugin)
        PluginGenerator.new(plugin).generate(io)
      end
      def gen_module(io, exports)
        #m = @module.empty? ? "" : @module + "."
        #io << "module #{m}#{plugin.name.encapitalize} (\n"
        io << "module #{@module.empty? ? "Main" : @module} (\n"
        io << exports.collect { |x| (INDENT * 1) + x }.join(",\n") << "\n"
        io << ") where\n"
      end
      def gen_imports(io)
        io << "import Sound.SC3.UGen (UGen)\n"
        io << "import qualified Sound.SC3.UGen as UGen\n"
      end
    end
  end
  
  module SC3
    include Language
    
    CLASS_REGEXP = /^[A-Z][a-zA-Z0-9_]*[a-zA-Z0-9]?$/

    def path_to_unitname(path)
      name = File.basename(path)
      if ext_index = name.index(".")
        name = name[0..ext_index-1]
      end
      name
    end
    def make_class_name(unit_name, prefix)
      # The SuperCollider UGen class name generated here must match 
      # that generated in the Faust architecture file supercollider.cpp
      class_name = unit_name
      class_name = class_name.sub(/^#{prefix}/i, '')
      if prefix != ""
        class_name = prefix + '_' + class_name
      end
      cna = class_name.split(/[^0-9a-z]/i)
      cna.each_index { |i| cna[i] = cna[i].encapitalize } # SC name convention
      class_name = cna.join
      print_info(unit_name + " -> " + class_name + "\n")
      if class_name.length > 31 # maximum SC Node ID length is 31 (hashed)
        print_info("Class name `#{class_name}' truncated to 1st 31 chars\n")
        class_name = class_name[0,30]
      end
      unless class_name =~ CLASS_REGEXP
        raise "invalid class name: \"#{class_name}\""
      end
      class_name
    end
    module_function :path_to_unitname, :make_class_name

    class Faust::Widget
      def sc3_identifier
        l = self.label
        l = l.gsub(/\([^\)]*\)/, '')
        l = Language.make_identifier(l)
        if l.length > 30 # maximum SC ParamSpec length is 31 (hashed)
          lt = l[0,29]   # leave a final char for make_unique
          print_info("Label `#{l}' for #{self.type} #{self.id} truncated to " +
                     "`#{lt}' (30 chars)\n")
          l = lt
        end
        l
      end
      def sc3_arg_string
        "#{self.sc3_identifier}(#{self.init})"
      end
      def sc3_default
        "(#{self.init})"
      end
      def sc3_default2
        "=(#{self.init})" # Parens make unary minus work in SC
      end
    end

    class PluginGenerator
      attr_reader :unit_name, :class_name
      def initialize(plugin, options)
        @plugin     = plugin
        @options    = options
        @unit_name  = plugin.name || SC3::path_to_unitname(plugin.path)
        @class_name = SC3::make_class_name(@unit_name, options["prefix"])
      end
      def inputs
        @plugin.inputs
      end
      def outputs
        @plugin.outputs
      end
      def superclass_name
        @plugin.outputs > 1 ? "MultiOutUGen" : "UGen"
      end
      def input_names
        (1..self.inputs).collect { |i| "in#{i}" }
      end
      def control_names
        Language::make_unique(@plugin.ui.active_widgets.collect { |x| x.sc3_identifier })
      end
      def decl_args # "name(default)"
        cnames = self.control_names
        cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
        args = self.input_names + cnames.zip(cdefaults).collect { |ary| ary[0] + ary[1] }
        args.empty? ? "" : " | " + args.join(", ") + " |"
      end
      def decl_args2 # "name=default"
        cnames = self.control_names
        cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default2 }
        args = self.input_names + cnames.zip(cdefaults).collect { |ary| ary[0] + ary[1] }
        args.empty? ? "" : args.join(", ") + ";"
      end
      def decl_args3 # args for SynthDef
        cnames = self.control_names
        cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
        args = self.input_names.collect { |x| "\\#{x}.ar(0)" } \
        + cnames.zip(cdefaults).collect { |x| "\\#{x[0]}.kr#{x[1]}" }
        args.empty? ? "" : args.join(", ")
      end
      def decl_buses # declare input buses for Synth
        args = self.input_names.collect { |x| \
          "  #{x}Bus = Bus.audio(s,1);\n"};
      end
      def decl_args4 # args for Synth
        cnames = self.control_names
        cdefaults = @plugin.ui.active_widgets.collect { |x| x.sc3_default }
        args = self.input_names.collect { |x| "#{x}:#{x}Bus.asMap"} \
        + cnames.collect { |x| "#{x}:#{x}Var" }
        args.empty? ? "" : "\n\t[\t" + args.join(",\n\t\t") + "\n\t]"
      end
      def decl_metadata
        cnames = self.control_names
        cnames.collect! {|x| "    \\"+x+":"}
        warp = 0
        cmeta = @plugin.ui.active_widgets.collect \
          { |x| "[#{x.min}, #{x.max}, #{warp}, #{x.step}, #{x.init}].asSpec" }
          # \\name1: [minval, maxval, warp, step, default, units].asSpec,
          # Note: could append x.units as well
        args = cnames.zip(cmeta).collect { |ary| ary[0] + ary[1] }
        args.empty? ? "" : args.join(",\n      ")
      end
      def new_args(rate)
        ["'%s'" % rate] + self.input_names + self.control_names
      end
      def validate
        args = self.input_names + self.control_names
        unless args.uniq == args
          raise "argument list not unique"
        end
        self
      end
      def generate(io)
        self.validate
        generate_decl(io)
        generate_body(io)
      end
      def generate_decl(io)
        io.print("#{@class_name} : #{self.superclass_name}\n")
        print_info("UGen: #{@class_name}\n")
      end
      def generate_body(io)
        io.print("{\n")
        body = <<EOF
  *ar {#{self.decl_args}
      ^this.multiNew(#{self.new_args(:audio).join(", ")})
  }

  *kr {#{self.decl_args}
      ^this.multiNew(#{self.new_args(:control).join(", ")})
  } 
EOF
        if self.inputs > 0
          body = body + <<EOF

  checkInputs {
    if (rate == 'audio', {
      #{self.inputs}.do({|i|
        if (inputs.at(i).rate != 'audio', {
          ^(" input at index " + i + "(" + inputs.at(i) + 
            ") is not audio rate");
        });
      });
    });
    ^this.checkValidInputs
  }
EOF
        end
        io.print(body)
        generate_outputs(io)
        if @options["synthdef"]
          generate_synthdef(io)
        end
        io.print("\n  name { ^\"#{@class_name}\" }\n")
        io.print("\n")
        io.print("\n  info { ^\"Generated with Faust\" }\n")
        io.print("}\n")
      end
      def generate_outputs(io)
        if self.outputs > 1  # add initOutputs to overridden init:
          io.print <<EOF

  init { | ... theInputs |
      inputs = theInputs
      ^this.initOutputs(#{self.outputs}, rate)
  }
EOF
        end
      end
      def generate_synthdef(io)
        s = @class_name
        sdname = s[0,1].downcase + s[1 .. s.length]
        print_info("SynthDef: \\#{sdname}\n")
# if \arg.ar(0) form not used, add after out=0: ,#{self.decl_args2}
        io.print <<EOF
  
/*
  SynthDef - Typical usage in SuperCollider:

EOF
        print_info("SynthDef: have #{self.input_names.size} inputs\n")
        if self.input_names.size>0
          io.print "#{decl_buses}\n";
        end
        io.print <<EOF
  ~synth = Synth(\\#{sdname}, #{self.decl_args4});
 */

  *initClass {
    StartUp.add {
      SynthDesc.mdPlugin = TextArchiveMDPlugin;
// When SynthDef.writeOnce writes metadata:
//    SynthDef.writeOnce(\\#{sdname},
      SynthDef(\\#{sdname},
        { |out=0|
          Out.ar(out, 
            #{@class_name}.ar(
              #{self.decl_args3}
            )
          )
        }, metadata: (specs:( 
        //\\controlName:[min, max, warp, step, default, units].asSpec,
      #{self.decl_metadata}
  ) ) ).store } }
// When SynthDef.writeOnce writes metadata:
//) ) ) } }
EOF
      end
    end
    
    class Generator < Faust::Generator
      def lang
        "sclang"
      end
      def generate_plugin(io, plugin)
        PluginGenerator.new(plugin, options).generate(io)
      end
    end
  end # module SC3
end # module Faust

def usage
  $stdout.print <<EOF
Usage: #{File.basename($0)} [OPTION]... INPUT_FILE...

Generate a language module file from FAUST generated XML.
Currently supported languages are Haskell and SuperCollider.

Options:
 -h, --help     Display this help
 -l, --lang     Set output language (haskell, sclang)
 -o, --output   Set output file name
 -p, --prefix   Set class or module prefix
 -s, --synthdef Emit SynthDef including metadata (sclang)
 -V, --version  Display version information
EOF
end

opts = GetoptLong.new(
  [ "--help",     "-h",  GetoptLong::NO_ARGUMENT ],
  [ "--lang",     "-l",  GetoptLong::REQUIRED_ARGUMENT ],
  [ "--output",   "-o",  GetoptLong::REQUIRED_ARGUMENT ],
  [ "--prefix",   "-p",  GetoptLong::REQUIRED_ARGUMENT ],
  [ "--synthdef", "-s",  GetoptLong::NO_ARGUMENT ],
  [ "--version",  "-V",  GetoptLong::NO_ARGUMENT ]
)

LANG_MAP = {
  "sclang"  => Faust::SC3::Generator,
  "haskell" => Faust::Haskell::Generator
}

lang = "sclang"
generator = nil
output_file = nil

options = {
  "prefix" => "",
  "synthdef" => false
}

opts.each { | opt, arg |
  case opt
  when "--help"
    usage
    exit(0)
  when "--lang"
    lang = arg
  when "--output"
    output_file = arg
  when "--prefix"
    options["prefix"] = arg
    options["module"] = arg
  when "--synthdef"
    options["synthdef"] = true
  when "--version"
    puts "#{PROGRAM} #{PROGRAM_VERSION}"
    exit(0)
  end
}

if LANG_MAP.key?(lang)
  generator = LANG_MAP[lang]
else
  print_error("unknown output language #{lang}\n")
  exit(1)
end

if output_file
  output = File.open(output_file, "w")
else
  output = $stdout
end

plugins = ARGV.collect { |file|
  begin
    print_info("Parsing #{file} ...\n")
    Faust::Plugin.from_file(file)
  rescue
    print_error("#{$!}\n")
    print_error("Omitting #{file}\n")
  end
}

begin
  generator.new(plugins, options).generate(output)
ensure
  output.close unless output === $stdout
end

# EOF
