class ActionDispatch::Request::Session

def self.create(store, env, default_options)
  session_was = find env
  session     = Request::Session.new(store, env)
  session.merge! session_was if session_was
  set(env, session)
  Options.set(env, Request::Session::Options.new(store, env, default_options))
  session
end

def self.find(env)
  env[ENV_SESSION_KEY]
end

def self.set(env, session)
  env[ENV_SESSION_KEY] = session
end

def [](key)
  load_for_read!
  @delegate[key.to_s]
end

def []=(key, value)
  load_for_write!
  @delegate[key.to_s] = value
end

def clear
  load_for_write!
  @delegate.clear
end

def delete(key)
  load_for_write!
  @delegate.delete key.to_s
end

def destroy
  clear
  options = self.options || {}
  new_sid = @by.send(:destroy_session, @env, options[:id], options)
  options[:id] = new_sid # Reset session id with a new value or nil
  # Load the new sid to be written with the response
  @loaded = false
  load_for_write!
end

def empty?
  load_for_read!
  @delegate.empty?
end

def exists?
  return @exists unless @exists.nil?
  @exists = @by.send(:session_exists?, @env)
end

def fetch(key, default=Unspecified, &block)
  load_for_read!
  if default == Unspecified
    @delegate.fetch(key.to_s, &block)
  else
    @delegate.fetch(key.to_s, default, &block)
  end
end

def has_key?(key)
  load_for_read!
  @delegate.key?(key.to_s)
end

def id
  options[:id]
end

def initialize(by, env)
  @by       = by
  @env      = env
  @delegate = {}
  @loaded   = false
  @exists   = nil # we haven't checked yet
end

def inspect
  if loaded?
    super
  else
    "#<#{self.class}:0x#{(object_id << 1).to_s(16)} not yet loaded>"
  end
end

def keys
  @delegate.keys
end

def load!
  id, session = @by.load_session @env
  options[:id] = id
  @delegate.replace(stringify_keys(session))
  @loaded = true
end

def load_for_read!
  load! if !loaded? && exists?
end

def load_for_write!
  load! unless loaded?
end

def loaded?
  @loaded
end

def merge!(other)
  load_for_write!
  @delegate.merge!(other)
end

def options
  Options.find @env
end

def stringify_keys(other)
  other.each_with_object({}) { |(key, value), hash|
    hash[key.to_s] = value
  }
end

def to_hash
  load_for_read!
  @delegate.dup.delete_if { |_,v| v.nil? }
end

def update(hash)
  load_for_write!
  @delegate.update stringify_keys(hash)
end

def values
  @delegate.values
end