module BinData
  # Extracts args for Records and Buffers.
  #
  # Foo.new(:bar => "baz) is ambiguous as to whether :bar is a value or parameter.
  #
  # BaseArgExtractor always assumes :bar is parameter.  This extractor correctly
  # identifies it as value or parameter.
  module MultiFieldArgSeparator
    def separate_args(obj_class, obj_args)
      value, parameters, parent = super(obj_class, obj_args)

      if parameters_is_value?(obj_class, value, parameters)
        value = parameters
        parameters = {}
      end

      [value, parameters, parent]
    end

    def parameters_is_value?(obj_class, value, parameters)
      if value.nil? and parameters.length > 0
        field_names_in_parameters?(obj_class, parameters)
      else
        false
      end
    end

    def field_names_in_parameters?(obj_class, parameters)
      field_names = obj_class.fields.field_names
      param_keys = parameters.keys

      (field_names & param_keys).length > 0
    end
  end

  # BinData classes that are part of the DSL must be extended by this.
  module DSLMixin
    def dsl_parser(parser_type = nil)
      unless defined? @dsl_parser
        parser_type = superclass.dsl_parser.parser_type if parser_type.nil?
        @dsl_parser = DSLParser.new(self, parser_type)
      end
      @dsl_parser
    end

    def method_missing(symbol, *args, &block) #:nodoc:
      dsl_parser.__send__(symbol, *args, &block)
    end

    # Assert object is not an array or string.
    def to_ary; nil; end
    def to_str; nil; end

    # A DSLParser parses and accumulates field definitions of the form
    #
    #   type name, params
    #
    # where:
    #   * +type+ is the under_scored name of a registered type
    #   * +name+ is the (possible optional) name of the field
    #   * +params+ is a hash containing any parameters
    #
    class DSLParser
      def initialize(the_class, parser_type)
        raise "unknown parser type #{parser_type}" unless parser_abilities[parser_type]

        @the_class      = the_class
        @parser_type    = parser_type
        @validator      = DSLFieldValidator.new(the_class, self)
        @endian_handler = DSLBigAndLittleEndianHandler.new(the_class)
        @endian         = nil
      end

      attr_reader :parser_type

      def endian(endian = nil)
        if endian
          set_endian(endian)
        elsif @endian.nil?
          pendian = parent_attribute(:endian, nil)
          set_endian(pendian) if pendian
        end
        @endian
      end

      def hide(*args)
        if option?(:hidden_fields)
          hidden = args.collect { |name| name.to_sym }

          unless defined? @hide
            @hide = parent_attribute(:hide, []).dup
          end

          @hide.concat(hidden.compact)
          @hide
        end
      end

      def fields
        unless defined? @fields
          fields = @endian_handler.ancestor_fields || parent_attribute(:fields)
          @fields = SanitizedFields.new(endian)
          @fields.copy_fields(fields) if fields
        end

        @fields
      end

      def dsl_params
        send(parser_abilities[@parser_type].at(0))
      end

      def method_missing(*args, &block)
        if endian == :big_and_little
          @endian_handler.forward_field_definition(*args, &block)
        else
          parse_and_append_field(*args, &block)
        end
      end

      #-------------
      private

      def parser_abilities
        @abilities ||= {
          :struct    => [:to_struct_params, [:multiple_fields, :optional_fieldnames, :hidden_fields]],
          :array     => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
          :buffer    => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
          :choice    => [:to_choice_params, [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
          :primitive => [:to_struct_params, [:multiple_fields, :optional_fieldnames]]
        }
      end

      def option?(opt)
        parser_abilities[@parser_type].at(1).include?(opt)
      end

      def set_endian(endian)
        if has_fields?
          dsl_raise SyntaxError, "endian must not be called after defining fields"
        end
        if not valid_endian?(endian)
          dsl_raise ArgumentError, "unknown value for endian '#{endian}'"
        end

        if endian == :big_and_little
          @endian_handler.prepare_subclasses
        end

        @endian = endian
      end

      def has_fields?
        @fields && @fields.length > 0
      end

      def valid_endian?(endian)
        [:big, :little, :big_and_little].include?(endian)
      end

      def parent_attribute(attr, default = nil)
        parent = @the_class.superclass
        parser = parent.respond_to?(:dsl_parser) ? parent.dsl_parser : nil
        if parser and parser.respond_to?(attr)
          parser.send(attr)
        else
          default
        end
      end

      def parse_and_append_field(*args, &block)
        parser = DSLFieldParser.new(endian, *args, &block)
        begin
          @validator.validate_field(parser.name)
          append_field(parser.type, parser.name, parser.params)
        rescue Exception => err
          dsl_raise err.class, err.message
        end
      end

      def append_field(type, name, params)
        fields.add_field(type, name, params)
      rescue BinData::UnRegisteredTypeError => err
        raise TypeError, "unknown type '#{err.message}'"
      end

      def dsl_raise(exception, message)
        backtrace = caller
        backtrace.shift while %r{bindata/dsl.rb} =~ backtrace.first

        raise exception, message + " in #{@the_class}", backtrace
      end

      def to_array_params
        case fields.length
        when 0
          {}
        when 1
          {:type => fields[0].prototype}
        else
          {:type => [:struct, to_struct_params]}
        end
      end

      def to_choice_params
        if fields.length == 0
          {}
        elsif fields.all_field_names_blank?
          {:choices => fields.collect { |f| f.prototype }}
        else
          choices = {}
          fields.each { |f| choices[f.name] = f.prototype }
          {:choices => choices}
        end
      end

      def to_struct_params
        result = {:fields => fields}
        if not endian.nil?
          result[:endian] = endian
        end
        if option?(:hidden_fields) and not hide.empty?
          result[:hide] = hide
        end

        result
      end
    end

    # Handles the :big_and_little endian option.
    # This option creates two subclasses, each handling
    # :big or :little endian.
    class DSLBigAndLittleEndianHandler
      def initialize(the_class)
        @the_class = the_class
      end

      def prepare_subclasses
        create_subclasses_with_endian
        make_class_abstract
        override_new_in_class
      end

      def forward_field_definition(*args, &block)
        class_with_endian(@the_class,    :big).send(*args, &block)
        class_with_endian(@the_class, :little).send(*args, &block)
      end

      def ancestor_fields
        if subclass_of_big_and_little_endian?
          pparent = @the_class.superclass.superclass
          ancestor_with_endian = class_with_endian(pparent, @the_class.endian)
          obj_attribute(ancestor_with_endian, :fields)
        else
          nil
        end
      end

      #-------------
      private

      def create_subclasses_with_endian
        instance_eval "class ::#{@the_class}Be < ::#{@the_class}; endian :big; end"
        instance_eval "class ::#{@the_class}Le < ::#{@the_class}; endian :little; end"
      end

      def make_class_abstract
        @the_class.send(:unregister_self)
      end

      def override_new_in_class
        saved_class = @the_class
        endian_classes = {
          :big => class_with_endian(saved_class, :big),
          :little => class_with_endian(saved_class, :little),
        }
        @the_class.define_singleton_method(:new) do |*args|
          if self == saved_class
            value, options, parent = arg_processor.separate_args(self, args)
            delegate = endian_classes[options[:endian]]
            return delegate.new(*args) if delegate
          end

          super(*args)
        end
      end

      def subclass_of_big_and_little_endian?
        parent  = @the_class.superclass
        pparent = parent.superclass

        obj_attribute(parent, :endian) == :big_and_little and
        obj_attribute(pparent, :endian) == :big_and_little and
        [:big, :little].include?(@the_class.endian)
      end

      def class_with_endian(class_name, endian)
        RegisteredClasses.lookup(class_name, endian)
      end

      def obj_attribute(obj, attr, default = nil)
        parser = obj.respond_to?(:dsl_parser) ? obj.dsl_parser : nil
        if parser and parser.respond_to?(attr)
          parser.send(attr)
        else
          default
        end
      end
    end

    # Extracts the details from a field declaration.
    class DSLFieldParser
      def initialize(endian, symbol, *args, &block)
        @endian = endian
        @type   = symbol
        @name   = name_from_field_declaration(args)
        @params = params_from_field_declaration(args, &block)
      end

      attr_reader :type, :name, :params

      def name_from_field_declaration(args)
        name, params = args
        if name == "" or name.is_a?(Hash)
          nil
        else
          name
        end
      end

      def params_from_field_declaration(args, &block)
        params = params_from_args(args)

        if block_given?
          params.merge(params_from_block(&block))
        else
          params
        end
      end

      def params_from_args(args)
        name, params = args
        params = name if name.is_a?(Hash)

        params || {}
      end

      def params_from_block(&block)
        bindata_classes = {
          :array  => BinData::Array,
          :buffer => BinData::Buffer,
          :choice => BinData::Choice,
          :struct => BinData::Struct
        }

        if bindata_classes.include?(@type)
          parser = DSLParser.new(bindata_classes[@type], @type)
          parser.endian(@endian)
          parser.instance_eval(&block)

          parser.dsl_params
        else
          {}
        end
      end
    end

    # Validates a field defined in a DSLMixin.
    class DSLFieldValidator
      def initialize(the_class, parser)
        @the_class = the_class
        @dsl_parser = parser
      end

      def validate_field(name)
        if must_not_have_a_name_failed?(name)
          raise SyntaxError, "field must not have a name"
        end

        if all_or_none_names_failed?(name)
          raise SyntaxError, "fields must either all have names, or none must have names"
        end

        if must_have_a_name_failed?(name)
          raise SyntaxError, "field must have a name"
        end

        ensure_valid_name(name)
      end

      def ensure_valid_name(name)
        if name and not option?(:fieldnames_are_values)
          if malformed_name?(name)
            raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
          end

          if duplicate_name?(name)
            raise SyntaxError, "duplicate field '#{name}'"
          end

          if name_shadows_method?(name)
            raise NameError.new("", name), "field '#{name}' shadows an existing method"
          end

          if name_is_reserved?(name)
            raise NameError.new("", name), "field '#{name}' is a reserved name"
          end
        end
      end

      def must_not_have_a_name_failed?(name)
        option?(:no_fieldnames) and name != nil
      end

      def must_have_a_name_failed?(name)
        option?(:mandatory_fieldnames) and name.nil?
      end

      def all_or_none_names_failed?(name)
        if option?(:all_or_none_fieldnames) and not fields.empty?
          all_names_blank = fields.all_field_names_blank?
          no_names_blank = fields.no_field_names_blank?

          (name != nil and all_names_blank) or (name == nil and no_names_blank)
        else
          false
        end
      end

      def malformed_name?(name)
        /^[a-z_]\w*$/ !~ name.to_s
      end

      def duplicate_name?(name)
        fields.has_field_name?(name)
      end

      def name_shadows_method?(name)
        @the_class.method_defined?(name)
      end

      def name_is_reserved?(name)
        BinData::Struct::RESERVED.include?(name.to_sym)
      end

      def fields
        @dsl_parser.fields
      end

      def option?(opt)
        @dsl_parser.send(:option?, opt)
      end
    end
  end
end