import 'dart:convert';

import 'package:dio/dio.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:relationship_saver/core/llm/captured_fact_draft_parser.dart';
import 'package:relationship_saver/core/llm/llm_config.dart';
import 'package:relationship_saver/core/llm/llm_diagnostics_log.dart';
import 'package:relationship_saver/core/llm/ollama/ollama_tool_chat_client.dart';
import 'package:relationship_saver/core/observability/sentry_init.dart';
import 'package:relationship_saver/features/people/domain/person_models.dart';
import 'package:relationship_saver/features/share_intake/domain/share_models.dart';

class LlmProviderException implements Exception {
  const LlmProviderException({
    required this.message,
    required this.provider,
    this.statusCode,
  });

  final String message;
  final LlmProvider provider;
  final int? statusCode;

  @override
  String toString() => message;
}

class LlmModelInfo {
  const LlmModelInfo({required this.id, String? label}) : label = label ?? id;

  final String id;
  final String label;
}

class LlmService {
  LlmService(this._ref);

  final Ref _ref;

  Future<LlmConfigState> get _config async {
    final state = _ref.read(llmConfigProvider);
    if (!state.isConfigured) {
      throw Exception('LLM not configured');
    }
    return state;
  }

  Future<List<GeneratedSignal>> generateSignals(
    List<PersonProfile> people,
  ) async {
    final config = await _config;
    final apiKey = await _ref.read(llmConfigProvider.notifier).getApiKey();

    if (config.provider.requiresApiKey && (apiKey == null || apiKey.isEmpty)) {
      throw Exception('No API key available');
    }

    final systemPrompt =
        '''You are a relationship assistant that helps users maintain meaningful connections with their friends and family.
Based on the person's profile data, generate helpful signals such as:
- Check-in reminders
- Gift ideas
- Follow-up suggestions
- Relationship maintenance tips

Return your response as a JSON array of signals, each with:
- title: short actionable title
- description: brief explanation
- type: "recommendation", "gift", "followup", or "reminder"
- personId: the person's ID (use a valid ID from the input if applicable)

Only return the JSON array, no other text.''';

    final peopleContext = people
        .map(
          (p) =>
              '- ${p.name} (${p.relationship}): tags=${p.tags.join(", ")}, notes=${p.notes.isEmpty ? "none" : p.notes}, affinity=${p.affinityScore}',
        )
        .join('\n');

    final userPrompt =
        '''Here are the people in my life:
$peopleContext

Generate 3-5 helpful relationship signals for these people.''';

    try {
      final response = await _callLlm(
        provider: config.provider,
        apiKey: apiKey,
        baseUrl: config.baseUrl,
        model: config.model,
        systemPrompt: systemPrompt,
        userPrompt: userPrompt,
      );

      return _parseSignalsResponse(response, people);
    } catch (e) {
      throw Exception('Failed to generate signals: $e');
    }
  }

  Future<String> completeText({
    required String systemPrompt,
    required String userPrompt,
    bool enableWebSearch = false,
  }) async {
    final config = await _config;
    final String? apiKey = await _ref
        .read(llmConfigProvider.notifier)
        .getApiKey();

    if (config.provider.requiresApiKey && (apiKey == null || apiKey.isEmpty)) {
      throw Exception('No API key available');
    }

    return _callLlm(
      provider: config.provider,
      apiKey: apiKey,
      baseUrl: config.baseUrl,
      model: config.model,
      systemPrompt: systemPrompt,
      userPrompt: userPrompt,
      enableWebSearch: enableWebSearch,
    );
  }

  Future<CapturedFactDraft?> suggestCaptureDraft(SharedPayload payload) async {
    final config = await _config;
    final String? apiKey = await _ref
        .read(llmConfigProvider.notifier)
        .getApiKey();

    if (config.provider.requiresApiKey && (apiKey == null || apiKey.isEmpty)) {
      throw Exception('No API key available');
    }

    final String systemPrompt =
        '''You analyze shared messages and links for a relationship-tracking app.
Return exactly one JSON object with:
- type: one of "note", "like", "dislike", "importantDate", "giftIdea", "placeIdea", "activityIdea", "misc"
- text: cleaned user-facing summary
- label: short optional label
- dateValue: ISO-8601 date if the content clearly describes an important date, otherwise null
- confidence: number from 0 to 1
- isSensitive: true only if the content looks private or sensitive

Be conservative. If the content is ambiguous, prefer "note". Return JSON only.''';

    final String userPrompt =
        '''Source app: ${payload.sourceApp}
Sender: ${payload.sourceDisplayName ?? "unknown"}
Platform: ${payload.platform}
URL: ${payload.url ?? "none"}
shared_message_datetime: ${payload.sharedMessageDateTime?.toIso8601String() ?? "null"}
Import received at: ${payload.receivedAt.toIso8601String()}
If shared_message_datetime is present, use it as the point-in-time reference for interpreting the message. Old status or health updates should usually become historical context or durable preferences, not current check-in prompts.
Raw text:
${payload.rawText}''';

    try {
      final String response = await _callLlm(
        provider: config.provider,
        apiKey: apiKey,
        baseUrl: config.baseUrl,
        model: config.model,
        systemPrompt: systemPrompt,
        userPrompt: userPrompt,
      );
      return parseCapturedFactDraftSuggestion(
        response,
        fallbackPayload: payload,
      );
    } catch (e) {
      throw Exception('Failed to suggest share capture draft: $e');
    }
  }

  Future<List<LlmModelInfo>> listAvailableModels({
    required LlmProvider provider,
    String? apiKey,
    String? baseUrl,
  }) async {
    final String? resolvedApiKey = apiKey != null && apiKey.trim().isNotEmpty
        ? apiKey.trim()
        : await _ref
              .read(llmConfigProvider.notifier)
              .getApiKey(provider: provider);

    if (provider.requiresApiKey &&
        (resolvedApiKey == null || resolvedApiKey.isEmpty)) {
      throw LlmProviderException(
        provider: provider,
        message: '${provider.label} needs an API key before models can load.',
      );
    }

    final Dio dio = _createDio();
    final String resolvedBaseUrl = _normalizeBaseUrl(
      baseUrl?.trim().isNotEmpty == true
          ? baseUrl!.trim()
          : provider.defaultBaseUrl,
    );

    try {
      return switch (provider) {
        LlmProvider.openai => _listOpenAIModels(
          dio,
          resolvedBaseUrl,
          resolvedApiKey,
        ),
        LlmProvider.anthropic => _listAnthropicModels(
          dio,
          resolvedBaseUrl,
          resolvedApiKey,
        ),
        LlmProvider.google => _listGoogleModels(
          dio,
          resolvedBaseUrl,
          resolvedApiKey,
        ),
        LlmProvider.ollama => _listOllamaModels(dio, resolvedBaseUrl),
        LlmProvider.openaiCompatible => _listOpenAIModels(
          dio,
          resolvedBaseUrl,
          resolvedApiKey,
        ),
      };
    } on DioException catch (error) {
      throw _mapProviderError(provider, error);
    }
  }

  Future<String> _callLlm({
    required LlmProvider provider,
    required String? apiKey,
    required String baseUrl,
    required String model,
    required String systemPrompt,
    required String userPrompt,
    bool enableWebSearch = false,
  }) async {
    final Dio dio = provider == LlmProvider.ollama
        ? _createDio(receiveTimeout: const Duration(minutes: 5))
        : _createDio();
    final String resolvedBaseUrl = _normalizeBaseUrl(baseUrl);
    await _recordDiagnostics(
      'request_start',
      'Starting ${provider.label} LLM request.',
      details: _diagnosticsDetails(
        provider: provider,
        baseUrl: resolvedBaseUrl,
        model: model,
        enableWebSearch: enableWebSearch,
        systemPrompt: systemPrompt,
        userPrompt: userPrompt,
      ),
    );

    try {
      late final String content;
      switch (provider) {
        case LlmProvider.openai:
          content = await _callOpenAI(
            dio,
            resolvedBaseUrl,
            apiKey,
            model,
            systemPrompt,
            userPrompt,
          );
        case LlmProvider.anthropic:
          content = await _callAnthropic(
            dio,
            resolvedBaseUrl,
            apiKey,
            model,
            systemPrompt,
            userPrompt,
          );
        case LlmProvider.google:
          content = await _callGoogleAI(
            dio,
            resolvedBaseUrl,
            apiKey,
            model,
            systemPrompt,
            userPrompt,
            enableWebSearch: enableWebSearch,
          );
        case LlmProvider.ollama:
          content = await _callOllama(
            dio,
            resolvedBaseUrl,
            model,
            systemPrompt,
            userPrompt,
            enableWebSearch: enableWebSearch,
          );
        case LlmProvider.openaiCompatible:
          content = await _callOpenAI(
            dio,
            resolvedBaseUrl,
            apiKey,
            model,
            systemPrompt,
            userPrompt,
          );
      }
      await _recordDiagnostics(
        'request_success',
        '${provider.label} returned a response.',
        details: _diagnosticsDetails(
          provider: provider,
          baseUrl: resolvedBaseUrl,
          model: model,
          enableWebSearch: enableWebSearch,
          systemPrompt: systemPrompt,
          userPrompt: userPrompt,
          responseLength: content.length,
        ),
      );
      return content;
    } on DioException catch (error) {
      await _recordProviderFailure(
        provider: provider,
        baseUrl: resolvedBaseUrl,
        model: model,
        enableWebSearch: enableWebSearch,
        systemPrompt: systemPrompt,
        userPrompt: userPrompt,
        error: error,
      );
      throw _mapProviderError(provider, error);
    }
  }

  Future<void> _recordDiagnostics(
    String stage,
    String message, {
    String? details,
  }) async {
    try {
      await _ref
          .read(llmDiagnosticsLogProvider)
          .record(stage, message, details: details);
    } catch (_) {
      // Diagnostics must never break the user-facing LLM flow.
    }
  }

  Future<void> _recordProviderFailure({
    required LlmProvider provider,
    required String baseUrl,
    required String model,
    required bool enableWebSearch,
    required String systemPrompt,
    required String userPrompt,
    required DioException error,
  }) {
    final int? statusCode = error.response?.statusCode;
    final String status = statusCode == null
        ? 'without HTTP status'
        : '$statusCode';
    final Map<String, dynamic> context = _diagnosticsMap(
      provider: provider,
      baseUrl: baseUrl,
      model: model,
      enableWebSearch: enableWebSearch,
      systemPrompt: systemPrompt,
      userPrompt: userPrompt,
      dioType: error.type.name,
      statusCode: statusCode,
      providerMessage: _extractProviderMessage(error.response?.data),
      responseBody: _safeJson(error.response?.data),
    );
    _ref
        .read(sentryInitProvider)
        .captureException(
          error,
          stackTrace: error.stackTrace,
          area: 'llm_provider',
          context: context,
        );
    return _recordDiagnostics(
      'provider_error',
      '${provider.label} request failed with $status.',
      details: const JsonEncoder.withIndent('  ').convert(context),
    );
  }

  Future<String> _callOpenAI(
    Dio dio,
    String baseUrl,
    String? apiKey,
    String model,
    String systemPrompt,
    String userPrompt,
  ) async {
    final Map<String, String> headers = <String, String>{
      'Content-Type': 'application/json',
      if (apiKey != null && apiKey.isNotEmpty)
        'Authorization': 'Bearer $apiKey',
    };
    final Response<Map<String, dynamic>> response = await dio
        .post<Map<String, dynamic>>(
          '$baseUrl/chat/completions',
          options: Options(headers: headers),
          data: jsonEncode({
            'model': model,
            'messages': [
              {'role': 'system', 'content': systemPrompt},
              {'role': 'user', 'content': userPrompt},
            ],
            'max_tokens': 1000,
          }),
        );

    final Map<String, dynamic> responseData = response.data!;
    final List<dynamic> choices = responseData['choices'] as List<dynamic>;
    final Map<String, dynamic> firstChoice = choices[0] as Map<String, dynamic>;
    final Map<String, dynamic> message =
        firstChoice['message'] as Map<String, dynamic>;
    final String content = message['content'] as String;
    return content;
  }

  Future<String> _callAnthropic(
    Dio dio,
    String baseUrl,
    String? apiKey,
    String model,
    String systemPrompt,
    String userPrompt,
  ) async {
    final Response<Map<String, dynamic>> response = await dio
        .post<Map<String, dynamic>>(
          '$baseUrl/messages',
          options: Options(
            headers: {
              'x-api-key': apiKey ?? '',
              'anthropic-version': '2023-06-01',
              'Content-Type': 'application/json',
            },
          ),
          data: jsonEncode({
            'model': model,
            'system': systemPrompt,
            'messages': [
              {'role': 'user', 'content': userPrompt},
            ],
            'max_tokens': 1000,
          }),
        );

    final Map<String, dynamic> responseData = response.data!;
    final List<dynamic> contentList = responseData['content'] as List<dynamic>;
    final Map<String, dynamic> firstContent =
        contentList[0] as Map<String, dynamic>;
    final String content = firstContent['text'] as String;
    return content;
  }

  Future<String> _callGoogleAI(
    Dio dio,
    String baseUrl,
    String? apiKey,
    String model,
    String systemPrompt,
    String userPrompt, {
    bool enableWebSearch = false,
  }) async {
    final String modelPath = model.startsWith('models/')
        ? model
        : 'models/$model';
    final Response<Map<String, dynamic>> response = await dio
        .post<Map<String, dynamic>>(
          '$baseUrl/$modelPath:generateContent',
          options: Options(headers: {'Content-Type': 'application/json'}),
          queryParameters: {'key': apiKey ?? ''},
          data: jsonEncode({
            'systemInstruction': {
              'parts': [
                {'text': systemPrompt},
              ],
            },
            'contents': [
              {
                'parts': [
                  {'text': userPrompt},
                ],
              },
            ],
            if (enableWebSearch)
              'tools': [
                {'google_search': <String, dynamic>{}},
              ],
            'generationConfig': {'temperature': 0.7, 'maxOutputTokens': 1000},
          }),
        );

    final Map<String, dynamic> responseData = response.data!;
    final List<dynamic> candidates =
        responseData['candidates'] as List<dynamic>;
    final Map<String, dynamic> firstCandidate =
        candidates[0] as Map<String, dynamic>;
    final Map<String, dynamic> content =
        firstCandidate['content'] as Map<String, dynamic>;
    final List<dynamic> parts = content['parts'] as List<dynamic>;
    final Map<String, dynamic> firstPart = parts[0] as Map<String, dynamic>;
    final String contentText = firstPart['text'] as String;
    return contentText;
  }

  Future<String> _callOllama(
    Dio dio,
    String baseUrl,
    String model,
    String systemPrompt,
    String userPrompt, {
    bool enableWebSearch = false,
  }) async {
    if (enableWebSearch) {
      return _ref
          .read(ollamaToolChatClientProvider)
          .complete(
            baseUrl: baseUrl,
            model: model,
            systemPrompt: systemPrompt,
            userPrompt: userPrompt,
          );
    }

    final Response<Map<String, dynamic>> response = await dio
        .post<Map<String, dynamic>>(
          '$baseUrl/api/chat',
          options: Options(headers: {'Content-Type': 'application/json'}),
          data: jsonEncode({
            'model': model,
            'stream': false,
            'messages': [
              {'role': 'system', 'content': systemPrompt},
              {'role': 'user', 'content': userPrompt},
            ],
          }),
        );

    final Map<String, dynamic> responseData = response.data!;
    final Map<String, dynamic> message =
        responseData['message'] as Map<String, dynamic>;
    return message['content'] as String;
  }

  Future<List<LlmModelInfo>> _listOpenAIModels(
    Dio dio,
    String baseUrl,
    String? apiKey,
  ) async {
    final Response<Map<String, dynamic>> response = await dio
        .get<Map<String, dynamic>>(
          '$baseUrl/models',
          options: Options(
            headers: <String, String>{
              if (apiKey != null && apiKey.isNotEmpty)
                'Authorization': 'Bearer $apiKey',
            },
          ),
        );
    final List<dynamic> data = response.data!['data'] as List<dynamic>;
    return _sortModels(
      data
          .map((dynamic item) => item as Map<String, dynamic>)
          .map((Map<String, dynamic> item) => item['id'] as String)
          .map((String id) => LlmModelInfo(id: id)),
    );
  }

  Future<List<LlmModelInfo>> _listAnthropicModels(
    Dio dio,
    String baseUrl,
    String? apiKey,
  ) async {
    final Response<Map<String, dynamic>> response = await dio
        .get<Map<String, dynamic>>(
          '$baseUrl/models',
          options: Options(
            headers: <String, String>{
              'x-api-key': apiKey ?? '',
              'anthropic-version': '2023-06-01',
            },
          ),
        );
    final List<dynamic> data = response.data!['data'] as List<dynamic>;
    return _sortModels(
      data.map((dynamic item) {
        final Map<String, dynamic> model = item as Map<String, dynamic>;
        final String id = model['id'] as String;
        return LlmModelInfo(id: id, label: model['display_name'] as String?);
      }),
    );
  }

  Future<List<LlmModelInfo>> _listGoogleModels(
    Dio dio,
    String baseUrl,
    String? apiKey,
  ) async {
    final Response<Map<String, dynamic>> response = await dio
        .get<Map<String, dynamic>>(
          '$baseUrl/models',
          queryParameters: <String, String>{'key': apiKey ?? ''},
        );
    final List<dynamic> data = response.data!['models'] as List<dynamic>;
    return _sortModels(
      data
          .map((dynamic item) => item as Map<String, dynamic>)
          .where((Map<String, dynamic> item) {
            final Object? methods = item['supportedGenerationMethods'];
            return methods is List<dynamic> &&
                methods.whereType<String>().contains('generateContent');
          })
          .map((Map<String, dynamic> item) {
            final String name = item['name'] as String;
            final String id = name.startsWith('models/')
                ? name.substring('models/'.length)
                : name;
            return LlmModelInfo(
              id: id,
              label: item['displayName'] as String? ?? id,
            );
          }),
    );
  }

  Future<List<LlmModelInfo>> _listOllamaModels(Dio dio, String baseUrl) async {
    final Response<Map<String, dynamic>> response = await dio
        .get<Map<String, dynamic>>('$baseUrl/api/tags');
    final List<dynamic> data = response.data!['models'] as List<dynamic>;
    return _sortModels(
      data.map((dynamic item) => item as Map<String, dynamic>).map((
        Map<String, dynamic> item,
      ) {
        final Object? name = item['name'] ?? item['model'];
        return LlmModelInfo(id: name as String);
      }),
    );
  }

  List<GeneratedSignal> _parseSignalsResponse(
    String response,
    List<PersonProfile> people,
  ) {
    try {
      final jsonStart = response.indexOf('[');
      final jsonEnd = response.lastIndexOf(']');

      if (jsonStart == -1 || jsonEnd == -1) {
        return [];
      }

      final jsonStr = response.substring(jsonStart, jsonEnd + 1);
      final List<dynamic> items = jsonDecode(jsonStr) as List<dynamic>;

      return items.map((item) {
        final Map<String, dynamic> itemMap = item as Map<String, dynamic>;
        final String? personId = itemMap['personId'] as String?;
        final validPersonId =
            personId != null && people.any((p) => p.id == personId)
            ? personId
            : (people.isNotEmpty ? people.first.id : null);

        return GeneratedSignal(
          title: itemMap['title'] as String? ?? 'Check in',
          description: itemMap['description'] as String? ?? '',
          type: itemMap['type'] as String? ?? 'recommendation',
          personId: validPersonId,
        );
      }).toList();
    } catch (e) {
      return [];
    }
  }
}

LlmProviderException _mapProviderError(
  LlmProvider provider,
  DioException error,
) {
  final int? statusCode = error.response?.statusCode;
  final String providerName = _providerLabel(provider);
  final String? providerMessage = _extractProviderMessage(error.response?.data);

  if (statusCode == 429) {
    final String detail = providerMessage == null ? '' : ' $providerMessage';
    return LlmProviderException(
      provider: provider,
      statusCode: statusCode,
      message:
          '$providerName rejected the digest request with 429 rate limiting or quota pressure.$detail Check that the API key has available billing/quota, wait for the provider limit to reset, or switch to another configured provider.',
    );
  }

  if (error.type == DioExceptionType.connectionTimeout ||
      error.type == DioExceptionType.sendTimeout ||
      error.type == DioExceptionType.receiveTimeout) {
    return LlmProviderException(
      provider: provider,
      statusCode: statusCode,
      message: '$providerName timed out while running the digest request.',
    );
  }

  if (error.type == DioExceptionType.connectionError) {
    return LlmProviderException(
      provider: provider,
      statusCode: statusCode,
      message:
          'Could not reach $providerName. Check the network connection and provider endpoint availability.',
    );
  }

  final String statusText = statusCode == null ? '' : ' HTTP $statusCode.';
  final String detail = providerMessage == null ? '' : ' $providerMessage';
  return LlmProviderException(
    provider: provider,
    statusCode: statusCode,
    message:
        '$providerName could not complete the digest request.$statusText$detail',
  );
}

String _diagnosticsDetails({
  required LlmProvider provider,
  required String baseUrl,
  required String model,
  required bool enableWebSearch,
  required String systemPrompt,
  required String userPrompt,
  int? responseLength,
  String? dioType,
  int? statusCode,
  String? providerMessage,
  String? responseBody,
}) {
  return const JsonEncoder.withIndent('  ').convert(
    _diagnosticsMap(
      provider: provider,
      baseUrl: baseUrl,
      model: model,
      enableWebSearch: enableWebSearch,
      systemPrompt: systemPrompt,
      userPrompt: userPrompt,
      responseLength: responseLength,
      dioType: dioType,
      statusCode: statusCode,
      providerMessage: providerMessage,
      responseBody: responseBody,
    ),
  );
}

Map<String, dynamic> _diagnosticsMap({
  required LlmProvider provider,
  required String baseUrl,
  required String model,
  required bool enableWebSearch,
  required String systemPrompt,
  required String userPrompt,
  int? responseLength,
  String? dioType,
  int? statusCode,
  String? providerMessage,
  String? responseBody,
}) {
  final Map<String, dynamic> diagnostics = <String, dynamic>{
    'provider': provider.name,
    'baseUrl': baseUrl,
    'model': model,
    'webSearchRequested': enableWebSearch,
    'systemPromptChars': systemPrompt.length,
    'userPromptChars': userPrompt.length,
  };
  if (responseLength != null) {
    diagnostics['responseChars'] = responseLength;
  }
  if (dioType != null) {
    diagnostics['dioType'] = dioType;
  }
  if (statusCode != null) {
    diagnostics['statusCode'] = statusCode;
  }
  if (providerMessage != null) {
    diagnostics['providerMessage'] = providerMessage;
  }
  if (responseBody != null) {
    diagnostics['responseBody'] = responseBody;
  }
  return diagnostics;
}

String? _safeJson(Object? data) {
  if (data == null) {
    return null;
  }
  try {
    final String encoded = data is String
        ? data
        : const JsonEncoder.withIndent('  ').convert(data);
    return _compactDiagnosticValue(encoded);
  } catch (_) {
    return _compactDiagnosticValue('$data');
  }
}

String _compactDiagnosticValue(String value) {
  final String compacted = value.trim().replaceAll(RegExp(r'\s+'), ' ');
  if (compacted.length <= 3000) {
    return compacted;
  }
  return '${compacted.substring(0, 2997)}...';
}

String _normalizeBaseUrl(String baseUrl) {
  String normalized = baseUrl.trim();
  while (normalized.endsWith('/')) {
    normalized = normalized.substring(0, normalized.length - 1);
  }
  return normalized;
}

Dio _createDio({Duration receiveTimeout = const Duration(seconds: 20)}) {
  return Dio(
    BaseOptions(
      connectTimeout: const Duration(seconds: 20),
      receiveTimeout: receiveTimeout,
      sendTimeout: const Duration(seconds: 20),
    ),
  );
}

List<LlmModelInfo> _sortModels(Iterable<LlmModelInfo> models) {
  final List<LlmModelInfo> sorted = models.toList();
  sorted.sort(
    (LlmModelInfo a, LlmModelInfo b) =>
        a.label.toLowerCase().compareTo(b.label.toLowerCase()),
  );
  return sorted;
}

String _providerLabel(LlmProvider provider) {
  return provider.label;
}

String? _extractProviderMessage(Object? data) {
  if (data is Map<String, dynamic>) {
    final Object? direct = data['message'];
    if (direct is String && direct.trim().isNotEmpty) {
      return _compactProviderMessage(direct);
    }

    final Object? error = data['error'];
    if (error is String && error.trim().isNotEmpty) {
      return _compactProviderMessage(error);
    }
    if (error is Map<String, dynamic>) {
      final Object? nested = error['message'];
      if (nested is String && nested.trim().isNotEmpty) {
        return _compactProviderMessage(nested);
      }
    }
  }

  return null;
}

String _compactProviderMessage(String value) {
  final String compacted = value.trim().replaceAll(RegExp(r'\s+'), ' ');
  if (compacted.length <= 240) {
    return compacted;
  }
  return '${compacted.substring(0, 237)}...';
}

class GeneratedSignal {
  const GeneratedSignal({
    required this.title,
    required this.description,
    required this.type,
    this.personId,
  });

  final String title;
  final String description;
  final String type;
  final String? personId;
}

final llmServiceProvider = Provider<LlmService>((Ref ref) {
  return LlmService(ref);
});