init

lib/playlists/playlists.dart

@@ -0,0 +1,334 @@
+// Callback fields are assigned from named required params, which can't be
+// private initializing formals.
+// ignore_for_file: prefer_initializing_formals
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:path_provider/path_provider.dart';
+
+import '../subsonic/models.dart';
+import '../subsonic/subsonic_client.dart';
+
+/// Playlists snapshot: the summaries (from `getPlaylists`) plus any full details
+/// that have been opened. Details are cached so an opened playlist keeps working
+/// offline.
+class PlaylistsState {
+  const PlaylistsState({
+    this.playlists = const [],
+    this.details = const {},
+    this.loading = false,
+  });
+
+  final List<Playlist> playlists;
+  final Map<String, PlaylistDetail> details;
+  final bool loading;
+
+  PlaylistsState copyWith({
+    List<Playlist>? playlists,
+    Map<String, PlaylistDetail>? details,
+    bool? loading,
+  }) =>
+      PlaylistsState(
+        playlists: playlists ?? this.playlists,
+        details: details ?? this.details,
+        loading: loading ?? this.loading,
+      );
+}
+
+/// Source of truth for playlists. The server is authoritative while online
+/// (mutations are optimistic and reverted on failure, mirroring
+/// `state/favorites.dart`); a per-server on-disk mirror
+/// (`playlists_<serverKey>.json`, atomic temp+rename like
+/// `library/library_index.dart`) keeps the last-known playlists + opened track
+/// lists available offline.
+class PlaylistsController extends StateNotifier<PlaylistsState> {
+  PlaylistsController({
+    required SubsonicClient? Function() clientGetter,
+    required String? Function() serverKeyGetter,
+  })  : _clientGetter = clientGetter,
+        _serverKeyGetter = serverKeyGetter,
+        super(const PlaylistsState()) {
+    reloadForServer();
+  }
+
+  final SubsonicClient? Function() _clientGetter;
+  final String? Function() _serverKeyGetter;
+
+  int _generation = 0;
+  String? _loadedKey;
+
+  // ---- Server switching ---------------------------------------------------
+
+  Future<File> _mirrorFile(String key) async {
+    final dir = await getApplicationSupportDirectory();
+    return File('${dir.path}/playlists_$key.json');
+  }
+
+  /// Load the offline mirror for the active server, then refresh from the
+  /// server when online.
+  Future<void> reloadForServer() async {
+    final key = _serverKeyGetter();
+    if (key == _loadedKey && state.playlists.isNotEmpty) {
+      // Same server, already loaded — just refresh from server if possible.
+      await hydrate();
+      return;
+    }
+    _generation++;
+    final gen = _generation;
+    _loadedKey = key;
+
+    if (key == null) {
+      state = const PlaylistsState();
+      return;
+    }
+
+    // 1. Offline mirror first (instant, works with no connection).
+    try {
+      final file = await _mirrorFile(key);
+      if (await file.exists()) {
+        final raw = jsonDecode(await file.readAsString());
+        if (raw is Map && gen == _generation) {
+          state = _fromMirror(raw.cast<String, dynamic>());
+        }
+      }
+    } catch (_) {
+      // Missing/corrupt mirror is non-fatal.
+    }
+
+    // 2. Refresh from server if connected.
+    await hydrate();
+  }
+
+  PlaylistsState _fromMirror(Map<String, dynamic> j) {
+    final playlists = (j['playlists'] as List? ?? const [])
+        .whereType<Map>()
+        .map((e) => Playlist.fromJson(e.cast<String, dynamic>()))
+        .toList();
+    final details = <String, PlaylistDetail>{};
+    final rawDetails = (j['details'] as Map?)?.cast<String, dynamic>() ?? const {};
+    rawDetails.forEach((id, v) {
+      if (v is Map) {
+        details[id] = PlaylistDetail.fromJson(v.cast<String, dynamic>());
+      }
+    });
+    return PlaylistsState(playlists: playlists, details: details);
+  }
+
+  // ---- Fetch --------------------------------------------------------------
+
+  /// Refresh the playlist list from the server (no-op offline). Keeps cached
+  /// details for playlists that still exist.
+  Future<void> hydrate() async {
+    final client = _clientGetter();
+    if (client == null) return;
+    final gen = _generation;
+    state = state.copyWith(loading: true);
+    try {
+      final playlists = await client.getPlaylists();
+      if (gen != _generation) return;
+      final liveIds = playlists.map((p) => p.id).toSet();
+      final details = {
+        for (final e in state.details.entries)
+          if (liveIds.contains(e.key)) e.key: e.value,
+      };
+      state = PlaylistsState(playlists: playlists, details: details);
+      await _persist();
+    } catch (_) {
+      if (gen == _generation) state = state.copyWith(loading: false);
+    }
+  }
+
+  /// Fetch (and cache) a playlist's full track list. Returns the cached copy
+  /// when offline, or null if never fetched.
+  Future<PlaylistDetail?> loadDetail(String id) async {
+    final client = _clientGetter();
+    if (client == null) return state.details[id];
+    final gen = _generation;
+    try {
+      final detail = await client.getPlaylist(id);
+      if (gen != _generation) return state.details[id];
+      state = state.copyWith(details: {...state.details, id: detail});
+      await _persist();
+      return detail;
+    } catch (_) {
+      return state.details[id];
+    }
+  }
+
+  // ---- Mutations (optimistic) --------------------------------------------
+
+  /// Create a playlist and return its id (null on failure / offline).
+  Future<String?> create(String name) async {
+    final client = _clientGetter();
+    if (client == null) return null;
+    try {
+      final created = await client.createPlaylist(name);
+      if (created != null) {
+        state = state.copyWith(
+          playlists: [...state.playlists, created.toSummary()],
+          details: {...state.details, created.id: created},
+        );
+        await _persist();
+        return created.id;
+      }
+      // Server didn't echo the new playlist — refetch and locate it by name.
+      final priorIds = state.playlists.map((p) => p.id).toSet();
+      await hydrate();
+      final match = state.playlists
+          .where((p) => !priorIds.contains(p.id) && p.name == name)
+          .toList();
+      return match.isNotEmpty ? match.last.id : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  Future<void> rename(String id, String name) async {
+    final client = _clientGetter();
+    if (client == null) return;
+    final prev = state;
+    state = state.copyWith(
+      playlists: [
+        for (final p in state.playlists)
+          if (p.id == id) _renamed(p, name) else p,
+      ],
+      details: {
+        for (final e in state.details.entries)
+          e.key: e.key == id ? _renamedDetail(e.value, name) : e.value,
+      },
+    );
+    try {
+      await client.renamePlaylist(id, name);
+      await _persist();
+    } catch (_) {
+      state = prev; // revert
+    }
+  }
+
+  Future<void> delete(String id) async {
+    final client = _clientGetter();
+    if (client == null) return;
+    final prev = state;
+    state = state.copyWith(
+      playlists: state.playlists.where((p) => p.id != id).toList(),
+      details: {
+        for (final e in state.details.entries)
+          if (e.key != id) e.key: e.value,
+      },
+    );
+    try {
+      await client.deletePlaylist(id);
+      await _persist();
+    } catch (_) {
+      state = prev; // revert
+    }
+  }
+
+  Future<void> addTracks(String id, List<Song> songs) async {
+    final client = _clientGetter();
+    if (client == null || songs.isEmpty) return;
+    final prev = state;
+    final detail = state.details[id];
+    if (detail != null) {
+      state = state.copyWith(details: {
+        ...state.details,
+        id: _withSongs(detail, [...detail.songs, ...songs]),
+      });
+    }
+    _bumpSummaryCount(id, songs.length);
+    try {
+      await client.addTracksToPlaylist(id, songs.map((s) => s.id).toList());
+      await _persist();
+    } catch (_) {
+      state = prev; // revert
+    }
+  }
+
+  Future<void> removeAt(String id, int index) async {
+    final client = _clientGetter();
+    if (client == null) return;
+    final prev = state;
+    final detail = state.details[id];
+    if (detail == null || index < 0 || index >= detail.songs.length) return;
+    final nextSongs = [...detail.songs]..removeAt(index);
+    state = state.copyWith(details: {
+      ...state.details,
+      id: _withSongs(detail, nextSongs),
+    });
+    _bumpSummaryCount(id, -1);
+    try {
+      await client.removeTrackFromPlaylist(id, index);
+      await _persist();
+    } catch (_) {
+      state = prev; // revert
+    }
+  }
+
+  // ---- Helpers ------------------------------------------------------------
+
+  void _bumpSummaryCount(String id, int delta) {
+    state = state.copyWith(playlists: [
+      for (final p in state.playlists)
+        if (p.id == id)
+          Playlist(
+            id: p.id,
+            name: p.name,
+            songCount: ((p.songCount ?? 0) + delta).clamp(0, 1 << 30),
+            duration: p.duration,
+            owner: p.owner,
+            public: p.public,
+            coverArt: p.coverArt,
+          )
+        else
+          p,
+    ]);
+  }
+
+  static Playlist _renamed(Playlist p, String name) => Playlist(
+        id: p.id,
+        name: name,
+        songCount: p.songCount,
+        duration: p.duration,
+        owner: p.owner,
+        public: p.public,
+        coverArt: p.coverArt,
+      );
+
+  static PlaylistDetail _renamedDetail(PlaylistDetail d, String name) =>
+      PlaylistDetail(
+        id: d.id,
+        name: name,
+        songCount: d.songCount,
+        duration: d.duration,
+        coverArt: d.coverArt,
+        songs: d.songs,
+      );
+
+  static PlaylistDetail _withSongs(PlaylistDetail d, List<Song> songs) =>
+      PlaylistDetail(
+        id: d.id,
+        name: d.name,
+        songCount: songs.length,
+        duration: d.duration,
+        coverArt: d.coverArt,
+        songs: songs,
+      );
+
+  Future<void> _persist() async {
+    final key = _serverKeyGetter();
+    if (key == null) return;
+    try {
+      final file = await _mirrorFile(key);
+      final tmp = File('${file.path}.tmp');
+      await tmp.writeAsString(jsonEncode({
+        'playlists': state.playlists.map((p) => p.toJson()).toList(),
+        'details': {
+          for (final e in state.details.entries) e.key: e.value.toJson(),
+        },
+      }));
+      await tmp.rename(file.path);
+    } catch (_) {}
+  }
+}