class ActionDispatch::Request::Session

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

def self.delete(req)
  req.delete_header ENV_SESSION_KEY
end

def self.disabled(req)
  new(nil, req, enabled: false).tap do
    Session::Options.set(req, Session::Options.new(nil, { id: nil }))
  end
end

def self.find: (ActionDispatch::Request req) -> nil

def self.find(req)
  req.get_header ENV_SESSION_KEY
end

def self.set(req, session)
  req.set_header ENV_SESSION_KEY, session
end

def []: (String key) -> String

def [](key)
  load_for_read!
  key = key.to_s
  if key == "session_id"
    id&.public_id
  else
    @delegate[key]
  end
end

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

def clear
  load_for_delete!
  @delegate.clear
end

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

def destroy
  clear
  if enabled?
    options = self.options || {}
    @by.send(:delete_session, @req, options.id(@req), options)
    # Load the new sid to be written with the response.
    @loaded = false
    load_for_write!
  end
end

def dig(*keys)
  load_for_read!
  keys = keys.map.with_index { |key, i| i.zero? ? key.to_s : key }
  @delegate.dig(*keys)
end

def each(&block)
  to_hash.each(&block)
end

def empty?
  load_for_read!
  @delegate.empty?
end

def enabled?: () -> true

def enabled?
  @enabled
end

def exists?
  return false unless enabled?
  return @exists unless @exists.nil?
  @exists = @by.send(:session_exists?, @req)
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?: (String key) -> true

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

def id: () -> Rack::Session::SessionId

def id
  options.id(@req)
end

def initialize: (ActionDispatch::Session::CookieStore by, ActionDispatch::Request req, enabled: true) -> void

def initialize(by, req, enabled: true)
  @by       = by
  @req      = req
  @delegate = {}
  @loaded   = false
  @exists   = nil # We haven't checked yet.
  @enabled  = enabled
end

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

def keys
  load_for_read!
  @delegate.keys
end

def load!: () -> untyped

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

def load_for_delete!
  load! if enabled? && !loaded?
end

def load_for_read!: () -> true?

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

def load_for_write!
  if enabled?
    load! unless loaded?
  else
    raise DisabledSessionError, "Your application has sessions disabled. To write to the session you must first configure a session store"
  end
end

def loaded?: () -> bool

def loaded?
  @loaded
end

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

def options: () -> ActionDispatch::Request::Session::Options

def options
  Options.find @req
end

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

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

def values
  load_for_read!
  @delegate.values
end