class Aws::SessionStore::DynamoDB::Locking::Base

def attr_opts
  { attributes_to_get: ['data'],
    consistent_read: @config.consistent_read }
end

def attr_updts(env, session, add_attrs = {})
  data = data_unchanged?(env, session) ? {} : data_attr(session)
  {
    attribute_updates: merge_all(updated_attr, data, add_attrs, expire_attr),
    return_values: 'UPDATED_NEW'
  }
end

def created_attr
  { 'created_at' => updated_at }
end

def data_attr(session)
  { 'data' => { value: session, action: 'PUT' } }
end

def data_unchanged?(env, session)
  return false unless env['rack.initial_data']
  env['rack.initial_data'] == session
end

def delete_opts(sid)
  table_opts(sid)
end

def delete_session(env, sid)
  handle_error(env) do
    @config.dynamo_db_client.delete_item(delete_opts(sid))
  end
end

def expected_attributes(sid)
  { expected: { @config.table_key => { value: sid, exists: true } } }
end

def expire_at
  max_stale = @config.max_stale || 0
  { value: (Time.now + max_stale).to_i, action: 'PUT' }
end

def expire_attr
  { 'expire_at' => expire_at }
end

def get_session_data(env, sid)
  raise NotImplementedError
end

def handle_error(env = nil)
  yield
rescue Aws::DynamoDB::Errors::ServiceError => e
  @config.error_handler.handle_error(e, env)
end

def initialize(cfg)
  @config = cfg
end

def merge_all(*hashes)
  new_hash = {}
  hashes.each { |hash| new_hash.merge!(hash) }
  new_hash
end

def pack_data(data)
  [Marshal.dump(data)].pack('m*')
end

def save_exists_opts(env, sid, session, options = {})
  add_attr = options[:add_attrs] || {}
  expected = options[:expect_attr] || {}
  attribute_opts = merge_all(attr_updts(env, session, add_attr), expected)
  merge_all(table_opts(sid), attribute_opts)
end

def save_new_opts(env, sid, session)
  attribute_opts = attr_updts(env, session, created_attr)
  merge_all(table_opts(sid), attribute_opts)
end

def set_session_data(env, sid, session, options = {})
  return false if session.empty?
  packed_session = pack_data(session)
  handle_error(env) do
    save_opts = update_opts(env, sid, packed_session, options)
    @config.dynamo_db_client.update_item(save_opts)
    sid
  end
end

def table_opts(sid)
  {
    table_name: @config.table_name,
    key: { @config.table_key => sid }
  }
end

def unpack_data(packed_data)
  Marshal.load(packed_data.unpack1('m*'))
end

def update_opts(env, sid, session, options = {})
  if env['dynamo_db.new_session']
    save_new_opts(env, sid, session)
  else
    save_exists_opts(env, sid, session, options)
  end
end

def updated_at
  { value: Time.now.to_f.to_s, action: 'PUT' }
end

def updated_attr
  {
    'updated_at' => updated_at
  }
end