prosappweb/lib/providers/professionals_provider.dart

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';
import 'package:prosapp_web_app/models/comment_entity.dart';
import 'package:prosapp_web_app/models/pro_state.dart';
import 'package:prosapp_web_app/models/profesional.dart';
import 'package:prosapp_web_app/models/usuario.dart';
import 'package:prosapp_web_app/models/usuario_profesional.dart';

class ProfessionalsProvider extends ChangeNotifier {
  List<UsuarioProfesional> professionals = [];
  bool isLoading = true;

  ProfessionalsProvider() {
    getProfessionals();
  }

  getProfessionals() async {
    try {
      final querySnapshot = await FirebaseFirestore.instance
          .collection('users')
          .where('professional_state', isEqualTo: ProState.active.index)
          .get();

      final users = querySnapshot.docs
          .map((e) => Usuario.fromDocument(e.data()))
          .toList();

      final ids = users.map((e) => e.id).toList();

      final querySnapshot2 = await FirebaseFirestore.instance
          .collection('professional_info')
          .where(FieldPath.documentId, whereIn: ids)
          .get();

      final professionalsInfo = querySnapshot2.docs
          .map((e) => Profesional.fromDocument(e.data()))
          .toList();

      final professionalInfoMap = {
        for (var doc in professionalsInfo) doc.id: doc
      };

      final usersMap = await Future.wait(users.map((user) async {
        final professionalInfo = professionalInfoMap[user.id];
        final averageScore = await _getAverageScore(user.id);
        return UsuarioProfesional(
          user: user,
          professionalInfo: professionalInfo!,
          averageScore: averageScore,
        );
      }).toList());

      professionals = usersMap;

    } catch (e) {
      print('Error obteniendo profesionales: $e');
    } finally {
      isLoading = false;
      notifyListeners();
    }
  }

  Future<double> _getAverageScore(String userId) async {
    final querySnapshot = await FirebaseFirestore.instance
        .collection('comments')
        .where('destination_id', isEqualTo: userId)
        .where('is_from_user', isEqualTo: true)
        .get();

    if (querySnapshot.docs.isEmpty) {
      return 0.0;
    }

    final scores = querySnapshot.docs
        .map((e) => CommentEntity.fromDocument(e.data()).score)
        .toList();
    final averageScore = scores.reduce((a, b) => a + b) / scores.length;
    return averageScore;
  }
}