class ReeDao::Associations

def self.sync_mode?
  ReeDao.load_sync_associations_enabled?
end

def association(assoc_type, assoc_name, opts, &block)
  if self.class.sync_mode?
    return if association_is_not_included?(assoc_name) || list.empty?
    
    association = Association.new(self, list, **global_opts)
    if assoc_type == :field
      association.handle_field(assoc_name, opts)
    else
      association.load(assoc_type, assoc_name, **get_assoc_opts(opts), &block)
    end
  else
    if association_is_not_included?(assoc_name) || list.empty?
      return { association_threads: @assoc_threads, field_threads: @field_threads } 
    end
    association = Association.new(self, list, **global_opts)
    if assoc_type == :field
      field_proc = opts
      { 
        association_threads: @assoc_threads,
        field_threads: @field_threads << [
          association, field_proc
        ]
      }
    else
      {
        association_threads: @assoc_threads << [
          association, assoc_type, assoc_name, get_assoc_opts(opts), block
        ],
        field_threads: @field_threads
      }
    end
  end
end

def association_is_not_included?(assoc_name)
  return false if !only && !except
  if only
    return false if only && only.include?(assoc_name)
    if only && !only.include?(assoc_name)
      return false if autoload_children
      return true 
    end
  end
  if except
    return true if except && except.include?(assoc_name)
    return false if except && !except.include?(assoc_name)
  end
end

def belongs_to(assoc_name, opts = nil, &block)
  association(__method__, assoc_name, opts, &block)
end

def field(assoc_name, proc)
  association(__method__, assoc_name, proc)
end

def get_assoc_opts(opts)
  if opts.is_a?(Proc)
    opts.call
  elsif opts.is_a?(Sequel::Dataset)
    { scope: opts }
  else
    {}
  end
end

def has_many(assoc_name, opts = nil, &block)
  association(__method__, assoc_name, opts, &block)
end

def has_one(assoc_name, opts = nil, &block)
  association(__method__, assoc_name, opts, &block)
end

def initialize(agg_caller, list, local_vars, autoload_children = false, **opts)
  @agg_caller = agg_caller
  @list = list
  @local_vars = local_vars
  @global_opts = opts || {}
  @only = opts[:only] if opts[:only]
  @except = opts[:except] if opts[:except]
  @autoload_children = autoload_children
  raise ArgumentError.new("you can't use both :only and :except arguments at the same time") if @only && @except
  if !self.class.sync_mode?
    @assoc_threads = []
    @field_threads = []
  end
  local_vars.each do |k, v|
    instance_variable_set(k, v)
    self.class.define_method k.to_s.gsub('@', '') do
      v
    end
  end
end

def method_missing(method, *args, &block)
  return super if !agg_caller.private_methods(false).include?(method)
  agg_caller.send(method, *args, &block)
end