module WebIDL
  class RubySexpVisitor

    def visit_module(mod)
      [:block,
        [:module, classify(mod.name),
          [:scope,
            [:block] + mod.definitions.map { |d| d.accept(self) }
          ]
        ]
      ]
    end

    def visit_interface(intf)
      [:module, classify(intf.name),
        ([:scope, [:block] + intf.inherits.map { |inherit| [:call, nil, :include, [:arglist, inherit.accept(self)]] }] unless intf.inherits.empty?),
        [:scope,
          [:block] + intf.members.map { |m| m.accept(self) }
        ]
      ].compact
    end

    def visit_dictionary(dict)
      [:module, classify(dict.name),
        ([:scope, [:block] + dict.inherits.map { |inherit| [:call, nil, :include, [:arglist, inherit.accept(self)]] }] unless dict.inherits.empty?),
        [:scope,
          [:block] + dict.members.map { |m| m.accept(self) }
        ]
      ].compact
    end

    def visit_exception(ex)
      [:class, classify(ex.name), [:const, :StandardError],
        [:scope,
          [:block] + ex.members.map { |m| m.accept(self)}
        ]
      ]
    end

    def visit_const(const)
      [:cdecl, const.name, [:lit, const.value]] # FIXME: won't always be literals - need Literal AST node?
    end

    def visit_enum(enum)
      [:cdecl, enum.name, [:lit, enum.values]]
    end

    def visit_field(field)
      [:call, nil, :attr_accessor, [:arglist, [:lit, field.name.to_sym]]]
    end

    def visit_attribute(attribute)
      func = attribute.readonly? ? :attr_reader : :attr_accessor
      [:call, nil, func, [:arglist, [:lit, attrify(attribute.name).to_sym]]]
    end

    def visit_dictionary_member(mem)
      [:call, nil, :attr_accessor, [:arglist, [:lit, attrify(mem.name).to_sym]]]
    end

    def visit_callback(callback)
      arguments = callback.arguments.map { |a| [:lit, attrify(a.name).to_sym] }

      [:defn, callback.name,
        [:args] + callback.arguments.map { |a| a.accept(self) },
        [:scope,
          [:block,
            [:call, nil, :raise,
              [:arglist,
                [:const, :NotImplementedError]
              ]
            ]
          ]
        ]
      ]
    end

    def visit_operation(operation)
      if operation.name.empty?
        if operation.setter?
          meth = :[]=
        elsif operation.getter?
          meth = :[]
        elsif operation.creator?
          meth = :initialize
        elsif operation.stringifier?
          meth = :to_s
        elsif operation.deleter?
          meth = :delete!
        elsif operation.legacycaller?
          meth = operation.parent.name
        else
          raise "no name for operation #{operation.inspect}"
        end
      else
        meth = attrify(operation.name)
        meth << "=" if operation.setter?
      end

      [:defn, meth.to_sym,
        [:args] + operation.args.map { |a| a.accept(self) },
        [:scope,
          [:block,
            [:call, nil, :raise,
              [:arglist,
                [:const, :NotImplementedError]
              ]
            ]
          ]
        ]
      ]
    end

    def visit_argument(argument)
      name = attrify(argument.name)
      arg = argument.variadic? ? "*#{name}" : name

      arg.to_sym
    end

    def visit_type_def(typedef)
      # don't care
    end

    def visit_implements_statement(impls)
      [:module, classify(impls.implementor),
        [:scope,
          [:call, nil, :include,
            [:arglist,
              [:const, classify(impls.implementee)]
            ]
          ]
        ]
      ]
    end

    def visit_includes_statement(incls)
      [:module, classify(incls.includer),
        [:scope,
          [:call, nil, :include,
            [:arglist,
              [:const, classify(impls.includee)]
            ]
          ]
        ]
      ]
    end

    def visit_scoped_name(sn)
      [:const, classify(sn.qualified_name)]
    end

    private

    def classify(string)
      s = string.to_s

      if s.include?("::")
        s.split("::").map { |e| classify(e) unless e.empty? }.compact.join("::").to_sym
      else
        "#{s.slice(0,1).upcase}#{s[1..-1]}".to_sym
      end
    end

    RESERVED = %w[
      BEGIN	do	next	then
      END	else	nil	true
      alias	elsif	not	undef
      and	end	or	unless
      begin	ensure	redo	until
      break	false	rescue	when
      case	for	retry	while
      class	if	return	while
      def	in	self	__FILE__
      defined?	module	super	__LINE__
    ]

    def attrify(string)
      attr = string.snake_case
      attr += '_' if RESERVED.include?(attr)

      attr
    end

  end # RubySexpVisitor
end # WebIDL