syncrow-web/lib/pages/auth/login/bloc/login_bloc.dart

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:syncrow_web/pages/auth/login/bloc/login_event.dart';
import 'package:syncrow_web/pages/auth/login/bloc/login_state.dart';
import 'package:syncrow_web/pages/auth/login/model/login_with_email_model.dart';
import 'package:syncrow_web/pages/auth/login/model/token.dart';
import 'package:syncrow_web/pages/auth/login/model/user_model.dart';
import 'package:syncrow_web/services/auth_api.dart';
import 'package:syncrow_web/utils/snack_bar.dart';

class LoginBloc extends Bloc<LoginEvent, LoginState> {
  LoginBloc() : super(LoginInitial()) {
    on<LoginButtonPressed>(_login);
    on<CheckBoxEvent>(checkBoxTgl);
  }

  final TextEditingController emailController = TextEditingController();
  final TextEditingController passwordController = TextEditingController();
  final formKey = GlobalKey<FormState>();
  bool isChecked = false;
  bool obscureText = true;

  _login(LoginButtonPressed event, Emitter<LoginState> emit) async {
    emit(LoginLoading());
    if(isChecked) {
      try {
        if (event.username.isEmpty || event.password.isEmpty) {
          CustomSnackBar.displaySnackBar('Please enter your credentials');
          emit(const LoginFailure(error: 'Something went wrong'));
          return;
        }
        token = await AuthenticationAPI.loginWithEmail(
          model: LoginWithEmailModel(
            email: event.username,
            password: event.password,
          ),
        );
      }
      catch (failure) {
        emit(const LoginFailure(error: 'Something went wrong'));
        // emit(LoginFailure(error: failure.toString()));
        return;
      }
      if (token.accessTokenIsNotEmpty) {
        debugPrint('token: ${token.accessToken}');
        FlutterSecureStorage storage = const FlutterSecureStorage();
        await storage.write(
            key: Token.loginAccessTokenKey, value: token.accessToken);

        const FlutterSecureStorage().write(
            key: UserModel.userUuidKey,
            value: Token.decodeToken(token.accessToken)['uuid'].toString()
        );
        user = UserModel.fromToken(token);
        emailController.clear();
        passwordController.clear();
        emit(LoginSuccess());
      } else {
        emit(const LoginFailure(error: 'Something went wrong'));
      }
    }
    else{
      emit(const LoginFailure(error: 'Accept terms and condition'));
    }
  }

  checkBoxTgl(CheckBoxEvent event, Emitter<LoginState> emit,){
    emit(LoginLoading());
    isChecked = event.newValue!;
    emit(LoginInitial());
  }


  void launchURL(String url) {
    if (kDebugMode) {
      print('Launching URL: $url');
    }
  }



  String newPassword = '';
  String maskedEmail = '';
  String otpCode = '';

  static Token token = Token.emptyConstructor();
  static UserModel? user;

  bool showValidationMessage = false;

  /////////////////////////////////////VALIDATORS/////////////////////////////////////

  String? validatePassword(String? value) {
    if (value == null || value.isEmpty) {
      return 'Password is required';
    } else if (value.length < 8) {
      return 'Password must be at least 8 characters';
    }
    return null;
  }

  String? validateEmail(String? value) {
    if (value == null || value.isEmpty) {
      return 'Email is required';
    } else if (!RegExp(r'^[^@]+@[^@]+\.[^@]+').hasMatch(value)) {
      return 'Enter a valid email address';
    }
    return null;
  }




  String? validateRegion(String? value) {
      if (value == null || value.isEmpty) {
        return 'Please select a region';
      }
      return null;
  }

  String? passwordValidator(String? value) {
    if (value == null || value.isEmpty) {
      return 'Please enter your password';
    }

    List<String> validationErrors = [];

    if (!RegExp(r'^(?=.*[a-z])').hasMatch(value)) {
      validationErrors.add(' - one lowercase letter');
    }
    if (!RegExp(r'^(?=.*[A-Z])').hasMatch(value)) {
      validationErrors.add(' - one uppercase letter');
    }
    if (!RegExp(r'^(?=.*\d)').hasMatch(value)) {
      validationErrors.add(' - one number');
    }
    if (!RegExp(r'^(?=.*[@$!%*?&])').hasMatch(value)) {
      validationErrors.add(' - one special character');
    }
    if (value.length < 8) {
      validationErrors.add(' - minimum 8 characters');
    }

    if (validationErrors.isNotEmpty) {
      return 'Password must contain at least:\n' + validationErrors.join('\n');
    }

    return null;
  }


  String? fullNameValidator(String? value) {
    if (value == null) return 'Full name is required';

    final withoutExtraSpaces = value.replaceAll(RegExp(r"\s+"), ' ').trim();

    if (withoutExtraSpaces.length < 2 || withoutExtraSpaces.length > 30) {
      return 'Full name must be between 2 and 30 characters long';
    }

    // Test if it contains anything but alphanumeric spaces and single quote

    if (RegExp(r"/[^ a-zA-Z0-9-\']/").hasMatch(withoutExtraSpaces)) {
      return 'Only alphanumeric characters, space, dash and single quote are allowed';
    }

    final parts = withoutExtraSpaces.split(' ');

    if (parts.length < 2) return 'Full name must contain first and last names';

    if (parts.length > 3) return 'Full name can at most contain 3 parts';

    if (parts.any((part) => part.length < 2 || part.length > 30)) {
      return 'Full name parts must be between 2 and 30 characters long';
    }
    return null;
  }



  String? reEnterPasswordCheckForgetPass(String? value) {
    passwordValidator(value);
    if (newPassword == value) {
      return null;
    } else {
      return 'Passwords do not match';
    }
  }

  String? emailAddressValidator(String? value) {
    if (value != null && value.isNotEmpty && value != "") {
      if (checkValidityOfEmail(value)) {
        return null;
      } else {
        return 'Please enter a valid email';
      }
    } else {
      return 'Email address is required';
    }
  }

  bool checkValidityOfEmail(String? email) {
    if (email != null) {
      return RegExp(
          r"^[a-zA-Z0-9]+([.!#$%&'*+/=?^_`{|}~-]?[a-zA-Z0-9]+)*@[a-zA-Z0-9]+([.-]?[a-zA-Z0-9]+)*\.[a-zA-Z0-9]{2,}$")
          .hasMatch(email);
    } else {
      return false;
    }
  }

  String maskEmail(String email) {
    final emailParts = email.split('@');
    if (emailParts.length != 2) return email;

    final localPart = emailParts[0];
    final domainPart = emailParts[1];

    if (localPart.length < 3) return email;

    final start = localPart.substring(0, 2);
    final end = localPart.substring(localPart.length - 1);

    final maskedLocalPart = '$start******$end';
    return '$maskedLocalPart@$domainPart';
  }


  final List<String> regions = [
    'North America',
    'South America',
    'Europe',
    'Asia',
    'Africa',
    'Australia',
    'Antarctica',
  ];

  // signUp() async {
  //   emit(LoginLoading());
  //   final response;
  //   try {
  //     List<String> userFullName = fullName.split(' ');
  //     response = await AuthenticationAPI.signUp(
  //       model: SignUpModel(
  //           email: email.toLowerCase(),
  //           password: signUpPassword,
  //           firstName: userFullName[0],
  //           lastName: userFullName[1]),
  //     );
  //   } catch (failure) {
  //     emit(AuthLoginError(message: failure.toString()));
  //     return;
  //   }
  //   if (response) {
  //     maskedEmail = maskEmail(email);
  //     await sendOtp();
  //   } else {
  //     emit(AuthLoginError(message: 'Something went wrong'));
  //   }
  // }




}