zep/src/chat/services/hooks/useActions.ts

import { useState, useMemo, useCallback } from "react";
import { useReducer } from "spacetimedb/react";
import { reducers } from "../../../module_bindings";
import * as Types from "../../../module_bindings/types";

export const useActions = (
  activeServerId: bigint | null,
  activeChannelId: bigint | null,
  activeThreadId: bigint | null,
) => {
  // Modal states
  const [showCreateServerModal, setShowCreateServerModal] = useState(false);
  const [newServerName, setNewServerName] = useState("");
  const [showCreateChannelModal, setShowCreateChannelModal] = useState(false);
  const [newChannelName, setNewChannelName] = useState("");
  const [isVoiceChannel, setIsVoiceChannel] = useState(false);
  const [showSetNameModal, setShowSetNameModal] = useState(false);
  const [newName, setNewName] = useState("");
  const [messageText, setMessageText] = useState("");
  const [threadMessageText, setThreadMessageText] = useState("");

  // Reducers
  const createServerReducer = useReducer(
    useMemo(() => reducers.createServer, []),
  );
  const createChannelReducer = useReducer(
    useMemo(() => reducers.createChannel, []),
  );
  const createThreadReducer = useReducer(
    useMemo(() => reducers.createThread, []),
  );
  const sendMessageReducer = useReducer(
    useMemo(() => reducers.sendMessage, []),
  );
  const joinVoiceReducer = useReducer(useMemo(() => reducers.joinVoice, []));
  const leaveVoiceReducer = useReducer(useMemo(() => reducers.leaveVoice, []));
  const setNameReducer = useReducer(useMemo(() => reducers.setName, []));
  const joinServerReducer = useReducer(useMemo(() => reducers.joinServer, []));
  const leaveServerReducer = useReducer(
    useMemo(() => reducers.leaveServer, []),
  );

  // Handlers
  const handleCreateServer = useCallback(
    (e: React.FormEvent) => {
      e.preventDefault();
      if (newServerName.trim()) {
        createServerReducer({ name: newServerName });
        setNewServerName("");
        setShowCreateServerModal(false);
      }
    },
    [newServerName, createServerReducer],
  );

  const handleCreateChannel = useCallback(
    (e: React.FormEvent) => {
      e.preventDefault();
      if (newChannelName.trim() && activeServerId) {
        createChannelReducer({
          serverId: activeServerId,
          name: newChannelName,
          isVoice: isVoiceChannel,
        });
        setNewChannelName("");
        setShowCreateChannelModal(false);
      }
    },
    [newChannelName, activeServerId, isVoiceChannel, createChannelReducer],
  );

  const handleStartThread = useCallback(
    (msg: Types.Message) => {
      const threadName = `Thread for ${msg.text.substring(0, 20)}...`;
      createThreadReducer({
        name: threadName,
        channelId: msg.channelId,
        parentMessageId: msg.id,
      });
    },
    [createThreadReducer],
  );

  const handleSendMessage = useCallback(
    (e: React.FormEvent) => {
      e.preventDefault();
      if (messageText.trim() && activeChannelId) {
        sendMessageReducer({
          channelId: activeChannelId,
          text: messageText,
          threadId: activeThreadId || undefined,
        });
        setMessageText("");
      }
    },
    [messageText, activeChannelId, activeThreadId, sendMessageReducer],
  );

  const handleSendThreadMessage = useCallback(
    (e: React.FormEvent) => {
      e.preventDefault();
      if (threadMessageText.trim() && activeChannelId && activeThreadId) {
        sendMessageReducer({
          channelId: activeChannelId,
          text: threadMessageText,
          threadId: activeThreadId,
        });
        setThreadMessageText("");
      }
    },
    [threadMessageText, activeChannelId, activeThreadId, sendMessageReducer],
  );

  const handleJoinVoice = useCallback(
    (channelId: bigint) => {
      joinVoiceReducer({ channelId });
    },
    [joinVoiceReducer],
  );

  const handleLeaveVoice = useCallback(() => {
    leaveVoiceReducer();
  }, [leaveVoiceReducer]);

  const handleSetName = useCallback(
    (e: React.FormEvent) => {
      e.preventDefault();
      if (newName.trim()) {
        setNameReducer({ name: newName });
        setNewName("");
        setShowSetNameModal(false);
      }
    },
    [newName, setNameReducer],
  );

  const handleJoinServer = useCallback(
    (serverId: bigint) => {
      joinServerReducer({ serverId });
    },
    [joinServerReducer],
  );

  const handleLeaveServer = useCallback(
    (serverId: bigint) => {
      leaveServerReducer({ serverId });
    },
    [leaveServerReducer],
  );

  return {
    // Modal states & setters
    showCreateServerModal,
    setShowCreateServerModal,
    newServerName,
    setNewServerName,
    showCreateChannelModal,
    setShowCreateChannelModal,
    newChannelName,
    setNewChannelName,
    isVoiceChannel,
    setIsVoiceChannel,
    showSetNameModal,
    setShowSetNameModal,
    newName,
    setNewName,
    messageText,
    setMessageText,
    threadMessageText,
    setThreadMessageText,

    // Handlers
    handleCreateServer,
    handleCreateChannel,
    handleStartThread,
    handleSendMessage,
    handleSendThreadMessage,
    handleJoinVoice,
    handleLeaveVoice,
    handleSetName,
    handleJoinServer,
    handleLeaveServer,

    // Raw Reducers (if needed)
    createServerReducer,
    createChannelReducer,
    createThreadReducer,
    sendMessageReducer,
    joinVoiceReducer,
    leaveVoiceReducer,
    setNameReducer,
    joinServerReducer,
    leaveServerReducer,
  };
};