life-helper/app/lib/state/ai_providers.dart

import 'dart:async';

import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../data/ai/llm_service.dart';
import '../data/ai/model_lifecycle.dart';
import '../data/db/app_database.dart' as drift;
import '../domain/ai/frame_candidate.dart';
import '../domain/ai/suggest_frame.dart';
import '../domain/models/frame_pattern.dart';
import 'providers.dart';

/// Default config for the on-device Gemma model (#215).
/// OQ-1: URL + SHA-256 pinned in Developer phase. Until then, downloads are
/// disabled (AI toggle is gated behind these constants being real).
const _kModelUrlPlaceholder =
    'https://example.invalid/gemma4-e2b-q4.bin'; // OQ-1
const _kModelShaPlaceholder = 'PENDING_OQ_1';

final modelLifecycleProvider = Provider<ModelLifecycle>((ref) {
  return ModelLifecycle(
    meta: ref.watch(metaDaoProvider),
    config: ModelConfig(
      url: Uri.parse(_kModelUrlPlaceholder),
      expectedSha256: _kModelShaPlaceholder,
    ),
  );
});

/// Read-only opt-in state. Default OFF; persisted in `meta_kv`.
final aiSettingsProvider = FutureProvider<bool>((ref) async {
  final meta = ref.watch(metaDaoProvider);
  final v = await meta.find(AiMetaKeys.optIn);
  return v == 'true';
});

/// Toggles opt-in. On opt-out, purges model file via [ModelLifecycle.purge].
/// On opt-in, kicks off `ModelDownloadController.start()` so AC2 (progress UI)
/// has a stream to subscribe to.
class AiSettingsController {
  AiSettingsController(this.ref);
  final Ref ref;

  Future<int> setOptIn(bool value) async {
    final meta = ref.read(metaDaoProvider);
    if (value) {
      await meta.put(AiMetaKeys.optIn, 'true');
      ref.invalidate(aiSettingsProvider);
      ref.invalidate(modelAvailabilityProvider);
      // AC2: opt-in triggers download stream so Settings UI can render
      // progress + pause/resume. Fire-and-forget; controller emits states.
      ref.read(modelDownloadControllerProvider.notifier).start();
      return 0;
    }
    // opt-out: cancel any in-flight download, then purge.
    ref.read(modelDownloadControllerProvider.notifier).cancel();
    final freed = await ref.read(modelLifecycleProvider).purge();
    await meta.put(AiMetaKeys.optIn, 'false');
    ref.invalidate(aiSettingsProvider);
    ref.invalidate(modelAvailabilityProvider);
    return freed;
  }
}

final aiSettingsControllerProvider = Provider<AiSettingsController>((ref) {
  return AiSettingsController(ref);
});

/// AC2: streams DownloadProgress + supports pause/resume/cancel.
/// State `null` means idle (no active subscription).
class ModelDownloadController extends StateNotifier<DownloadProgress?> {
  ModelDownloadController(this.ref) : super(null);
  final Ref ref;
  StreamSubscription<DownloadProgress>? _sub;

  void start() {
    cancel();
    final lc = ref.read(modelLifecycleProvider);
    _sub = lc.download().listen(
      (p) {
        state = p;
        if (p.state == DownloadState.completed) {
          ref.invalidate(modelAvailabilityProvider);
        }
      },
      onError: (Object e) {
        state = DownloadProgress(
          bytesReceived: state?.bytesReceived ?? 0,
          totalBytes: state?.totalBytes ?? -1,
          state: DownloadState.failed,
          errorMessage: e.toString(),
        );
      },
      onDone: () {
        _sub = null;
      },
    );
  }

  /// Pauses by cancelling the subscription. .tmp file + meta_kv preserved so
  /// `start()` resumes via HTTP Range header.
  void pause() {
    _sub?.cancel();
    _sub = null;
    final cur = state;
    if (cur != null && cur.state != DownloadState.completed) {
      state = DownloadProgress(
        bytesReceived: cur.bytesReceived,
        totalBytes: cur.totalBytes,
        state: DownloadState.paused,
      );
    }
  }

  void resume() => start();

  void cancel() {
    _sub?.cancel();
    _sub = null;
    state = null;
  }

  @override
  void dispose() {
    _sub?.cancel();
    super.dispose();
  }
}

final modelDownloadControllerProvider =
    StateNotifierProvider<ModelDownloadController, DownloadProgress?>(
  (ref) => ModelDownloadController(ref),
);

final modelAvailabilityProvider =
    FutureProvider<ModelAvailability>((ref) async {
  final lc = ref.watch(modelLifecycleProvider);
  return lc.checkAvailability();
});

/// Loads FramePatterns from DB and converts to domain models.
final framePatternsProvider = FutureProvider<List<FramePatternModel>>(
  (ref) async {
    final db = ref.watch(appDatabaseProvider);
    final rows = await db.select(db.framePatterns).get();
    return rows.map(_toDomain).toList(growable: false);
  },
);

FramePatternModel _toDomain(drift.FramePattern r) => FramePatternModel(
      id: r.id,
      domain: r.domain,
      avoidanceKeyword: r.avoidanceKeyword,
      l0Example: r.l0Example,
      l1SimpleReplace: r.l1SimpleReplace,
      l2Suggestion: r.l2Suggestion,
      l3Identity: r.l3Identity,
    );

/// Singleton LLM service for the app. v1 starts unloaded; first
/// [suggestFrame] triggers `.load()` via the dialog. Override in tests with
/// `MockLlmService`.
final llmServiceProvider = Provider<LlmService>((ref) {
  throw UnimplementedError(
    'llmServiceProvider must be overridden (Mock in tests, '
    'GemmaLlmService after OQ-1 in production).',
  );
});

/// `family` param wraps a SuggestFrameInput. Loads model lazily before
/// calling suggestFrame.
final frameSuggestionsProvider = FutureProvider.autoDispose
    .family<List<FrameCandidate>, SuggestFrameInput>((ref, input) async {
  final llm = ref.watch(llmServiceProvider);
  final patterns = await ref.watch(framePatternsProvider.future);
  if (!llm.isLoaded) {
    try {
      await llm.load();
    } catch (_) {
      return const [];
    }
  }
  return suggestFrame(
    input,
    llm: llm,
    framePatterns: patterns,
  );
});