class Stytch::Sessions

def authenticate(
  session_token: nil,
  session_duration_minutes: nil,
  session_jwt: nil,
  session_custom_claims: nil
)
  request = {}
  request[:session_token] = session_token unless session_token.nil?
  request[:session_duration_minutes] = session_duration_minutes unless session_duration_minutes.nil?
  request[:session_jwt] = session_jwt unless session_jwt.nil?
  request[:session_custom_claims] = session_custom_claims unless session_custom_claims.nil?
  post_request('/v1/sessions/authenticate', request)
end

def authenticate_jwt(
  session_jwt,
  max_token_age_seconds: nil,
  session_duration_minutes: nil,
  session_custom_claims: nil
)
  if max_token_age_seconds == 0
    return authenticate(
      session_jwt: session_jwt,
      session_duration_minutes: session_duration_minutes,
      session_custom_claims: session_custom_claims
    )
  end
  decoded_jwt = authenticate_jwt_local(session_jwt)
  iat_time = Time.at(decoded_jwt['iat']).to_datetime
  if iat_time + max_token_age_seconds >= Time.now
    session = marshal_jwt_into_session(decoded_jwt)
    { 'session' => session }
  else
    authenticate(
      session_jwt: session_jwt,
      session_duration_minutes: session_duration_minutes,
      session_custom_claims: session_custom_claims
    )
  end
rescue StandardError
  # JWT could not be verified locally. Check with the Stytch API.
  authenticate(
    session_jwt: session_jwt,
    session_duration_minutes: session_duration_minutes,
    session_custom_claims: session_custom_claims
  )
end

def authenticate_jwt_local(session_jwt)
  issuer = 'stytch.com/' + @project_id
  begin
    decoded_token = JWT.decode session_jwt, nil, true,
                               { jwks: @jwks_loader, iss: issuer, verify_iss: true, aud: @project_id, verify_aud: true, algorithms: ['RS256'] }
    decoded_token[0]
  rescue JWT::InvalidIssuerError
    raise JWTInvalidIssuerError
  rescue JWT::InvalidAudError
    raise JWTInvalidAudienceError
  rescue JWT::ExpiredSignature
    raise JWTExpiredSignatureError
  rescue JWT::IncorrectAlgorithm
    raise JWTIncorrectAlgorithmError
  end
end

def get(
  user_id:
)
  query_params = {
    user_id: user_id
  }
  request = request_with_query_params('/v1/sessions', query_params)
  get_request(request)
end

def get_jwks(
  project_id:
)
  query_params = {}
  request = request_with_query_params("/v1/sessions/jwks/#{project_id}", query_params)
  get_request(request)
end

def initialize(connection, project_id)
  @connection = connection
  @project_id = project_id
  @cache_last_update = 0
  @jwks_loader = lambda do |options|
    @cached_keys = nil if options[:invalidate] && @cache_last_update < Time.now.to_i - 300
    @cached_keys ||= begin
      @cache_last_update = Time.now.to_i
      keys = []
      get_jwks(project_id: @project_id)['keys'].each do |r|
        keys << r
      end
      { keys: keys }
    end
  end
end

def marshal_jwt_into_session(jwt)
  stytch_claim = 'https://stytch.com/session'
  expires_at = jwt[stytch_claim]['expires_at'] || Time.at(jwt['exp']).to_datetime.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
  # The custom claim set is all the claims in the payload except for the standard claims and
  # the Stytch session claim. The cleanest way to collect those seems to be naming what we want
  # to omit and filtering the rest to collect the custom claims.
  reserved_claims = ['aud', 'exp', 'iat', 'iss', 'jti', 'nbf', 'sub', stytch_claim]
  custom_claims = jwt.reject { |key, _| reserved_claims.include?(key) }
  {
    'session_id' => jwt[stytch_claim]['id'],
    'user_id' => jwt['sub'],
    'started_at' => jwt[stytch_claim]['started_at'],
    'last_accessed_at' => jwt[stytch_claim]['last_accessed_at'],
    # For JWTs that include it, prefer the inner expires_at claim.
    'expires_at' => expires_at,
    'attributes' => jwt[stytch_claim]['attributes'],
    'authentication_factors' => jwt[stytch_claim]['authentication_factors'],
    'custom_claims' => custom_claims
  }
end

def revoke(
  session_id: nil,
  session_token: nil,
  session_jwt: nil
)
  request = {}
  request[:session_id] = session_id unless session_id.nil?
  request[:session_token] = session_token unless session_token.nil?
  request[:session_jwt] = session_jwt unless session_jwt.nil?
  post_request('/v1/sessions/revoke', request)
end