syncrow-web/lib/services/space_mana_api.dart

import 'package:flutter/material.dart';
import 'package:syncrow_web/pages/spaces_management/model/community_model.dart';
import 'package:syncrow_web/pages/spaces_management/model/space_model.dart';
import 'package:syncrow_web/pages/spaces_management/model/space_response_model.dart';
import 'package:syncrow_web/services/api/http_service.dart';
import 'package:syncrow_web/utils/constants/api_const.dart';

class CommunitySpaceManagementApi {
  // Community Management APIs
  Future<List<CommunityModel>> fetchCommunities() async {
    try {
      final response = await HTTPService().get(
        path: ApiEndpoints.getCommunityList,
        expectedResponseModel: (json) {
          // Access the 'data' key from the response
          List<dynamic> jsonData = json['data'];

          // Check if jsonData is actually a List
          if (jsonData is List) {
            List<CommunityModel> communityList = jsonData.map((jsonItem) {
              return CommunityModel.fromJson(jsonItem);
            }).toList();
            return communityList;
          } else {
            throw Exception('Expected a list but got something else.');
          }
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching communities: $e');
      return [];
    }
  }

  Future<CommunityModel?> getCommunityById(String communityId) async {
    try {
      final response = await HTTPService().get(
        path: ApiEndpoints.getCommunityById
            .replaceAll('{communityId}', communityId),
        expectedResponseModel: (json) {
          return CommunityModel.fromJson(json['data']);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching community by ID: $e');
      return null;
    }
  }

  Future<CommunityModel?> createCommunity(
      String name, String description, String regionId) async {
    try {
      final response = await HTTPService().post(
        path: ApiEndpoints.createCommunity,
        body: {
          'name': name,
          'description': description,
          'regionId': regionId,
        },
        expectedResponseModel: (json) {
          return CommunityModel.fromJson(json['data']);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error creating community: $e');
      return null;
    }
  }

  Future<bool> updateCommunity(
      String communityId, CommunityModel community) async {
    try {
      final response = await HTTPService().put(
        path: ApiEndpoints.updateCommunity
            .replaceAll('{communityId}', communityId),
        body: community.toMap(),
        expectedResponseModel: (json) {
          return json['success'] ?? false;
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error updating community: $e');
      return false;
    }
  }

  Future<bool> deleteCommunity(String communityId) async {
    try {
      final response = await HTTPService().delete(
        path: ApiEndpoints.deleteCommunity
            .replaceAll('{communityId}', communityId),
        expectedResponseModel: (json) {
          return json['success'] ?? false;
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error deleting community: $e');
      return false;
    }
  }

  Future<SpacesResponse> fetchSpaces(String communityId) async {
    try {
      final response = await HTTPService().get(
        path: ApiEndpoints.listSpaces.replaceAll('{communityId}', communityId),
        expectedResponseModel: (json) {
          return SpacesResponse.fromJson(json);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching spaces: $e');
      return SpacesResponse(
        data: [],
        message: 'Error fetching spaces',
        page: 1,
        size: 10,
        totalItem: 0,
        totalPage: 0,
        hasNext: false,
        hasPrevious: false,
      );
    }
  }

  Future<SpaceModel?> getSpace(String communityId, String spaceId) async {
    try {
      final response = await HTTPService().get(
        path: ApiEndpoints.getSpace
            .replaceAll('{communityId}', communityId)
            .replaceAll('{spaceId}', spaceId),
        expectedResponseModel: (json) {
          return SpaceModel.fromJson(json);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching space: $e');
      return null; // Assuming an empty SpaceModel constructor
    }
  }

  Future<SpaceModel?> createSpace(String communityId, String name,
      {String? parentId, bool isPrivate = false}) async {
    try {
      final body = {
        'name': name,
        'isPrivate': isPrivate,
      };
      if (parentId != null) {
        body['parentId'] = parentId;
      }

      final response = await HTTPService().post(
        path: ApiEndpoints.createSpace.replaceAll('{communityId}', communityId),
        body: body,
        expectedResponseModel: (json) {
          return SpaceModel.fromJson(json['data']);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error creating space: $e');
      return null;
    }
  }

  Future<bool> updateSpace(
      String communityId, String spaceId, SpaceModel space) async {
    try {
      final response = await HTTPService().put(
        path: ApiEndpoints.updateSpace
            .replaceAll('{communityId}', communityId)
            .replaceAll('{spaceId}', spaceId),
        body: space.toMap(),
        expectedResponseModel: (json) {
          return json['success'] ?? false;
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error updating space: $e');
      return false;
    }
  }

  Future<bool> deleteSpace(String communityId, String spaceId) async {
    try {
      final response = await HTTPService().delete(
        path: ApiEndpoints.deleteSpace
            .replaceAll('{communityId}', communityId)
            .replaceAll('{spaceId}', spaceId),
        expectedResponseModel: (json) {
          return json['success'] ?? false;
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error deleting space: $e');
      return false;
    }
  }

  Future<List<SpaceModel>> getSpaceHierarchy(String communityId) async {
    try {
      final response = await HTTPService().get(
        path: ApiEndpoints.getSpaceHierarchy
            .replaceAll('{communityId}', communityId),
        expectedResponseModel: (json) {
          return (json['data'] as List)
              .map((spaceJson) => SpaceModel.fromJson(spaceJson))
              .toList();
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching space hierarchy: $e');
      return [];
    }
  }

}