import 'dart:async'; 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 '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(); /// 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); } /// 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); } } @override void dispose() { _sessions.dispose(); super.dispose(); } @override Widget build(BuildContext context) { final selected = _selected; final row = selected == null ? null : _rowFor(selected); final start = _startNotice; return Stack( children: [ Offstage( offstage: selected != null, child: ChatSessionsScreen( gateway: widget.gateway, embedded: true, syncToken: widget.syncToken, controller: _sessions, onOpen: _open, onSessions: _adoptRows, activeSessionId: selected, ), ), if (selected != null) ChatThreadView( key: ValueKey('chat-session-$selected'), gateway: widget.gateway, sessionId: selected, title: '${row?['title'] ?? ''}'.trim(), session: row, syncToken: widget.syncToken, scrollPositions: _scrollPositions, initialNotice: start != null && start.id == selected ? start.notice : null, onBack: _back, onModelChanged: (applied) => _modelChanged(selected, applied), onCreatedSession: _openCreated, onSessionRenamed: (title) => _renamed(selected, title), onSessionClosed: _closed, ), ], ); } }