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/enum/operation_dialog_type.dart';
import 'package:syncrow_app/features/scene/helper/scene_operations_data_helper.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>
    with SceneOperationsDataHelper {
  CreateSceneBloc() : super(CreateSceneInitial()) {
    on<CreateSceneWithTasksEvent>(_createSceneWithTasks);
    on<AddTaskEvent>(_onAddSceneTask);
    on<SelectedValueEvent>(_selectedValue);
    on<RemoveTaskByIdEvent>(_removeTaskById);
    on<ClearTaskListEvent>(_clearTaskList);
    on<ClearTempTaskListEvent>(_clearTempTaskList);
    on<FetchSceneTasksEvent>(_fetchSceneTasks);
    on<TempHoldSceneTasksEvent>(_onTempHoldSceneTask);
    on<RemoveTempTaskByIdEvent>(_removeTempTaskById);
    on<RemoveFromSelectedValueById>(_removeFromSelectedValueById);
    on<DeleteSceneEvent>(_deleteScene);
    on<UpdateTaskEvent>(_updateTaskValue);
  }

  List<SceneStaticFunction> tasksList = [];
  List<SceneStaticFunction> tempTasksList = [];
  final Map<String, dynamic> selectedValues = {};

  FutureOr<void> _onAddSceneTask(
      AddTaskEvent event, Emitter<CreateSceneState> emit) {
    final copyList = List<SceneStaticFunction>.from(tempTasksList);
    tasksList.addAll(copyList);
    tempTasksList.clear();
    selectedValues.clear();
    emit(AddSceneTask(tasksList: tasksList));
  }

  FutureOr<void> _onTempHoldSceneTask(
      TempHoldSceneTasksEvent event, Emitter<CreateSceneState> emit) {
    bool updated = false;
    for (var element in tempTasksList) {
      if (element.code == event.deviceControlModel.code) {
        // Update the existing function with new values
        var updatedElement = element.copyWith(
          operationName: event.operation,
          deviceName: event.deviceName,
          icon: event.icon,
          code: event.deviceControlModel.code ?? '',
          deviceId: event.deviceId,
          functionValue: event.deviceControlModel.value,
          operationalValues: [
            SceneOperationalValue(
              value: event.deviceControlModel.value,
              icon: '',
            ),
          ],
        );
        tempTasksList[tempTasksList.indexOf(element)] = updatedElement;
        selectedValues[updatedElement.code] = event.deviceControlModel.value;
        updated = true;
        break;
      }
    }
    if (!updated) {
      // Add new function if not found
      OperationDialogType getOperationDialogType(String? code, [value]) {
        if (code == null) {
          return OperationDialogType.none;
        }
        if (code.contains('delay')) {
          return OperationDialogType.delay;
        } else if (code.contains('countdown')) {
          return OperationDialogType.countdown;
        } else if (code.contains('set_temp')) {
          return OperationDialogType.temperature;
        } else if (value.toString().toLowerCase().trim() == 'on' ||
            value.toString().toLowerCase().trim() == 'off') {
          return OperationDialogType.onOff;
        }
        return OperationDialogType.listOfOptions;
      }

      var newElement = SceneStaticFunction(
        operationName: event.operation,
        deviceName: event.deviceName,
        icon: event.icon,
        code: event.deviceControlModel.code ?? '',
        operationDialogType: getOperationDialogType(
            event.deviceControlModel.code, event.deviceControlModel.value),
        deviceId: event.deviceId,
        functionValue: event.deviceControlModel.value,
        operationalValues: [
          SceneOperationalValue(
            value: event.deviceControlModel.value,
            icon: '',
          ),
        ],
      );
      tempTasksList.add(newElement);
      selectedValues[newElement.code] = event.deviceControlModel.value;
    }

    emit(TempHoldSceneTask(tempTasksList: tempTasksList));
    emit(AddSceneTask(tasksList: tasksList));
  }

  FutureOr<void> _selectedValue(
      SelectedValueEvent event, Emitter<CreateSceneState> emit) {
    selectedValues[event.code] = event.value;
    emit(SelectedTaskValueState(value: event.value));
    emit(AddSceneTask(tasksList: tasksList));
  }

  FutureOr<void> _removeTaskById(
      RemoveTaskByIdEvent 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> _removeTempTaskById(
      RemoveTempTaskByIdEvent event, Emitter<CreateSceneState> emit) {
    for (var element in tempTasksList) {
      if (element.code == event.code) {
        tempTasksList.remove(element);

        emit(AddSceneTask(tasksList: tasksList));

        break;
      }
    }
  }

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

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

  FutureOr<void> _fetchSceneTasks(
      FetchSceneTasksEvent event, Emitter<CreateSceneState> emit) async {
    emit(CreateSceneLoading());

    try {
      final response = await SceneApi.getSceneDetails(event.sceneId);
      if (response.id.isNotEmpty) {
        tasksList = List<SceneStaticFunction>.from(
            getTaskListFunctionsFromApi(actions: response.actions));
        emit(AddSceneTask(
          tasksList: tasksList,
        ));
      } else {
        emit(const CreateSceneError(message: 'Something went wrong'));
      }
    } catch (e) {
      emit(const CreateSceneError(message: 'Something went wrong'));
    }
  }

  FutureOr<void> _clearTempTaskList(
      ClearTempTaskListEvent event, Emitter<CreateSceneState> emit) {
    tempTasksList.clear();
    selectedValues.clear();
    emit(AddSceneTask(tasksList: tempTasksList));
  }

  FutureOr<void> _removeFromSelectedValueById(
      RemoveFromSelectedValueById event, Emitter<CreateSceneState> emit) {
    if (selectedValues.containsKey(event.code)) {
      selectedValues.remove(event.code);
      emit(const SelectedTaskValueState(value: null));
      emit(AddSceneTask(tasksList: tasksList));
    }
  }

  FutureOr<void> _deleteScene(
      DeleteSceneEvent event, Emitter<CreateSceneState> emit) async {
    emit(DeleteSceneLoading());

    try {
      final response = await SceneApi.deleteScene(
          sceneId: event.sceneId, unitUuid: event.unitUuid);
      if (response == true) {
        emit(const DeleteSceneSuccess(true));
      } else {
        emit(const DeleteSceneError(message: 'Something went wrong'));
      }
    } catch (e) {
      emit(const DeleteSceneError(message: 'Something went wrong'));
    }
  }

  FutureOr<void> _updateTaskValue(
      UpdateTaskEvent event, Emitter<CreateSceneState> emit) {
    for (var i = 0; i < tasksList.length; i++) {
      if (tasksList[i].uniqueCustomId == event.taskId) {
        tasksList[i] = tasksList[i].copyWith(
          functionValue: event.newValue,
        );
        break;
      }
    }
    emit(AddSceneTask(tasksList: tasksList));
  }
}