Flutter (Mobile)

subprojects {
    afterEvaluate { project ->
        if (project.hasProperty('android')) {
            project.android {
                if (namespace == null) {
                    namespace project.group
                }
            }
        }
    }
}

import 'package:para/para.dart';
import 'package:para/src/auth_extensions.dart'; // For Auth.email helper

Future<void> authenticateWithEmail(String email) async {
  // Step 1: Initiate auth flow (using extension method)
  final authState = await para.initiateAuthFlow(
    auth: Auth.email(email)
  );
  
  // Or call the core method directly:
  // final authStateFuture = para.signUpOrLogIn(auth: {'email': email});
  // final authState = await authStateFuture.future;
  
  // Step 2: Handle based on auth stage
  switch (authState.stage) {
    case AuthStage.verify:
      // New user - needs verification
      print('Verification code sent to $email');
      // Show UI to collect verification code
      break;
      
    case AuthStage.login:
      // Existing user - proceed to login
      await handleLogin(authState);
      break;
      
    case AuthStage.signup:
      // Should not happen directly, comes after verification
      break;
  }
}

Future<void> verifyEmail(String verificationCode) async {
  // Verify the code
  final verifiedStateFuture = para.verifyNewAccount(
    verificationCode: verificationCode
  );
  final verifiedState = await verifiedStateFuture.future;
  
  // After verification, proceed to signup
  if (verifiedState.stage == AuthStage.signup) {
    await handleSignup(verifiedState);
  }
}

Future<void> handleLogin(AuthState authState) async {
  // Login with passkey - no webAuthSession needed
  final walletFuture = para.loginWithPasskey(
    email: authState.email,
  );
  final wallet = await walletFuture.future;
  
  // User is now logged in
  final walletsFuture = para.fetchWallets();
  final wallets = await walletsFuture.future;
}

Future<void> handleSignup(AuthState authState) async {
  // For simplified flow, use the auth extension
  final wallet = await para.handleSignup(
    authState: authState,
    method: SignupMethod.passkey,
  );
  
  print('Wallet created: ${wallet.address}');
  
  // Alternative: Manual flow
  // 1. Generate passkey
  // await para.generatePasskey();
  // 2. Create wallet
  // final wallet = await para.createWallet(
  //   type: WalletType.evm,
  //   skipDistribute: false,
  // ).future;
}

Future<void> authenticateWithPhone(String phoneNumber, String countryCode) async {
  // Format phone number properly  
  final formattedPhone = para.formatPhoneNumber(phoneNumber, countryCode);
  
  // Step 1: Initiate auth flow
  final authState = await para.signUpOrLogIn(
    auth: Auth.phone(formattedPhone)
  );
  
  // Step 2: Handle based on auth stage
  switch (authState.stage) {
    case AuthStage.verify:
      // New user - SMS verification code sent
      print('SMS code sent to $formattedPhone');
      // Show UI to collect verification code
      break;
      
    case AuthStage.login:
      // Existing user - proceed to login
      await handlePhoneLogin(authState);
      break;
      
    case AuthStage.signup:
      // Should not happen directly
      break;
  }
}

Future<void> verifyPhone(String verificationCode) async {
  // Verify the SMS code
  final verifiedState = await para.verifyNewAccount(
    verificationCode: verificationCode
  );
  
  // After verification, proceed to signup
  if (verifiedState.stage == AuthStage.signup) {
    await handlePhoneSignup(verifiedState);
  }
}

Future<void> handlePhoneLogin(AuthState authState) async {
  // Login with passkey - no webAuthSession needed
  final walletFuture = para.loginWithPasskey(
    phone: authState.auth.phoneNumber,
  );
  final wallet = await walletFuture.future;
  
  // User is now logged in
  final wallets = await para.fetchWallets();
}

Future<void> handlePhoneSignup(AuthState authState) async {
  // For simplified flow, use the auth extension
  final wallet = await para.handleSignup(
    authState: authState,
    method: SignupMethod.passkey,
  );
  
  print('Wallet created: ${wallet.address}');
}

Future<void> loginWithGoogle() async {
  final webAuthSession = WebAuthenticationSession(
    prefersEphemeralWebBrowserSession: false,
  );
  
  // Use unified OAuth flow for v2
  final authState = await para.verifyOAuth(
    provider: OAuthMethod.google,
    deeplinkUrl: 'yourapp://callback',
  );
  
  // OAuth handles both new and existing users automatically
  final isActive = await para.isSessionActive();
  if (isActive) {
    // User is now authenticated
    final wallets = await para.fetchWallets();
    print('OAuth successful, ${wallets.length} wallets available');
  }
}

Future<void> setupPassword(AuthState authState) async {
  // Password flow requires a web authentication session
  final webAuthSession = FlutterWebAuthSession(
    callbackUrlScheme: 'yourapp',
  );
  
  // Use the extension method for simplified flow
  final wallet = await para.handleSignup(
    authState: authState,
    method: SignupMethod.password,
    webAuthenticationSession: webAuthSession,
  );
  
  print('Wallet created with password: ${wallet.address}');
}

// Alternative: Manual password flow
Future<void> setupPasswordManually(AuthState authState) async {
  if (authState.passwordUrl != null) {
    final webAuthSession = FlutterWebAuthSession(
      callbackUrlScheme: 'yourapp',
    );
    
    // Present password URL using the extension
    await para.presentPasswordUrl(
      authState.passwordUrl!,
      webAuthSession,
    );
    
    // After password is set, create wallet
    final walletFuture = para.createWallet(
      type: WalletType.evm,
      skipDistribute: false,
    );
    
    final wallet = await walletFuture.future;
  }
}