module Gecode::Mixin

# File lib/gecoder/interface/constraints/extensional_regexp.rb, line 49
def any(*regexps)
  regexps.inject(Gecode::Raw::REG.new) do |result, regexp|
    result | Util::Extensional.parse_regexp(regexp)
  end
end

# File lib/gecoder/interface/constraints/extensional_regexp.rb, line 44
def at_least_once(regexp)
  repeat(regexp, 1)
end

# File lib/gecoder/interface/constraints/extensional_regexp.rb, line 36
def at_most_once(regexp)
  repeat(regexp, 0, 1)
end

# File lib/gecoder/interface/mixin.rb, line 168
def bool_var
  BoolVar.new(self, variable_creation_space.new_bool_var)
end

# File lib/gecoder/interface/mixin.rb, line 173
def bool_var_array(count)
  build_var_array(count) do
    BoolVar.new(self, variable_creation_space.new_bool_var)
  end
end

# File lib/gecoder/interface/mixin.rb, line 181
def bool_var_matrix(row_count, col_count)
  build_var_matrix(row_count, col_count) do
    BoolVar.new(self, variable_creation_space.new_bool_var)
  end
end

# File lib/gecoder/interface/branch.rb, line 64
def branch_on(variables, options = {})
  if variables.respond_to?(:to_int_var) or 
      variables.respond_to?(:to_bool_var) or 
      variables.respond_to?(:to_set_var)
    variables = wrap_enum [variables]
  end

  if variables.respond_to? :to_int_enum 
    add_branch(variables.to_int_enum, options,
      Constants::BRANCH_INT_VAR_CONSTANTS, 
      Constants::BRANCH_INT_VALUE_CONSTANTS)
  elsif variables.respond_to? :to_bool_enum
    add_branch(variables.to_bool_enum, options, 
      Constants::BRANCH_INT_VAR_CONSTANTS, 
      Constants::BRANCH_INT_VALUE_CONSTANTS)
  elsif variables.respond_to? :to_set_enum
    add_branch(variables.to_set_enum, options, 
      Constants::BRANCH_SET_VAR_CONSTANTS, 
      Constants::BRANCH_SET_VALUE_CONSTANTS)
  else
    raise TypeError, "Unknown type of variable enum #{variables.class}."
  end
end

# File lib/gecoder/interface/mixin.rb, line 335
def combined_method_missing(*args)
  begin
    mixin_method_missing(*args)
  rescue NoMethodError => e
    mixee_method_missing(*args)
  end
end

# File lib/gecoder/interface/search.rb, line 63
def each_solution(&block)
  dfs = dfs_engine
  next_solution = nil
  while not (next_solution = dfs.next).nil?
    self.active_space = next_solution
    @gecoder_mixin_statistics = dfs.statistics
    yield self
  end
  self.reset!
end

# File lib/gecoder/interface/mixin.rb, line 140
def int_var(domain = LARGEST_INT_DOMAIN)
  args = domain_arguments(domain)
  IntVar.new(self, variable_creation_space.new_int_var(*args))
end

# File lib/gecoder/interface/mixin.rb, line 149
def int_var_array(count, domain = LARGEST_INT_DOMAIN)
  args = domain_arguments(domain)
  build_var_array(count) do
    IntVar.new(self, variable_creation_space.new_int_var(*args))
  end
end

# File lib/gecoder/interface/mixin.rb, line 160
def int_var_matrix(row_count, col_count, domain = LARGEST_INT_DOMAIN)
  args = domain_arguments(domain)
  build_var_matrix(row_count, col_count) do
    IntVar.new(self, variable_creation_space.new_int_var(*args))
  end
end

# File lib/gecoder/interface/search.rb, line 154
def maximize!(var)
  variable = self.method(var).call
  unless variable.kind_of? Gecode::IntVar
    raise ArgumentError.new("Expected integer variable, got #{variable.class}.")
  end
  
  optimize! do |model, best_so_far|
    model.method(var).call.must > best_so_far.method(var).call.value
  end
end

# File lib/gecoder/interface/mixin.rb, line 296
def method_missing(method, *args)
  name = method.to_s
  if name =~ /._is_an?$/
    name.sub!(/_is_an?$/, '')
    unless args.size == 1
      raise ArgumentError, 
        "Wrong number of argmuments (#{args.size} for 1)."
    end 
    if respond_to? name
      raise ArgumentError, "Method with name #{name} already exists."
    end
    if instance_variable_defined? "@#{name}"
      raise ArgumentError, 
        "Instance variable with name @#{name} already exists."
    end

    # We use the meta class to avoid defining the variable in all
    # other instances of the class.
    eval <<-"end_eval"
      @#{name} = args.first
      class <<self
        attr :#{name}
      end
    end_eval
    return args.first
  else
    pre_gecoder_method_missing(method, *args)
  end
end

# File lib/gecoder/interface/search.rb, line 173
def minimize!(var)
  variable = self.method(var).call
  unless variable.kind_of? Gecode::IntVar
    raise ArgumentError.new("Expected integer variable, got #{variable.class}.")
  end
  
  optimize! do |model, best_so_far|
    model.method(var).call.must < best_so_far.method(var).call.value
  end
end

# File lib/gecoder/interface/search.rb, line 108
def optimize!(&block)
  # Execute constraints.
  perform_queued_gecode_interactions

  # Set the method used for constrain calls by the BAB-search.
  Mixin.constrain_proc = lambda do |home_space, best_space|
    self.active_space = best_space
    @gecoder_mixin_variable_creation_space = home_space
    yield(self, self)
    self.active_space = home_space
    @gecoder_mixin_variable_creation_space = nil
    
    perform_queued_gecode_interactions
  end

  # Perform the search.
  options = Gecode::Raw::Search::Options.new
  options.c_d = Gecode::Raw::Search::Config::MINIMAL_DISTANCE
  options.a_d = Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE
  options.stop = nil
  bab = Gecode::Raw::BAB.new(selected_space, options)
  
  result = nil
  previous_solution = nil
  until (previous_solution = bab.next).nil?
    result = previous_solution
  end
  @gecoder_mixin_statistics = bab.statistics
  
  # Reset the method used constrain calls and return the result.
  Mixin.constrain_proc = nil
  raise Gecode::NoSolutionError if result.nil?
  
  # Switch to the result.
  self.active_space = result
  return self
end

# File lib/gecoder/interface/constraints/extensional_regexp.rb, line 10
def repeat(regexp, at_least = nil, at_most = nil)
  unless at_least.nil? or at_least.kind_of? Fixnum
    raise TypeError, 
      "Expected the at_least argument to be a Fixnum, got #{at_least.class}"
  end
  unless at_most.nil? or at_most.kind_of?(Fixnum)
    raise TypeError, 
      "Expected the at_most argument to be a Fixnum, got #{at_most.class}"
  end

  reg = Util::Extensional.parse_regexp regexp
  if at_most.nil?
    if at_least.nil?
      reg.send '*'
    else
      reg.send('()', at_least)
    end
  else
    reg.send('()', at_least, at_most)
  end
end

# File lib/gecoder/interface/search.rb, line 42
def reset!
  self.active_space = base_space
  @gecoder_mixin_statistics = nil
  return self
end

# File lib/gecoder/interface/search.rb, line 83
def search_stats
  return nil if @gecoder_mixin_statistics.nil?
  
  return {
    :propagations => @gecoder_mixin_statistics.propagate,
    :failures     => @gecoder_mixin_statistics.fail,
    :clones       => @gecoder_mixin_statistics.clone,
    :commits      => @gecoder_mixin_statistics.commit,
    :memory       => @gecoder_mixin_statistics.memory
  }
end

# File lib/gecoder/interface/mixin.rb, line 196
def set_var(glb_domain = [], lub_domain = LARGEST_SET_BOUND,
    cardinality_range = nil)
  args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
  SetVar.new(self, variable_creation_space.new_set_var(*args))
end

# File lib/gecoder/interface/mixin.rb, line 204
def set_var_array(count, glb_domain = [], lub_domain = LARGEST_SET_BOUND, 
    cardinality_range = nil)
  args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
  build_var_array(count) do
    SetVar.new(self, variable_creation_space.new_set_var(*args))
  end
end

# File lib/gecoder/interface/mixin.rb, line 215
def set_var_matrix(row_count, col_count, glb_domain = [], 
    lub_domain = LARGEST_SET_BOUND, cardinality_range = nil)
  args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
  build_var_matrix(row_count, col_count) do
    SetVar.new(self, variable_creation_space.new_set_var(*args))
  end
end

# File lib/gecoder/interface/search.rb, line 51
def solution(&block)
  begin
    solution = self.solve!
    res = yield solution
    self.reset!
    return res
  rescue Gecode::NoSolutionError
    return nil
  end
end

# File lib/gecoder/interface/search.rb, line 30
def solve!(options = {})
  dfs = dfs_engine(options)
  space = dfs.next
  @gecoder_mixin_statistics = dfs.statistics
  raise Gecode::SearchAbortedError if dfs.stopped
  raise Gecode::NoSolutionError if space.nil?
  self.active_space = space
  return self
end

# File lib/gecoder/interface/enum_wrapper.rb, line 5
def wrap_enum(enum)
  unless enum.kind_of? Enumerable
    raise TypeError, 'Only enumerables can be wrapped.'
  end
  if enum.kind_of? Gecode::EnumMethods
    raise ArgumentError, 'The enumration is already wrapped.'
  end
  elements = enum.to_a
  if elements.empty?
    raise ArgumentError, 'Enumerable must not be empty.'
  end
  
  if elements.all?{ |var| var.respond_to? :to_int_var }
    elements.map!{ |var| var.to_int_var }
    class <<enum
      include Gecode::IntEnumMethods
    end
  elsif elements.all?{ |var| var.respond_to? :to_bool_var }
    elements.map!{ |var| var.to_bool_var }
    class <<enum
      include Gecode::BoolEnumMethods
    end
  elsif elements.all?{ |var| var.respond_to? :to_set_var }
    elements.map!{ |var| var.to_set_var }
    class <<enum
      include Gecode::SetEnumMethods
    end
  elsif elements.all?{ |var| var.kind_of? Fixnum }
    class <<enum
      include Gecode::FixnumEnumMethods
    end
  else
    raise TypeError, "Enumerable doesn't contain operands #{enum.inspect}."
  end
  
  enum.model = self
  return enum
end

# File lib/gecoder/interface/mixin.rb, line 275
def self.included(mod)
  mod.class_eval do
    alias_method :pre_gecoder_method_missing, :method_missing
    # Wraps method missing to handle #foo_is_a and #foo_is_an . 
    #
    # "<variable_name>_is_a <variable>" or "<variable_name>_is_an
    # <variable>", # replacing "<variable_name>" with the variable's
    # name and "<variable>" with the variable, adds an instance
    # variable and accessor with the specified name.
    #
    # The method also returns the variable given.
    #
    # ==== Example
    #
    #   # Add an instance variable and accessor named "foo" that return
    #   # the integer variable.
    #   foo_is_an int_var(0..9)
    #
    #   # Add an instance variable and accessor named "bar" that return
    #   # the boolean variable array.
    #   bar_is_a bool_var_array(2)
    def method_missing(method, *args)
      name = method.to_s
      if name =~ /._is_an?$/
        name.sub!(/_is_an?$/, '')
        unless args.size == 1
          raise ArgumentError, 
            "Wrong number of argmuments (#{args.size} for 1)."
        end 
        if respond_to? name
          raise ArgumentError, "Method with name #{name} already exists."
        end
        if instance_variable_defined? "@#{name}"
          raise ArgumentError, 
            "Instance variable with name @#{name} already exists."
        end

        # We use the meta class to avoid defining the variable in all
        # other instances of the class.
        eval <<-"end_eval"
          @#{name} = args.first
          class <<self
            attr :#{name}
          end
        end_eval
        return args.first
      else
        pre_gecoder_method_missing(method, *args)
      end
    end
    alias_method :mixin_method_missing, :method_missing

    def self.method_added(method)
      if method == :method_missing && !@redefining_method_missing
        # The class that is mixing in the mixin redefined method
        # missing. Redefine method missing again to combine the two
        # definitions.
        @redefining_method_missing = true
        class_eval do 
          alias_method :mixee_method_missing, :method_missing
          def combined_method_missing(*args)
            begin
              mixin_method_missing(*args)
            rescue NoMethodError => e
              mixee_method_missing(*args)
            end
          end
          alias_method :method_missing, :combined_method_missing
        end
      end
    end
  end
end

# File lib/gecoder/interface/mixin.rb, line 327
def self.method_added(method)
  if method == :method_missing && !@redefining_method_missing
    # The class that is mixing in the mixin redefined method
    # missing. Redefine method missing again to combine the two
    # definitions.
    @redefining_method_missing = true
    class_eval do 
      alias_method :mixee_method_missing, :method_missing
      def combined_method_missing(*args)
        begin
          mixin_method_missing(*args)
        rescue NoMethodError => e
          mixee_method_missing(*args)
        end
      end
      alias_method :method_missing, :combined_method_missing
    end
  end
end