import '../../shell/destination.dart'; import '../../shell/detail_page.dart'; import '../../shell/empty_detail_pane.dart'; import '../../shell/list_detail.dart'; import 'dart:async'; import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import '../../core/api_gateway.dart'; import 'conversation/chat_models.dart'; import 'conversation/chat_scroll.dart'; import 'conversation/chat_thread_view.dart'; import 'conversation/chat_transcript_cache.dart'; import 'data/chat_repository.dart'; import 'ui/sessions/chat_sessions_controller.dart'; import 'ui/sessions/chat_sessions_screen.dart'; /// The Chat destination's list/detail switch. /// /// The route names the open session, so a row tap, a deep link and Back all /// navigate through the same value. The session list stays mounted (offstage) /// while a conversation is open, so returning to it keeps its rows and query. /// The destination owns the list controller too, so a session a conversation's /// `/new` creates is listed, opened and refreshed from here. /// The shell owns the app bar; this screen adds no second one. class ChatScreen extends StatefulWidget { const ChatScreen({ super.key, required this.gateway, this.initialSessionId, this.syncToken = 0, this.onSessionSelected, this.onBack, }); final ApiGateway gateway; /// The chat session the current route names, or null for the list. final String? initialSessionId; /// Advances when the shared socket is replaced. The open conversation /// re-subscribes and re-reads in place, so its selection survives. final int syncToken; final ValueChanged? onSessionSelected; final VoidCallback? onBack; @override State createState() => _ChatScreenState(); } class _ChatScreenState extends State { /// The list's controller, shared with the mounted list screen. The list /// screen refreshes it on mount and swaps its repository when the socket is /// replaced; this destination lists created rows and re-reads after a /// conversation's command changes a session. late final ChatSessionsController _sessions = ChatSessionsController( ChatRepository(widget.gateway), ); /// Rows this visit has opened, used for the native title and the recorded /// model facts. The mounted list also reports its loaded rows, so a routed id /// (a deep link) resolves the same row without a second list request. final Map _openedSessions = {}; /// Model switches the server accepted after a row was opened. The row that /// opened the conversation may still carry the pre-switch model, so these win /// for the rest of this visit, including when the same chat is reopened. final Map _acceptedModels = {}; /// Transcript positions for this visit. It lives with the destination, not a /// conversation view, so Back and a reopened chat return to the same place. final ChatScrollStore _scrollPositions = MemoryChatScrollStore(); /// Transcripts of recently left chats for this visit, so a reopened chat /// shows its last transcript at once while it re-subscribes and re-reads. /// Bounded and in memory only; see [ChatTranscriptCache]. final ChatTranscriptCache _transcripts = ChatTranscriptCache(); /// The line a just-created conversation opens on, tied to the selection /// `/new` made. Leaving that conversation drops it, so a later reopen is an /// ordinary visit. ({String id, String notice})? _startNotice; String? _standaloneSelection; String? get _selected { final routed = widget.initialSessionId; if (routed != null && routed.isNotEmpty) return routed; return _standaloneSelection; } void _open(JsonMap session) { final id = '${session['id'] ?? ''}'; if (id.isEmpty) return; _openedSessions[id] = session; if (_startNotice?.id != id) _startNotice = null; final select = widget.onSessionSelected; if (select != null) { select(id); } else { setState(() => _standaloneSelection = id); } } /// `/new` created [session]: list it at the head before its conversation /// opens, open it on [notice], then re-read the list from the server. void _openCreated(JsonMap session, String notice) { final id = '${session['id'] ?? ''}'; if (id.isEmpty) return; _sessions.insertCreated(session); _startNotice = (id: id, notice: notice); _open(session); unawaited(_sessions.refresh()); } /// `/rename` was accepted for [id]: the opened row follows the shared title /// and the list re-reads it. void _renamed(String id, String title) { final row = _openedSessions[id]; if (row != null) { setState(() => _openedSessions[id] = {...row, 'title': title}); } unawaited(_sessions.refresh()); } /// `/close` was accepted: the conversation leaves, back to the list, which /// re-reads the closed row. void _closed() { _back(); unawaited(_sessions.refresh()); } /// Adopts the list's loaded rows for the routed session: a deep link opens /// the conversation before any row has been tapped, and the header's title /// and model control come from that row. Called after a frame, never during /// the list's own build. void _adoptRows(List rows) { final id = _selected; if (id == null || _openedSessions.containsKey(id)) return; for (final row in rows) { if ('${row['id'] ?? ''}' != id) continue; setState(() => _openedSessions[id] = row); return; } } void _modelChanged(String id, ChatModelSelection applied) { if (!mounted) return; setState(() => _acceptedModels[id] = applied); } /// An accepted mode switch updates the opened row, so reopening the chat in /// this visit shows it before the list re-reads. void _modeChanged(String id, String mode, String name) { final row = _openedSessions[id]; if (!mounted || row == null) return; setState( () => _openedSessions[id] = {...row, 'mode': mode, 'mode_name': name}, ); } /// The row to open for [id], with an accepted model folded in. JsonMap? _rowFor(String id) { final row = _openedSessions[id]; final accepted = _acceptedModels[id]; if (row == null || accepted == null) return row; return { ...row, 'model': accepted.model, 'model_provider': accepted.provider, 'model_selection': accepted.selection, }; } void _back() { _startNotice = null; final back = widget.onBack; if (back != null) { back(); } else { setState(() => _standaloneSelection = null); } } /// On a phone the open chat is a real page above the main screen. final DetailPageHost _page = DetailPageHost(); @override void didUpdateWidget(covariant ChatScreen oldWidget) { super.didUpdateWidget(oldWidget); // Transcripts read through another gateway belong to that server. if (oldWidget.gateway != widget.gateway) _transcripts.clear(); } @override void dispose() { _page.dispose(); _sessions.dispose(); super.dispose(); } Widget _thread(String selected, VoidCallback onBack) { final row = _rowFor(selected); final start = _startNotice; return ChatThreadView( key: ValueKey('chat-session-$selected'), gateway: widget.gateway, sessionId: selected, title: '${row?['title'] ?? ''}'.trim(), session: row, syncToken: widget.syncToken, scrollPositions: _scrollPositions, transcripts: _transcripts, initialNotice: start != null && start.id == selected ? start.notice : null, onBack: onBack, onModelChanged: (applied) => _modelChanged(selected, applied), onModeChanged: (mode, name) => _modeChanged(selected, mode, name), onCreatedSession: _openCreated, onSessionRenamed: (title) => _renamed(selected, title), onSessionClosed: _closed, ); } @override Widget build(BuildContext context) { final selected = _selected; // A phone opens a chat as a real Navigator page with stock Back. A wide // window keeps the destination rail and the chat list beside the open // chat, which has no Back: another row, `/close` or a route change swaps it. final beside = showsListBesideDetail(context); _page.sync( context, selected: selected != null && !beside, destination: AppDestination.chat, onClosed: _back, builder: (context) => selected == null ? const SizedBox.shrink() : _thread(selected, () => Navigator.of(context).maybePop()), ); // The session list pads its first row by the bar's height itself, so it // scrolls behind the shell's floating bar like the other lists. final list = ChatSessionsScreen( gateway: widget.gateway, embedded: true, syncToken: widget.syncToken, controller: _sessions, onOpen: _open, onSessions: _adoptRows, activeSessionId: selected, publishShellBar: true, ); if (!beside) return list; return ListDetailPanes( list: list, detailIdentity: selected, detail: selected == null ? const EmptyDetailPane( destination: AppDestination.chat, message: 'Select a chat to open it here.', ) : DetailPane( key: const ValueKey('chat-detail-pane'), destination: AppDestination.chat, implyBack: false, builder: (context) => _thread(selected, _back), ), ); } }