module Vrobot4::Module
   class Command
      attr_reader :help_str

      def initialize fn, help, roles
         @function = fn
         @help_str = help
         @roles    = /[#{roles}]/
      end

      def usable_in? m, type
         chan = m.chan.name
         role = m.user.roles
         mprm = m.serv.mprm
         retm = true
         retc = false
         retr = false
         retm = mprm[:glob][type]                  if mprm[:glob].key? type
         retc = mprm[:chan][type].key? chan        if mprm[:chan].key? type
         retr = mprm[:role][type].scan /[#{role}]/ if mprm[:role].key? type
         role.scan(@roles).any? && (retm || retc || retr)
      end

      def run m, argv
         @function.call(m, argv)
      end
   end

   class Module
      def initialize info
         @commands = {}
         @info = info
         Vrobot4.log :DEBUG, "initialized", self.to_s
      end

      def register fn, cnam, help, roles: "v"
         @commands[cnam] = Command.new(self.method(fn), help, roles).freeze
      end

      def onMessage m
         false
      end

      def onCommand m, cnam, argv
         if (cmd = get_cmd m, cnam)
            begin;  cmd.run(m, argv)
            rescue; m.reply "Error:", $!.to_s; end
            return true
         else
            return false
         end
      end

      def all_cmds m
         @commands.select {|name, cmd| cmd.usable_in? m, self.class}
      end

      def get_cmd m, name
         cmds = all_cmds(m)
         cmds[name] if cmds.key? name
      end

      protected
      def check_args argv, req, opt = ""
         if argv.length < req.length
            raise ArgumentError, "Not enough arguments"
         elsif argv.length > req.length + opt.length
            raise ArgumentError, "Too many arguments"
         else
            (0...req.length).each do |i|
               check_arg argv[i], i, req[i]
            end

            (0...argv.length - req.length).each do |i|
               check_arg argv[i + req.length], i + req.length, opt[i]
            end
         end
      end

      private
      def check_arg arg, i, req
         case req
         when 'N'
            unless Vrobot4.is_num? arg
               raise ArgumentError, "Expected a number for arg " + i.to_s
            end
         end
      end
   end

   @@module_types = {}

   def self.add_module_type type, server: nil, servflags: nil
      @@module_types[type.type] = {
         type:      type,
         server:    server,
         servflags: servflags ? /[#{servflags}]/ : nil
      }
      Vrobot4.log :INFO, "added module type:", type.type
   end

   def self.get_module_type s
      @@module_types[s]
   end
end

## EOF