class Stytch::Sessions

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

def authenticate(
  session_token: nil,
  session_duration_minutes: nil,
  session_jwt: nil,
  session_custom_claims: nil,
  authorization_check: nil
)
  headers = {}
  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?
  request[:authorization_check] = authorization_check unless authorization_check.nil?
  post_request('/v1/sessions/authenticate', request, headers)
end

def authenticate_jwt(
  session_jwt,
  max_token_age_seconds: nil,
  session_duration_minutes: nil,
  session_custom_claims: nil,
  clock_tolerance_seconds: nil,
  authorization_check: nil
)
  max_token_age_seconds = 300 if max_token_age_seconds.nil?
  clock_tolerance_seconds = 0 if clock_tolerance_seconds.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,
      authorization_check: authorization_check
    )
  end
  session = authenticate_jwt_local(
    session_jwt,
    max_token_age_seconds: max_token_age_seconds,
    clock_tolerance_seconds: clock_tolerance_seconds,
    authorization_check: authorization_check
  )
  return session unless session.nil?
  authenticate(
    session_jwt: session_jwt,
    session_duration_minutes: session_duration_minutes,
    session_custom_claims: session_custom_claims,
    authorization_check: authorization_check
  )
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,
    authorization_check: authorization_check
  )
end

def authenticate_jwt_local(session_jwt, max_token_age_seconds: nil, clock_tolerance_seconds: nil, authorization_check: nil)
  max_token_age_seconds = 300 if max_token_age_seconds.nil?
  clock_tolerance_seconds = 0 if clock_tolerance_seconds.nil?
  default_issuer = 'stytch.com/' + @project_id
  base_url_issuer = @connection.url_prefix
  valid_issuers = [default_issuer, base_url_issuer]
  begin
    decoded_token = JWT.decode session_jwt, nil, true,
                               { jwks: @jwks_cache.loader, iss: valid_issuers, verify_iss: true, aud: @project_id, verify_aud: true, algorithms: ['RS256'], nbf_leeway: clock_tolerance_seconds }
    session = decoded_token[0]
    iat_time = Time.at(session['iat']).to_datetime
    return nil unless iat_time + max_token_age_seconds >= Time.now
    session = marshal_jwt_into_session(session)
  rescue JWT::InvalidIssuerError
    raise JWTInvalidIssuerError
  rescue JWT::InvalidAudError
    raise JWTInvalidAudienceError
  rescue JWT::ExpiredSignature
    raise JWTExpiredSignatureError
  rescue JWT::IncorrectAlgorithm
    raise JWTIncorrectAlgorithmError
  end
  # Do the auth check - intentionally don't rescue errors from here
  if authorization_check
    @policy_cache.perform_consumer_authorization_check(
      subject_roles: session['roles'],
      authorization_check: authorization_check
    )
  end
  session
end

def exchange_access_token(
  access_token:,
  session_duration_minutes: nil,
  session_custom_claims: nil,
  telemetry_id: nil
)
  headers = {}
  request = {
    access_token: access_token
  }
  request[:session_duration_minutes] = session_duration_minutes unless session_duration_minutes.nil?
  request[:session_custom_claims] = session_custom_claims unless session_custom_claims.nil?
  request[:telemetry_id] = telemetry_id unless telemetry_id.nil?
  post_request('/v1/sessions/exchange_access_token', request, headers)
end

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

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

def initialize(connection, project_id, jwks_cache, policy_cache)
  @connection = connection
  @policy_cache = policy_cache
  @project_id = project_id
  @jwks_cache = jwks_cache
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' => {
      '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,
      'roles' => jwt[stytch_claim]['roles']
    }
  }
end

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

def revoke(
  session_id: nil,
  session_token: nil,
  session_jwt: nil
)
  headers = {}
  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, headers)
end