feat: continuing textual development

Author: kc1awv

client/app.css renamed to client/app.tcss

@@ -16,10 +16,18 @@ Screen {
     color: white;
 }
 
+.address_book {
+    height: 1fr;
+}
+
 .server-list {
     height: 1fr;
 }
 
+.tabs {
+    height: 1fr;
+}
+
 .debug-log {
     height: 7;
     border: round gray;
@@ -48,3 +56,33 @@ Screen {
     background: transparent;    /* No background unless explicitly needed */
     color: white;        /* Text color */
 }
+
+ServerDetailScreen {
+    align: center middle;
+}
+
+#server_details_dialog {
+    grid-size: 3;
+    grid-gutter: 1 2;
+    grid-rows: 1fr 3;
+    padding: 0 1;
+    width: 99;
+    height: 11;
+    border: thick $background 80%;
+    background: $surface;
+}
+
+#server_details {
+    column-span: 3;
+    height: 1fr;
+    width: 1fr;
+    content-align: center top;
+    padding: 1;
+}
+
+.button {
+    width: 1fr;
+    height: 1fr;
+    padding: 0 1;
+    content-align: center middle;
+}

client/retibbs_textual.py

@@ -5,13 +5,16 @@
 import re
 import time
 
-from textual.app import App
-from textual.widgets import Header, Footer, Input, Log, DataTable, Static
+from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import Horizontal, Vertical
+from textual.containers import Horizontal, Vertical, Grid
+from textual.screen import ModalScreen
+from textual.widgets import Header, Footer, TabbedContent, TabPane, Input, Log, DataTable, Static, Button, Label
 
 import RNS
 
+ADDRESS_BOOK_FILE = "address_book.json"
+
 class AnnounceHandler:
     def __init__(self, app, aspect_filter=None):
         self.app = app
@@ -44,11 +47,48 @@ def received_announce(self, destination_hash, announced_identity, app_data):
         #    f"[ANNOUNCE] {timestamp} - {display_name} ({dest_hash_display})"
         #)
 
-        # Call the app's `on_announce` function to update the table
         self.app.on_announce(destination_hash, announced_identity, app_data)
 
+class ServerDetailScreen(ModalScreen):
+    """Screen to display server details."""
+
+    def __init__(self, server_name, destination_hash, timestamp, on_connect, saved_in_address_book):
+        super().__init__()
+        self.server_name = server_name
+        self.destination_hash = destination_hash
+        self.timestamp = timestamp
+        self.on_connect = on_connect
+        self.saved_in_address_book = saved_in_address_book
+
+    def compose(self) -> ComposeResult:
+        yield Grid(
+            Label(
+                f"Server Name: {self.server_name}\nDestination Hash: {self.destination_hash}\nLast Heard: {self.timestamp}", 
+                id="server_details"
+            ),
+            Button("Connect", id="connect", variant="success", classes="button"),
+            Button(
+                "Remove from Address Book" if self.saved_in_address_book else "Save to Address Book",
+                id="toggle_address_book",
+                variant="primary",
+                classes="button",
+            ),
+            Button("Close", id="close", variant="default", classes="button"),
+            id="server_details_dialog",
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "connect":
+            asyncio.create_task(self.on_connect(self.destination_hash))
+            self.app.pop_screen()
+        elif event.button.id == "toggle_address_book":
+            self.app.pop_screen()
+            self.app.toggle_address_book(self.destination_hash, self.saved_in_address_book)
+        elif event.button.id == "close":
+            self.app.pop_screen()
+
 class RetiBBSClient(App):
-    CSS_PATH = "app.css"
+    CSS_PATH = "app.tcss"
 
     BINDINGS = [
         Binding(key="q", action="quit", description="Quit the app"),
@@ -62,32 +102,73 @@ class RetiBBSClient(App):
 
     def __init__(self, server_hexhash=None):
         super().__init__()
+        self._deferred_debug_log = []
         self.server_hexhash = server_hexhash
         self.client_identity = None
         self.link = None
         self.servers = {}
+        self.address_book = {}
+        self.active_tab = "servers"
+        self.server_list_update_pending = False
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         yield Header()
+        
+        server_tab = TabPane(title="Servers", id="servers")
+        server_tab.compose_add_child(
+            DataTable(id="server_list", classes="server-list", cursor_type="row")
+        )
+        
+        address_tab = TabPane(title="Address Book", id="address_book")
+        address_tab.compose_add_child(
+            DataTable(id="address_book", classes="address-book", cursor_type="row")
+        )
+        
+        tabs = TabbedContent(id="tabs", classes="tabs")
+        tabs.compose_add_child(server_tab)
+        tabs.compose_add_child(address_tab)
+        tabs.default_tab = "Servers"
+        
         yield Horizontal(
             Vertical(
                 Log(id="main_log"),
                 Input(placeholder="Enter command...", id="command_input"),
-                id="left_panel",
+                id="left_panel"
             ),
             Vertical(
-                Static("Servers", id="server_list_title"),
-                DataTable(id="server_list", classes="server-list"),
+                tabs,
                 Log(id="debug_log", classes="debug-log"),
-                id="right_panel",
+                id="right_panel"
             ),
-            id="main_body",
+            id="main_body"
         )
         yield Footer()
+    
+    def load_address_book(self):
+        if os.path.exists(ADDRESS_BOOK_FILE):
+            try:
+                with open(ADDRESS_BOOK_FILE, "r") as file:
+                    address_book = json.load(file)
+                    self._deferred_debug_log.append(f"[DEBUG] Address book loaded: {address_book}")
+                    return address_book
+            except Exception as e:
+                self._deferred_debug_log.append(f"[DEBUG] Error loading address book: {e}")
+        return {}
+    
+    def save_address_book(self):
+        with open(ADDRESS_BOOK_FILE, "w") as file:
+            json.dump(self.address_book, file, indent=4)
 
     def write_debug_log(self, message):
-        debug_log = self.query_one("#debug_log", Log)
-        debug_log.write_line(message)
+        try:
+            # Attempt to find the debug log and write the message
+            debug_log = self.query_one("#debug_log", Log)
+            debug_log.write_line(message)
+        except Exception:
+            # Defer the message if the debug log is not found
+            if not hasattr(self, "_deferred_debug_log"):
+                self._deferred_debug_log = []
+            self._deferred_debug_log.append(message)
 
     def write_log(self, message):
         log = self.query_one("#main_log", Log)
@@ -138,7 +219,28 @@ async def on_mount(self):
         self.title = "- RetiBBS Client -"
 
         server_list = self.query_one("#server_list", DataTable)
-        server_list.add_columns("Server Name", "Destination Hash")
+        if not server_list.columns:
+            server_list.add_columns("Server Name", "Destination Hash")
+
+        address_book = self.query_one("#address_book", DataTable)
+        if not address_book.columns:
+            address_book.add_columns("Server Name", "Destination Hash")
+
+        server_list.visible = True
+        address_book.visible = True
+
+        # Log deferred errors (if any)
+        if hasattr(self, "_deferred_debug_log"):
+            for message in self._deferred_debug_log:
+                try:
+                    debug_log = self.query_one("#debug_log", Log)
+                    debug_log.write_line(message)
+                except Exception:
+                    continue  # Skip if still unavailable
+            self._deferred_debug_log.clear()
+
+        self.address_book = self.load_address_book()
+        self.update_address_book()
 
         self.write_log("Initializing Reticulum...")
         try:
@@ -161,16 +263,17 @@ async def on_mount(self):
         else:
             self.write_log("Server hexhash not provided. Please wait for an announce...")
 
-    async def connect_client(self):
-        if not self.server_hexhash:
+    async def connect_client(self, destination_hash=None):
+        server_hexhash = destination_hash or self.server_hexhash
+        if not server_hexhash:
             self.write_log("[CONNECT] Failed: No server hexhash provided.")
             return
 
         try:
             try:
-                server_addr = bytes.fromhex(self.server_hexhash)
+                server_addr = bytes.fromhex(server_hexhash)
             except ValueError:
-                self.write_log(f"[CONNECT] Failed: Invalid server hexhash: {self.server_hexhash}.")
+                self.write_log(f"[CONNECT] Failed: Invalid server hexhash: {server_hexhash}.")
                 return
 
             if not RNS.Transport.has_path(server_addr):
@@ -233,9 +336,8 @@ async def wait_for_link(self):
             await asyncio.sleep(0.1)
 
     def on_link_established(self, link):
-        self.write_log("Connected to the RetiBBS server.")
-        self.write_log("[DEBUG] Link established!")
-        self.write_log(f"[DEBUG] Link status: {link.status}")
+        self.write_debug_log("[DEBUG] Link established!")
+        self.write_debug_log(f"[DEBUG] Link status: {link.status}")
 
     def on_link_closed(self, link):
         self.write_log("Disconnected from the RetiBBS server.")
@@ -302,10 +404,12 @@ async def on_input_submitted(self, message: Input.Submitted):
         message.input.value = ""
 
     def on_announce(self, destination_hash, announced_identity, app_data):
-        self.write_debug_log("[ANNOUNCE] [Callback] Received announce packet.")
+        # TOREMOVE: Debug log
+        #self.write_debug_log("[ANNOUNCE] [Callback] Received announce packet.")
 
         dest_hash_hex = destination_hash.hex()
         display_name = RNS.prettyhexrep(destination_hash)
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
         if app_data:
             try:
@@ -318,17 +422,53 @@ def on_announce(self, destination_hash, announced_identity, app_data):
         self.servers[dest_hash_hex] = {
             "display_name": display_name,
             "hash": dest_hash_hex,
+            "timestamp": timestamp,
         }
 
         self.call_later(self.update_server_list)
 
         self.write_debug_log(f"[ANNOUNCE] Discovered server: {display_name} ({dest_hash_hex})")
 
     def update_server_list(self):
-        server_list = self.query_one("#server_list", DataTable)
-        server_list.clear()
-        for server in self.servers.values():
-            server_list.add_row(server["display_name"], server["hash"])
+        try:
+            # Check if a modal is currently active
+            if len(self.screen_stack) > 1 and isinstance(self.screen_stack[-1], ModalScreen):
+                if not self.server_list_update_pending:
+                    self.server_list_update_pending = True  # Set flag to avoid repeated deferrals
+                    self.write_debug_log("[INFO] Modal is active, deferring server list update.")
+                    self.call_later(self.update_server_list)  # Defer the update
+                return
+
+            # Proceed with updating the server list
+            self.server_list_update_pending = False  # Reset the flag
+            server_list = self.query_one("#server_list", DataTable)
+            server_list.clear()
+            for server in self.servers.values():
+                server_list.add_row(server["display_name"], server["hash"])
+            self.write_debug_log("[DEBUG] Server list updated successfully.")
+        except Exception as e:
+            self.server_list_update_pending = False  # Ensure the flag is reset on error
+            self.write_debug_log(f"[ERROR] Error updating server list: {e}")
+    
+    def update_address_book(self):
+        try:
+            address_book = self.query_one("#address_book", DataTable)
+            address_book.clear()
+            for server in self.address_book.values():
+                address_book.add_row(server["display_name"], server["hash"])
+                self.write_debug_log(f"[DEBUG] Added to address book: {server['display_name']} - {server['hash']}")
+            self.write_debug_log("[DEBUG] Address book updated successfully.")
+        except Exception as e:
+            self.write_debug_log(f"[DEBUG] Error updating address book: {e}")
+    
+    def toggle_address_book(self, destination_hash, currently_saved):
+        if currently_saved:
+            del self.address_book[destination_hash]
+        else:
+            server = self.servers[destination_hash]
+            self.address_book[destination_hash] = server
+        self.save_address_book()
+        self.update_address_book()
 
     def action_refresh_servers(self):
         self.write_log("[ACTION] Refreshing server list...")
@@ -337,6 +477,48 @@ def action_refresh_servers(self):
         server_list.add_columns("Server Name", "Destination Hash")
         for server in self.servers.values():
             server_list.add_row(server["display_name"], server["hash"])
+    
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        try:
+            # Get the triggering table
+            triggering_table = event.control
+            table_id = triggering_table.id  # Retrieve the table's ID
+            self.write_debug_log(f"[ACTION] Selected row in table: {table_id}, row key: {event.row_key}")
+
+            if table_id == "server_list":
+                # Handle server list selection
+                row_data = triggering_table.get_row(event.row_key)
+                if row_data:
+                    server_name, destination_hash = row_data
+                    server_info = self.servers.get(destination_hash)
+                    if server_info:
+                        self.push_screen(
+                            ServerDetailScreen(
+                                server_name=server_info["display_name"],
+                                destination_hash=server_info["hash"],
+                                timestamp=server_info["timestamp"],
+                                on_connect=self.connect_client,
+                                saved_in_address_book=destination_hash in self.address_book,
+                            )
+                        )
+            elif table_id == "address_book":
+                # Handle address book selection
+                row_data = triggering_table.get_row(event.row_key)
+                if row_data:
+                    server_name, destination_hash = row_data
+                    server_info = self.address_book.get(destination_hash)
+                    if server_info:
+                        self.push_screen(
+                            ServerDetailScreen(
+                                server_name=server_info["display_name"],
+                                destination_hash=server_info["hash"],
+                                timestamp=server_info["timestamp"],
+                                on_connect=self.connect_client,
+                                saved_in_address_book=True,
+                            )
+                        )
+        except Exception as e:
+            self.write_debug_log(f"[ERROR] Exception in row selection: {e}")
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="RetiBBS Client")