import 'package:flutter/material.dart';
import 'package:syncrow_web/pages/spaces_management/model/community_model.dart';
import 'package:syncrow_web/pages/spaces_management/model/selected_product_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({int page = 1}) async {
    try {
      List<CommunityModel> allCommunities = [];
      bool hasNext = true;

      while (hasNext) {
        await HTTPService().get(
          path: ApiEndpoints.getCommunityList,
          queryParameters: {'page': page},
          expectedResponseModel: (json) {
            List<dynamic> jsonData = json['data'];
            hasNext = json['hasNext'] ?? false;
            int currentPage = json['page'] ?? 1;
            List<CommunityModel> communityList = jsonData.map((jsonItem) {
              return CommunityModel.fromJson(jsonItem);
            }).toList();

            allCommunities.addAll(communityList);
            page = currentPage + 1;
            return communityList;
          },
        );
      }

      return allCommunities;
    } 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) async {
    try {
      final response = await HTTPService().post(
        path: ApiEndpoints.createCommunity,
        body: {
          'name': name,
          'description': description,
        },
        expectedResponseModel: (json) {
          return CommunityModel.fromJson(json['data']);
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error creating community: $e');
      return null;
    }
  }

  Future<bool> updateCommunity(String communityId, String name) async {
    try {
      final response = await HTTPService().put(
        path: ApiEndpoints.updateCommunity
            .replaceAll('{communityId}', communityId),
        body: {
          'name': name,
        },
        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({
    required String communityId,
    required String name,
    String? parentId,
    String? direction,
    bool isPrivate = false,
    required Offset position,
    String? icon,
    required List<SelectedProduct> products,
  }) async {
    try {
      final body = {
        'spaceName': name,
        'isPrivate': isPrivate,
        'x': position.dx,
        'y': position.dy,
        'direction': direction,
        'icon': icon,
        'products': products.map((product) => product.toJson()).toList(),
      };
      if (parentId != null) {
        body['parentUuid'] = 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<SpaceModel?> updateSpace({
    required String communityId,
    required spaceId,
    required String name,
    String? parentId,
    String? icon,
    String? direction,
    bool isPrivate = false,
    required Offset position,
    required List<SelectedProduct> products,
  }) async {
    try {
      final body = {
        'spaceName': name,
        'isPrivate': isPrivate,
        'x': position.dx,
        'y': position.dy,
        'direction': direction,
        'icon': icon,
        'products': products.map((product) => product.toJson()).toList(),
      };
      if (parentId != null) {
        body['parentUuid'] = parentId;
      }

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

  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) {
          print(json);
          final spaceModels = (json['data'] as List)
              .map((spaceJson) => SpaceModel.fromJson(spaceJson))
              .toList();

          return spaceModels;
        },
      );
      return response;
    } catch (e) {
      debugPrint('Error fetching space hierarchy: $e');
      return [];
    }
  }
}