AWSCognitoAuthPlugin+ClientBehavior.swift

//
// Copyright Amazon.com Inc. or its affiliates.
// All Rights Reserved.
//
// SPDX-License-Identifier: Apache-2.0
//

import Amplify
import AuthenticationServices
import Foundation

// swiftlint:disable force_cast
extension AWSCognitoAuthPlugin: AuthCategoryBehavior {

    public func signUp(
        username: String,
        password: String? = nil,
        options: AuthSignUpRequest.Options?
    ) async throws -> AuthSignUpResult {
        let options = options ?? AuthSignUpRequest.Options()
        let request = AuthSignUpRequest(
            username: username,
            password: password,
            options: options
        )
        let task = AWSAuthSignUpTask(request, authStateMachine: authStateMachine, authEnvironment: authEnvironment)
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignUpResult
    }

    public func confirmSignUp(
        for username: String,
        confirmationCode: String,
        options: AuthConfirmSignUpRequest.Options?
    )
    async throws -> AuthSignUpResult {
        let options = options ?? AuthConfirmSignUpRequest.Options()
        let request = AuthConfirmSignUpRequest(
            username: username,
            code: confirmationCode,
            options: options
        )
        let task = AWSAuthConfirmSignUpTask(request, authStateMachine: authStateMachine, authEnvironment: authEnvironment)
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignUpResult
    }

    public func resendSignUpCode(for username: String, options: AuthResendSignUpCodeRequest.Options?) async throws -> AuthCodeDeliveryDetails {
        let options = options ?? AuthResendSignUpCodeRequest.Options()
        let request = AuthResendSignUpCodeRequest(username: username, options: options)
        let task = AWSAuthResendSignUpCodeTask(request, environment: authEnvironment, authConfiguration: authConfiguration)
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthCodeDeliveryDetails
    }

#if os(iOS) || os(macOS) || os(visionOS)
    public func signInWithWebUI(
        presentationAnchor: AuthUIPresentationAnchor? = nil,
        options: AuthWebUISignInRequest.Options?
    ) async throws -> AuthSignInResult {
        let options = options ?? AuthWebUISignInRequest.Options()
        let request = AuthWebUISignInRequest(
            presentationAnchor: presentationAnchor,
            options: options
        )
        let task = AWSAuthWebUISignInTask(
            request,
            authConfiguration: authConfiguration,
            authStateMachine: authStateMachine,
            eventName: HubPayload.EventName.Auth.webUISignInAPI
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignInResult
    }

    public func signInWithWebUI(
        for authProvider: AuthProvider,
        presentationAnchor: AuthUIPresentationAnchor? = nil,
        options: AuthWebUISignInRequest.Options?
    ) async throws -> AuthSignInResult {
        let options = options ?? AuthWebUISignInRequest.Options()
        let request = AuthWebUISignInRequest(
            presentationAnchor: presentationAnchor,
            authProvider: authProvider,
            options: options
        )
        let task = AWSAuthWebUISignInTask(
            request,
            authConfiguration: authConfiguration,
            authStateMachine: authStateMachine,
            eventName: HubPayload.EventName.Auth.socialWebUISignInAPI
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignInResult
    }
#endif

    public func confirmSignIn(
        challengeResponse: String,
        options: AuthConfirmSignInRequest.Options? = nil
    ) async throws -> AuthSignInResult {

        let options = options ?? AuthConfirmSignInRequest.Options()
        let request = AuthConfirmSignInRequest(
            challengeResponse: challengeResponse,
            options: options
        )
        let task = AWSAuthConfirmSignInTask(
            request,
            stateMachine: authStateMachine,
            configuration: authConfiguration
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignInResult
    }

    public func signOut(options: AuthSignOutRequest.Options? = nil) async -> AuthSignOutResult {
        clearCachedSession()

        let options = options ?? AuthSignOutRequest.Options()
        let request = AuthSignOutRequest(options: options)
        let task = AWSAuthSignOutTask(request, authStateMachine: authStateMachine)
        do {
            return try await taskQueue.sync {
                return await task.value
            } as! AuthSignOutResult
        } catch {
            fatalError("AWSAuthSignOutTask should not throw error: \(error)")
        }
    }

    public func fetchAuthSession(options: AuthFetchSessionRequest.Options?) async throws -> AuthSession {
        let options = options ?? AuthFetchSessionRequest.Options()

        if !options.forceRefresh,
           let cached = cachedSession,
           cached.areTokensValid() {
            return cached
        }

        let request = AuthFetchSessionRequest(options: options)
        let forceReconfigure = secureStoragePreferences?.accessGroup?.name != nil
        let task = AWSAuthFetchSessionTask(
            request,
            authStateMachine: authStateMachine,
            configuration: authConfiguration,
            environment: authEnvironment,
            forceReconfigure: forceReconfigure
        )

        let session = try await taskQueue.sync {
            return try await task.value
        } as! AuthSession

        if let cognitoSession = session as? AWSAuthCognitoSession {
            cachedSession = cognitoSession
        }

        return session
    }

    public func resetPassword(for username: String, options: AuthResetPasswordRequest.Options?) async throws -> AuthResetPasswordResult {
        let options = options ?? AuthResetPasswordRequest.Options()
        let request = AuthResetPasswordRequest(username: username, options: options)
        let task = AWSAuthResetPasswordTask(request, environment: authEnvironment, authConfiguration: authConfiguration)
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthResetPasswordResult
    }

    public func confirmResetPassword(
        for username: String,
        with newPassword: String,
        confirmationCode: String,
        options: AuthConfirmResetPasswordRequest.Options?
    ) async throws {
        let options = options ?? AuthConfirmResetPasswordRequest.Options()
        let request = AuthConfirmResetPasswordRequest(
            username: username,
            newPassword: newPassword,
            confirmationCode: confirmationCode,
            options: options
        )
        let task = AWSAuthConfirmResetPasswordTask(request, environment: authEnvironment, authConfiguration: authConfiguration)
        _ = try await taskQueue.sync {
            return try await task.value
        }
    }

    public func signIn(
        username: String?,
        password: String?,
        options: AuthSignInRequest.Options?
    ) async throws -> AuthSignInResult {
        let options = options ?? AuthSignInRequest.Options()
        let request = AuthSignInRequest(
            username: username,
            password: password,
            options: options
        )
        let task = AWSAuthSignInTask(
            request,
            authStateMachine: authStateMachine,
            configuration: authConfiguration
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignInResult
    }

    public func autoSignIn() async throws -> AuthSignInResult {
        let options = AuthAutoSignInRequest.Options()
        let request = AuthAutoSignInRequest(options: options)
        let task = AWSAuthAutoSignInTask(
            request,
            authStateMachine: authStateMachine,
            authEnvironment: authEnvironment
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! AuthSignInResult
    }

    public func deleteUser() async throws {
        let task = AWSAuthDeleteUserTask(
            authStateMachine: authStateMachine,
            authConfiguraiton: authConfiguration
        )
        _ = try await taskQueue.sync {
            return try await task.value
        }
    }

    public func setUpTOTP() async throws -> TOTPSetupDetails {
        let task = SetUpTOTPTask(
            authStateMachine: authStateMachine,
            userPoolFactory: authEnvironment.cognitoUserPoolFactory
        )
        return try await taskQueue.sync {
            return try await task.value
        } as! TOTPSetupDetails
    }

    public func verifyTOTPSetup(
        code: String,
        options: VerifyTOTPSetupRequest.Options?
    ) async throws {
        let options = options ?? VerifyTOTPSetupRequest.Options()
        let request = VerifyTOTPSetupRequest(
            code: code,
            options: options
        )
        let task = VerifyTOTPSetupTask(
            request,
            authStateMachine: authStateMachine,
            userPoolFactory: authEnvironment.cognitoUserPoolFactory
        )
        _ = try await taskQueue.sync {
            return try await task.value
        }
    }
}
// swiftlint:enable force_cast