import 'dart:async';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:lotti/classes/ai/ai_config.dart';
import 'package:lotti/classes/journal_entities.dart';
import 'package:lotti/features/ai/helpers/prompt_capability_filter.dart';
import 'package:lotti/features/ai/repository/ai_config_repository.dart';
import 'package:lotti/features/ai/state/consts.dart';
import 'package:lotti/logic/repositories/journal_repository.dart';
class AiPromptResolver {
  AiPromptResolver({required this.ref});
  final Ref ref;
  Future<List<AiConfigPrompt>> getActivePromptsForContext({
    required JournalEntity entity,
  }) async {
    final allPrompts = await ref
        .read(aiConfigRepositoryProvider)
        .getConfigsByType(AiConfigType.prompt);
    final activePrompts = <AiConfigPrompt>[];
    final activeChecks = <Future<bool>>[];
    final validPrompts = <AiConfigPrompt>[];
    for (final config in allPrompts) {
      if (config is AiConfigPrompt &&
          !config.archived &&
          !config.aiResponseType.isLegacyType) {
        validPrompts.add(config);
        activeChecks.add(_isPromptActiveForEntity(config, entity));
      }
    }
    final results = await Future.wait(activeChecks);
    for (var i = 0; i < results.length; i++) {
      if (results[i]) {
        activePrompts.add(validPrompts[i]);
      }
    }
    final capabilityFilter = ref.read(promptCapabilityFilterProvider);
    final platformFilteredPrompts = await capabilityFilter
        .filterPromptsByPlatform(activePrompts);
    return platformFilteredPrompts;
  }
  Future<bool> _isPromptActiveForEntity(
    AiConfigPrompt prompt,
    JournalEntity entity,
  ) async {
    final hasTask = prompt.requiredInputData.contains(InputDataType.task);
    final hasImages = prompt.requiredInputData.contains(InputDataType.images);
    final hasAudio = prompt.requiredInputData.contains(
      InputDataType.audioFiles,
    );
    if (hasTask) {
      if (entity is Task) {
        if (prompt.aiResponseType.isPromptGenerationType) {
          return false;
        }
        return !hasImages && !hasAudio;
      } else if (entity is JournalImage && hasImages) {
        final linkedEntities = await ref
            .read(journalRepositoryProvider)
            .getLinkedToEntities(linkedTo: entity.id);
        return linkedEntities.any((e) => e is Task);
      } else if (entity is JournalAudio && hasAudio) {
        final linkedEntities = await ref
            .read(journalRepositoryProvider)
            .getLinkedToEntities(linkedTo: entity.id);
        return linkedEntities.any((e) => e is Task);
      }
      if (entity is JournalAudio &&
          prompt.aiResponseType.isPromptGenerationType) {
        final linkedEntities = await ref
            .read(journalRepositoryProvider)
            .getLinkedToEntities(linkedTo: entity.id);
        return linkedEntities.any((e) => e is Task);
      }
      return false;
    }
    if (hasImages && entity is! JournalImage) return false;
    if (hasAudio && entity is! JournalAudio) return false;
    return true;
  }
}