import 'dart:async';

// ignore: depend_on_referenced_packages
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
// ignore: depend_on_referenced_packages
import 'package:meta/meta.dart';

import '../../../../core/network/handler_error.dart';
import '../../domain/entities/token.dart';
import '../../domain/entities/user.dart';
import '../../domain/usecases/fetch_token.dart';
import '../../domain/usecases/keep_token.dart';
import '../../domain/usecases/set_user.dart';

part 'authentication_event.dart';
part 'authentication_state.dart';

class AuthenticationBloc
    extends Bloc<AuthenticationEvent, AuthenticationState> {
  final FetchToken fetchToken;
  final KeepToken keepToken;
  final SetUser setUser;
  static User currentUser = const User(email: '', phone: '');

  AuthenticationBloc({
    required this.fetchToken,
    required this.keepToken,
    required this.setUser,
  }) : super(AuthenticationInitial()) {
    on<CheckAuthenticationStatusEvent>(_checkAuthenticationStatusEvent);
    on<SaveTokenEvent>(_saveToken);
    on<SetUserEvent>(_setUserEvent);
  }

  User get user {
    return currentUser;
  }

  set user(User user) {
    currentUser = user;
  }

  Future<void> _checkAuthenticationStatusEvent(
      CheckAuthenticationStatusEvent event,
      Emitter<AuthenticationState> emit) async {
    final result = await fetchToken(TokenParams());
    result.fold((failure) {
      emit(Unauthenticated(message: HandleError.getMessage(failure)));
    }, (success) {
        emit(Authenticated(user: user));
    });
  }

  Future<void> _setUserEvent(
      SetUserEvent event, Emitter<AuthenticationState> emit) async {
    final result = await setUser.call(const UserParams());
    result.fold(
        (failure) =>
            emit(Unauthenticated(message: HandleError.getMessage(failure))),
        (resultUser) {
      Authenticated(user: resultUser);
      user = resultUser;
    });
  }

  Future<void> _saveToken(
      SaveTokenEvent event, Emitter<AuthenticationState> emit) async {
    final result = await keepToken.call(event.token);

    result.fold((failure) {
      emit(Unauthenticated(message: HandleError.getMessage(failure)));
    }, (success) {
      add(SetUserEvent());
    });
  }
}