BudgetApp/lib/logic/user/user_cubit.dart

import 'dart:async';

import 'package:bloc/bloc.dart';
import 'package:flutter/foundation.dart';
import 'package:logger/logger.dart';

import '/data/repositories/interfaces/icategory_repository.dart';
import '/data/repositories/interfaces/iglobal_settings_repository.dart';
import '/data/repositories/interfaces/itag_repository.dart';
import '/data/repositories/interfaces/itransaction_repository.dart';
import '/data/repositories/interfaces/iuser_repository.dart';
import '/models/user.dart';
import '/utils/category_utils.dart';
import '/utils/tag_utils.dart';
import '/utils/transaction_utils.dart';

part 'user_state.dart';

/// Cubit для управления состоянием пользователя
class UserCubit extends Cubit<UserState> {
  final IGlobalSettingsRepository _settingsRepository;
  final IUserRepository _userRepository;
  final ICategoryRepository _categoryRepository;
  final ITagRepository _tagRepository;
  final ITransactionRepository _transactionRepository;
  final Logger _logger = Logger(
    printer: PrettyPrinter(
      methodCount: 2, // Number of method calls to be displayed
      errorMethodCount: 8, // Number of method calls if stacktrace is provided
      lineLength: 120, // Width of the output
      colors: true, // Colorful log messages
      printEmojis: true, // Print an emoji for each log message
      // Should each log print contain a timestamp
      dateTimeFormat: DateTimeFormat.onlyTimeAndSinceStart,
    ),
  );

  UserCubit({
    required IGlobalSettingsRepository settingsRepository,
    required IUserRepository userRepository,
    required ICategoryRepository categoryRepository,
    required ITagRepository tagRepository,
    required ITransactionRepository transactionRepository,
  }) : _settingsRepository = settingsRepository,
       _userRepository = userRepository,
       _categoryRepository = categoryRepository,
       _tagRepository = tagRepository,
       _transactionRepository = transactionRepository,
       super(UserInitial());

  // Метод для инициализации UserCubit
  Future<void> init() async {
    await _init();
  }

  Future<void> _init() async {
    emit(UserLoading(progress: 0.1, message: 'Инициализация...'));
    try {
      final userId = await _settingsRepository.getCurrentUserId();
      User? currentUser;

      if (userId != null) {
        emit(UserLoading(progress: 0.3, message: 'Поиск пользователя...'));
        currentUser = await _userRepository.getById(userId);
        if (currentUser == null) {
          await _settingsRepository.setCurrentUserId(null);
        }
      }

      emit(UserLoading(progress: 1.0, message: 'Завершение...'));
      await Future.delayed(const Duration(milliseconds: 300));
      emit(UserLoaded(currentUser));
    } catch (e, stack) {
      _logger.e(
        '--- UserCubit: FATAL ERROR in _init ---',
        error: e,
        stackTrace: stack,
      );
      emit(UserError('Ошибка загрузки пользователя: ${e.toString()}'));
    }
  }

  Future<User> _createDefaultUser() async {
    final user = User(
      name: 'Пользователь по умолчанию',
      email: 'default@example.com',
    );
    await _userRepository.add(user);

    // Создаем начальные данные для нового пользователя
    await _createInitialData(user.id);

    await _setCurrentUser(user);
    return user;
  }

  Future<void> _createInitialData(String userId) async {
    try {
      // Разбиваем создание данных на этапы
      emit(UserLoading(progress: 0.7, message: 'Создание категорий...'));
      await _categoryRepository.addAll(
        CategoryUtils.getDefaultCategories(userId),
      );

      emit(UserLoading(progress: 0.8, message: 'Создание тегов...'));
      await _tagRepository.addAll(TagUtils.getDefaultTags(userId));

      emit(UserLoading(progress: 0.9, message: 'Создание транзакций...'));
      await _transactionRepository.addAll(
        TransactionUtils.getSampleTransactions(userId),
      );
    } catch (e, stack) {
      _logger.e(
        'Error creating initial data for user: $userId',
        error: e,
        stackTrace: stack,
      );
    }
  }

  Future<void> _setCurrentUser(User user) async {
    await _settingsRepository.setCurrentUserId(user.id);
    emit(UserLoaded(user));
  }

  /// Устанавливает текущего пользователя
  Future<void> setCurrentUser(User user) async {
    emit(UserLoading());
    try {
      await _setCurrentUser(user);
    } catch (e, stack) {
      _logger.e('Error setting current user', error: e, stackTrace: stack);
      emit(UserError('Ошибка установки пользователя: ${e.toString()}'));
    }
  }

  /// Устанавливает текущего пользователя (прямая установка без загрузки)
  void setUser(User user) {
    emit(UserLoaded(user));
  }

  /// Выход из системы
  Future<void> logout() async {
    emit(UserLoading());
    try {
      await _settingsRepository.setCurrentUserId(null);
      emit(UserLoaded(null));
    } catch (e, stack) {
      _logger.e('Error during logout', error: e, stackTrace: stack);
      emit(UserError('Ошибка выхода из системы: ${e.toString()}'));
    }
  }

  /// Создает нового пользователя и устанавливает его как текущего
  Future<void> createAndSetUser(String name, String email) async {
    emit(UserLoading());
    try {
      final user = User(name: name, email: email);
      await _userRepository.add(user);

      // Создаем начальные данные для нового пользователя
      await _createInitialData(user.id);

      await _setCurrentUser(user);
    } catch (e, stack) {
      _logger.e('Error creating user', error: e, stackTrace: stack);
      emit(UserError('Ошибка создания пользователя: ${e.toString()}'));
    }
  }

  /// Возвращает всех пользователей
  Future<List<User>> getAllUsers() async {
    try {
      return await _userRepository.getAll();
    } catch (e, stack) {
      _logger.e('Error getting all users', error: e, stackTrace: stack);
      return [];
    }
  }
}