feat: Implement chat functionality with message encryption and decryption

- Added MessageView model to represent messages in the chat.
- Created ChatViewScreen for displaying chat messages and sending new messages.
- Integrated message sending and receiving with encryption using KeyProvider.
- Implemented message storage and retrieval in SecureStorage.
- Enhanced NodeService to fetch current user and device IDs.
- Added MessageService to handle message operations including fetching pending messages and sending messages.
- Updated ChooseUsernameScreen to navigate to ConversationsScreen upon completion.
- Refactored ConversationsScreen to display chat views and manage conversation selection.
- Introduced session management with ratchet keys for secure messaging.
- Updated dependencies in pubspec.yaml and pubspec.lock for uuid and other packages.

Author: AdamLBS

lib/data/node/sessions/create_session.dart

@@ -129,6 +129,59 @@ Future<bool> createSession(String nodeUrl, String recipientUserId) async {
         nonce: utf8.encode('HushNet-Salt'), // facultatif mais conseillé
         info: utf8.encode('X3DH Root Key'),
       );
+      final sendChainKey = await hkdf.deriveKey(
+        secretKey: rootKey,
+        nonce: utf8.encode('HushNet-Salt'),
+        info: utf8.encode('HushNet-Send-Chain'),
+      );
+
+      final recvChainKey = await hkdf.deriveKey(
+        secretKey: rootKey,
+        nonce: utf8.encode('HushNet-Salt'),
+        info: utf8.encode('HushNet-Recv-Chain'),
+      );
+
+      // 🧩 Génère ton propre ratchet keypair (X25519)
+      final ratchetAlgo = X25519();
+      final ratchetPair = await ratchetAlgo.newKeyPair();
+      final ratchetPub = await ratchetPair.extractPublicKey();
+      final ratchetPriv = await ratchetPair.extractPrivateKeyBytes();
+
+      // 🗄️ Sauvegarde dans SecureStorage
+      final rootB64 = base64Encode(await rootKey.extractBytes());
+      final sendB64 = base64Encode(await sendChainKey.extractBytes());
+      final recvB64 = base64Encode(await recvChainKey.extractBytes());
+      final ratchetPubB64 = base64Encode(ratchetPub.bytes);
+      final ratchetPrivB64 = base64Encode(ratchetPriv);
+
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_root",
+        value: rootB64,
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_send_chain",
+        value: sendB64,
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_recv_chain",
+        value: recvB64,
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_ratchet_pub",
+        value: ratchetPubB64,
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_ratchet_priv",
+        value: ratchetPrivB64,
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_send_counter",
+        value: "0",
+      );
+      await keyProvider.secureStorage.write(
+        key: "session_${device.deviceId}_recv_counter",
+        value: "0",
+      );
 
       // 6. encrypt initial plaintext with AES-GCM-256 using rootKey
       final nonce = aes.newNonce();

lib/models/message_view.dart

@@ -0,0 +1,35 @@
+class MessageView {
+  final String id;
+  final String logicalMsgId;
+  final String chatId;
+  final String fromUserId;
+  final String fromDeviceId; // ✅ ajouté
+  final String ciphertext;
+  DateTime createdAt;
+  final bool pending;
+
+  MessageView({
+    required this.id,
+    required this.logicalMsgId,
+    required this.chatId,
+    required this.fromUserId,
+    required this.fromDeviceId,
+    required this.ciphertext,
+    required this.createdAt,
+    this.pending = false,
+  });
+
+  factory MessageView.fromJson(Map<String, dynamic> json) {
+    return MessageView(
+      id: json['id'],
+      logicalMsgId: json['logical_msg_id'],
+      chatId: json['chat_id'],
+      fromUserId: json['from_user_id'],
+      fromDeviceId: json['from_device_id'], // ✅
+      ciphertext: json['ciphertext'],
+      createdAt: json['from_device_id'] == "SELF_DEVICE"
+          ? DateTime.parse(json['created_at'])
+          : DateTime.parse(json['created_at']),
+    );
+  }
+}

lib/screens/chat_view_screen.dart

@@ -0,0 +1,238 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:hushnet_frontend/data/node/sessions/create_session.dart';
+import 'package:hushnet_frontend/models/chat_view.dart';
+import 'package:hushnet_frontend/models/message_view.dart';
+import 'package:hushnet_frontend/services/key_provider.dart';
+import 'package:hushnet_frontend/services/message_service.dart';
+import 'package:hushnet_frontend/services/node_service.dart';
+
+class ChatViewScreen extends StatefulWidget {
+  final String chatId;
+  final String displayName;
+  final bool embedded; // 👈 si affiché à droite (desktop)
+  final ChatView chatView;
+
+  const ChatViewScreen({
+    super.key,
+    required this.chatId,
+    required this.displayName,
+    this.embedded = false, required this.chatView,
+  });
+
+  @override
+  State<ChatViewScreen> createState() => _ChatViewScreenState();
+}
+
+class _ChatViewScreenState extends State<ChatViewScreen> {
+  final MessageService messageService = MessageService();
+  final TextEditingController _controller = TextEditingController();
+  List<MessageView> _messages = [];
+  bool _loading = true;
+  late Timer _refreshTimer;
+  final NodeService _nodeService = NodeService();
+  String? _currentUserId;
+
+  @override
+  void initState() {
+    super.initState();
+    _nodeService.getCurrentUserId().then((id) {
+      setState(() {
+        _currentUserId = id;
+      });
+    });
+    _loadMessages();
+    // auto refresh toutes les 10 secondes
+    _refreshTimer = Timer.periodic(const Duration(seconds: 10), (_) {
+      _loadMessages();
+    });
+  }
+
+  @override
+  void dispose() {
+    _refreshTimer.cancel();
+    _controller.dispose();
+    super.dispose();
+  }
+
+Future<void> _loadMessages() async {
+  try {
+    setState(() => _loading = true);
+    final all = await messageService.getAllMessagesForChat(widget.chatId);
+    // 🕒 tri croissant (vieux → récents)
+     DateTime normalize(DateTime d) {
+    final s = d.toIso8601String();
+    print("normalizing date string: $s");
+    // Si la date n'a pas de "Z" ni d'offset, on la traite comme locale et on force en UTC
+    if (!s.endsWith('Z') && !s.contains('+')) {
+      print("manque zone info, normalizing to UTC for $s");
+      final res =  DateTime.utc(
+        d.year,
+        d.month,
+        d.day,
+        d.hour,
+        d.minute,
+        d.second,
+        d.millisecond,
+        d.microsecond,
+      ).toUtc();
+      print("normalized date: ${res.toIso8601String()}");
+      return res;
+    }
+    return d.toUtc();
+  }
+  for (final msg in all) {
+    msg.createdAt = normalize(msg.createdAt);
+  }
+  all.sort((a, b) => a.createdAt.compareTo(b.createdAt));
+    for (final msg in all) {
+      print('Message from ${msg.fromUserId}: ${msg.ciphertext} at ${msg.createdAt}');
+    }
+
+    setState(() {
+      _messages = all;
+      _loading = false;
+    });
+  } catch (e) {
+    debugPrint("Error loading messages: $e");
+    setState(() => _loading = false);
+  }
+}
+
+Future<void> _sendMessage() async {
+  final text = _controller.text.trim();
+  if (text.isEmpty || _currentUserId == null) return;
+
+  try {
+    final keyProvider = KeyProvider();
+
+    // 1️⃣ Identifier le destinataire
+    final recipientUserId = widget.chatView.partnerUserId!;
+
+    // 2️⃣ Récupérer les devices actifs du destinataire
+    final devices = await keyProvider.getUserDevicesKeys(recipientUserId);
+    if (devices.isEmpty) {
+      debugPrint('No devices for recipient');
+      return;
+    }
+
+    // 5️⃣ Envoi du message
+    await messageService.sendMessage(
+      chatId: widget.chatId,
+      plaintext: text,
+      recipientUserId: recipientUserId,
+      recipientDeviceIds: devices.map((d) => d.deviceId).toList(),
+    );
+
+    // 6️⃣ Reset input et refresh UI
+    _controller.clear();
+    await _loadMessages();
+
+  } catch (e) {
+    debugPrint("❌ Error sending message: $e");
+  }
+}
+
+  @override
+  Widget build(BuildContext context) {
+    final isDesktop = MediaQuery.of(context).size.width > 800;
+
+    final chatBody = Column(
+      children: [
+        if (!widget.embedded)
+          AppBar(
+            backgroundColor: const Color(0xFF1C1C1C),
+            title: Text(widget.displayName),
+            actions: [
+              IconButton(
+                icon: const Icon(Icons.refresh, color: Colors.greenAccent),
+                onPressed: _loadMessages,
+              ),
+            ],
+          ),
+        Expanded(
+          child: _loading
+              ? const Center(
+                  child:
+                      CircularProgressIndicator(color: Colors.greenAccent))
+              : _messages.isEmpty
+                  ? const Center(
+                      child: Text("No messages yet 💬",
+                          style: TextStyle(color: Colors.grey)),
+                    )
+                  : ListView.builder(
+                      reverse: false,
+                      padding: const EdgeInsets.all(12),
+                      itemCount: _messages.length,
+                      itemBuilder: (context, index) {
+                        final msg = _messages[index];
+                        final isMe = msg.fromUserId == _currentUserId;
+                        return Align(
+                          alignment: isMe
+                              ? Alignment.centerRight
+                              : Alignment.centerLeft,
+                          child: Container(
+                            margin: const EdgeInsets.symmetric(vertical: 4),
+                            padding: const EdgeInsets.symmetric(
+                                horizontal: 14, vertical: 10),
+                            decoration: BoxDecoration(
+                              color: isMe
+                                  ? Colors.greenAccent
+                                  : const Color(0xFF2A2A2A),
+                              borderRadius: BorderRadius.circular(16),
+                            ),
+                            child: Text(
+                              msg.ciphertext,
+                              style: TextStyle(
+                                color: isMe ? Colors.black : Colors.white,
+                              ),
+                            ),
+                          ),
+                        );
+                      },
+                    ),
+        ),
+        Container(
+          padding:
+              const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
+          decoration: const BoxDecoration(
+            color: Color(0xFF1C1C1C),
+            border: Border(
+                top: BorderSide(color: Color(0xFF2F2F2F), width: 0.5)),
+          ),
+          child: Row(
+            children: [
+              Expanded(
+                child: TextField(
+                  controller: _controller,
+                  style: const TextStyle(color: Colors.white),
+                  decoration: InputDecoration(
+                    hintText: "Type a message...",
+                    hintStyle: TextStyle(color: Colors.grey[500]),
+                    border: InputBorder.none,
+                  ),
+                ),
+              ),
+              IconButton(
+                icon: const Icon(Icons.send, color: Colors.greenAccent),
+                onPressed: _sendMessage,
+              ),
+            ],
+          ),
+        ),
+      ],
+    );
+
+    if (widget.embedded) {
+      return Container(
+        color: const Color(0xFF101010),
+        child: chatBody,
+      );
+    }
+
+    return Scaffold(
+      backgroundColor: const Color(0xFF101010),
+      body: SafeArea(child: chatBody),
+    );
+  }
+}