syncrow-app/lib/features/scene/bloc/create_scene/create_scene_bloc.dart

import 'dart:async';

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:syncrow_app/features/devices/model/device_control_model.dart';
import 'package:syncrow_app/features/scene/model/create_scene_model.dart';
import 'package:syncrow_app/features/scene/model/scene_static_function.dart';
import 'package:syncrow_app/services/api/scene_api.dart';

part 'create_scene_event.dart';
part 'create_scene_state.dart';

class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState> {
  CreateSceneBloc() : super(CreateSceneInitial()) {
    on<CreateSceneWithTasksEvent>(_createSceneWithTasks);
    on<AddTaskEvent>(_onAddSceneTask);
    on<SelectedValueEvent>(_selectedValue);
    on<RemoveTaskEvent>(_removeTaskById);
    on<ClearTaskListEvent>(_clearTaskList);
  }

  List<SceneStaticFunction> tasksList = [];
  dynamic selectedValue;

  FutureOr<void> _onAddSceneTask(
      AddTaskEvent event, Emitter<CreateSceneState> emit) {
    tasksList.add(
      SceneStaticFunction(
        operationName: event.operation,
        deviceName: event.deviceName,
        icon: event.icon,
        code: event.deviceControlModel.code ?? '',
        deviceId: event.deviceId,
        operationalValues: [
          SceneOperationalValue(
            value: event.deviceControlModel.value,
            icon: '',
          ),
        ],
      ),
    );
    emit(AddSceneTask(tasksList: tasksList));
  }

  FutureOr<void> _selectedValue(
      SelectedValueEvent event, Emitter<CreateSceneState> emit) {
    selectedValue = event.value;
    emit(SelectedTaskValueState(value: event.value));
  }

  FutureOr<void> _removeTaskById(
      RemoveTaskEvent event, Emitter<CreateSceneState> emit) {
    emit(CreateSceneLoading());

    for (var element in tasksList) {
      if (element.uniqueCustomId == event.taskId) {
        tasksList.remove(element);

        emit(AddSceneTask(tasksList: tasksList));
        break;
      }
    }
  }

  FutureOr<void> _createSceneWithTasks(
      CreateSceneWithTasksEvent event, Emitter<CreateSceneState> emit) async {
    emit(CreateSceneLoading());
    try {
      final response = await SceneApi.createScene(event.createSceneModel);
      if (response['success'] == true) {
        tasksList.clear();
        emit(const CreateSceneWithTasks(success: true));
      } else {
        emit(const CreateSceneError(message: 'Something went wrong'));
      }
    } catch (e) {
      emit(CreateSceneError(message: e.toString()));
      emit(AddSceneTask(tasksList: tasksList));
    }
  }

  FutureOr<void> _clearTaskList(
      ClearTaskListEvent event, Emitter<CreateSceneState> emit) {
    tasksList.clear();
    emit(AddSceneTask(tasksList: tasksList));
  }
}