Insparkspokalen-ui/lib/services/backend/teamService.dart

import 'dart:math';

import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:insparkspokalen_ui/models/teamModel.dart';
import 'package:insparkspokalen_ui/models/userModel.dart';
import 'package:insparkspokalen_ui/services/backend/userService.dart';

import '../../api_endpoints.dart';
import '../googleAuthService.dart';
import '../image_service.dart';

/// API docs teamMS
/// https://group-10-15.pvt.dsv.su.se/team/swagger-ui/index.html
class TeamService {


  Future<List<TeamModel>> showTeams() async {
    try {
      final response = await http.get(ApiEndPoints.teamAll);

      if (response.statusCode == 200) {
        final List<dynamic> data = jsonDecode(response.body);
        var _allTeams = data.map((json) => TeamModel.fromJson(json)).toList();

        // Sort teams by score (descending) for leaderboard display
        _allTeams.sort((a, b) => b.score.compareTo(a.score));
        return _allTeams;
      }
    } catch (e) {
      print('Error fetching all teams: $e');
    }
    return [];
  }


  Future<bool> createTeam(String teamName, String imageSeed) async {
    final firebaseImageUrl = await ImageService().diceStyleToStorageUrl(imageSeed); /// look imageService for available seeds
    final createTeamResponse = await http.post(
      ApiEndPoints.teamCreateTeam,
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({'name': teamName, 'imageUrl': firebaseImageUrl}),
    );
    print(
      'Create team response: ${createTeamResponse.statusCode} - ${createTeamResponse.body}',
    );
    if (createTeamResponse.statusCode == 200) {
      showTeams(); // Refresh all teams
      return true;
    }
    return false;
  }


  //Ta bort grupp
  Future<bool> removeTeam(int teamId) async {
    final response = await http.delete(ApiEndPoints.teamRemoveTeam(teamId));
    if (response.statusCode == 200 || response.statusCode == 201) {
      showTeams(); // Refresh all teams
      return true;
    }
    return false;
  }


  // Funktion för att lägga till poäng
  Future<bool> updateScore(int teamId, int scoreChange) async {
    final response = await http.put(ApiEndPoints.teamUpdateScore(teamId, scoreChange));
    if (response.statusCode == 200 || response.statusCode == 201) {
      showTeams();
      return true;
    }
    return false;
  }


  //Add user to team - now using the sync service
  Future<bool> addUserToTeam(int teamId) async {
    final user = GoogleAuthService.getCurrentUser();
    if (user == null) return false;

    final response = await http.post(
      ApiEndPoints.teamAddUser,
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'email': user.email,
        'teamId': teamId,
      }),
    );
    return response.statusCode == 200 || response.statusCode == 201;
  }


  Future<TeamModel?> getTeamById(int teamId) async {
    try {
      final response = await http.get(ApiEndPoints.teamGetById(teamId));
      // print('DEBUG: getTeamById response: ${response.statusCode} - ${response.body}');

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        return TeamModel.fromJson(data);
      } else {
        print('Failed to get team with id $teamId: ${response.statusCode}');
        return null;
      }
    } catch (e) {
      print('Error getting team by id: $e');
      return null;
    }
  }


  Future<bool> isUserInAnyTeam(String email) async {
    List<TeamModel> teams = await showTeams();
    for (var team in teams) {
      for (var userEmail in team.userEmails) {
        if (userEmail == email) {
          return true;
        }
      }
    }
    return false;
  }


  Future<List<UserModel>> getTeamMembers(int teamId) async {
    final response = await http.get(ApiEndPoints.teamGetMembersById(teamId));

    if (response.statusCode == 200) {
      final List<dynamic> emails = jsonDecode(response.body);

      List<UserModel> users = [];

      for (var email in emails) {
        if (email is String) {
          try {
            final user = await UserService().getUserByEmail(email);
            user.profilePicture = await UserService().fetchProfilePicture(
              user.email,
            );
            users.add(user);
          } catch (e) {
            print("Kunde inte hämta user för email $email: $e");
          }
        } else {
          print("Ogiltigt email-format: $email");
        }
      }
      return users;
    } else {
      print("Misslyckades med att hämta team-medlemmar: ${response.body}");
      return [];

    }
  }


  Future<List<UserModel>> getTeamMembersForCurrentUser() async {
    final user = GoogleAuthService.getCurrentUser();
    if (user == null) throw Exception("Ingen inloggad användare");

    final teamId = await UserService().getUserTeamByEmail(user.email);
    if (teamId == null) throw Exception("Ingen teamId hittades för användaren");

    return await getTeamMembers(teamId);
  }


  Future<bool> removeUserFromTeam(String email, int teamId) async {
    try {
      final removeResponse = await http.delete( // really bad atm we have int and string teamId
        ApiEndPoints.teamKickUser(email, teamId),
        headers: {'Content-Type': 'application/json'},
      );
      print(
        "Remove user response: ${removeResponse.statusCode} - ${removeResponse.body}",
      );
      return true;
    } catch (e) {
      print("Fel vid borttagning: $e");
      return false;
    }
  }


  Future<void> setTeamProfilePicture(
      int teamId,
      String profilePictureUrl,
      ) async {
    final response = await http.put(
      ApiEndPoints.teamChangeAvatar,
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({'id': teamId, 'imageUrl': profilePictureUrl}),
    );

    if (response.statusCode != 200) {
      throw Exception('Misslyckades med att spara lagets profilbild');
    }
  }
}