Real-time Updates

message ServerMessage {
  uint32 id = 1;
  oneof message {
    tangle.client.updates.Update update = 2;  // Real-time update
    RPCResult result = 3;                      // RPC response
  }
}

message Update {
  oneof update {
    UpdateMessageCreated          message_created                  = 1;
    UpdateChannel                 channel                          = 2;
    UpdateMessageDeleted          message_deleted                  = 3;
    UpdateUserStatus              user_status                      = 4;
    UpdateUser                    user                             = 5;
    UpdateCommunity               community                        = 6;
    UpdateChannelDeleted          channel_deleted                  = 7;
    UpdateMessage                 message                          = 8;
    UpdateChatTyping              chat_typing                      = 9;
    UpdateCommunityMember         community_member                 = 10;
    UpdateCommunityDeleted        community_deleted                = 11;
    UpdateConversationPermissions conversation_permissions         = 12;
    UpdateChat                    chat                             = 13;
    UpdateSessionDeleted          session_deleted                  = 14;
    UpdateCommunityUnavailable    community_unavailable            = 15;
    UpdateMemberList              member_list                      = 16;
    UpdateCommunityMemberDeleted  community_member_deleted         = 17;
    UpdateUserRelationship        update_user_relationship         = 18;
    UpdateUserRelationshipDeleted update_user_relationship_deleted = 19;
    UpdateGroup                   group                            = 20;
    voice.UpdateRoomState         room_state                       = 21;
    voice.UpdateRoomParticipant   room_participant                 = 22;
    UpdateMessageReactions        message_reactions                = 23;
    UpdateConversationLastRead    conversation_last_read           = 24;
    UpdateCommunityMemberCreated  community_member_created         = 25;
  }
}

message Initialize {
  uint32 client_id = 1;
  string device_type = 2;
  string device_version = 3;
  string app_version = 4;
  bool no_subscribe = 5;  // Set to true to disable automatic updates
}

class UpdateHandler {
  handleServerMessage(serverMessage) {
    if (serverMessage.update) {
      this.handleUpdate(serverMessage.update);
    } else if (serverMessage.result) {
      this.handleRPCResult(serverMessage.result);
    }
  }
  
  handleUpdate(update) {
    // Check which update type it is
    if (update.message_created) {
      this.onNewMessage(update.message_created);
    } else if (update.message_deleted) {
      this.onMessageDeleted(update.message_deleted);
    } else if (update.user_status) {
      this.onUserStatusChange(update.user_status);
    } else if (update.chat_typing) {
      this.onTypingIndicator(update.chat_typing);
    }
    // ... handle other update types
  }
  
  onNewMessage(messageCreated) {
    const { message, channel_unread_count, author } = messageCreated;
    
    // Add to message list
    this.addMessageToChat(message);
    
    // Update unread count
    this.updateUnreadCount(message.chat_ref, channel_unread_count);
    
    // Show notification if not current channel
    if (!this.isCurrentChannel(message.chat_ref)) {
      this.showNotification(message, author);
    }
  }
  
  onMessageDeleted(messageDeleted) {
    const { chat_ref, message_ids } = messageDeleted;
    
    // Remove from UI
    for (const messageId of message_ids) {
      this.removeMessageFromChat(chat_ref, messageId);
    }
  }
  
  onUserStatusChange(userStatus) {
    const { user_id, status } = userStatus;
    
    // Update user status in UI
    this.updateUserPresence(user_id, status);
  }
  
  onTypingIndicator(chatTyping) {
    const { chat_ref, user_id, typing } = chatTyping;
    
    if (typing) {
      this.addTypingUser(chat_ref, user_id);
      
      // Clear after timeout
      setTimeout(() => {
        this.removeTypingUser(chat_ref, user_id);
      }, 5000);
    } else {
      this.removeTypingUser(chat_ref, user_id);
    }
  }
}

import { EventEmitter } from 'events';

class OsmiumClient extends EventEmitter {
  handleUpdate(update: Update) {
    if (update.message_created) {
      this.emit('message', update.message_created.message);
    } else if (update.message_deleted) {
      this.emit('messageDelete', update.message_deleted);
    } else if (update.user_status) {
      this.emit('userStatus', update.user_status);
    }
    // ... etc
  }
}

// In React component
function ChatView() {
  const [messages, setMessages] = useState([]);
  
  useEffect(() => {
    const handleNewMessage = (message) => {
      setMessages(prev => [...prev, message]);
    };
    
    const handleMessageDelete = ({ message_ids }) => {
      setMessages(prev => 
        prev.filter(m => !message_ids.includes(m.message_id))
      );
    };
    
    client.on('message', handleNewMessage);
    client.on('messageDelete', handleMessageDelete);
    
    return () => {
      client.off('message', handleNewMessage);
      client.off('messageDelete', handleMessageDelete);
    };
  }, []);
  
  return (
    <div>
      {messages.map(msg => <MessageComponent key={msg.message_id} message={msg} />)}
    </div>
  );
}

// Redux action creators
const handleUpdate = (update: Update) => (dispatch) => {
  if (update.message_created) {
    dispatch({
      type: 'MESSAGE_CREATED',
      payload: update.message_created
    });
  } else if (update.message_deleted) {
    dispatch({
      type: 'MESSAGE_DELETED',
      payload: update.message_deleted
    });
  } else if (update.user_status) {
    dispatch({
      type: 'USER_STATUS_CHANGED',
      payload: update.user_status
    });
  }
  // ... etc
};

// Reducer
const messagesReducer = (state = {}, action) => {
  switch (action.type) {
    case 'MESSAGE_CREATED':
      const { message } = action.payload;
      return {
        ...state,
        [message.message_id]: message
      };
      
    case 'MESSAGE_DELETED':
      const newState = { ...state };
      for (const messageId of action.payload.message_ids) {
        delete newState[messageId];
      }
      return newState;
      
    default:
      return state;
  }
};

class TypingManager {
  constructor(client) {
    this.client = client;
    this.typingTimers = new Map();
  }
  
  startTyping(chatRef) {
    const key = this.getChatKey(chatRef);
    
    // Send typing indicator
    if (!this.typingTimers.has(key)) {
      this.client.sendRequest({
        chats_set_typing: {
          chat_ref: chatRef,
          typing: true
        }
      });
    }
    
    // Clear existing timer
    clearTimeout(this.typingTimers.get(key));
    
    // Auto-stop after 5 seconds
    this.typingTimers.set(key, setTimeout(() => {
      this.stopTyping(chatRef);
    }, 5000));
  }
  
  stopTyping(chatRef) {
    const key = this.getChatKey(chatRef);
    clearTimeout(this.typingTimers.get(key));
    this.typingTimers.delete(key);
    
    this.client.sendRequest({
      chats_set_typing: {
        chat_ref: chatRef,
        typing: false
      }
    });
  }
}

class MessageSender {
  async sendMessage(chatRef, text) {
    // Generate temporary ID
    const tempId = `temp-${Date.now()}-${Math.random()}`;
    
    // Optimistically add to UI
    const optimisticMessage = {
      message_id: 0n, // Placeholder
      temp_id: tempId,
      message: text,
      author_id: this.currentUserId,
      chat_ref: chatRef,
      pending: true
    };
    
    this.addMessageToUI(optimisticMessage);
    
    try {
      // Send actual request
      const result = await this.client.sendRequest({
        messages_send_message: {
          chat_ref: chatRef,
          message: text,
          temp_id: tempId
        }
      });
      
      // Replace optimistic message with real one
      this.replaceMessage(tempId, result.sent_message.message);
      
    } catch (error) {
      // Mark message as failed
      this.markMessageFailed(tempId, error);
    }
  }
}