{
  "serviceSettings": {
    "realtimeConfig": {
      "adapter": "redis",
      "heartbeatInterval": 25000,
      "heartbeatTimeout": 20000,
      "maxConnectionsPerUser": 10
    }
  }
}

{
  "hubBasics": {
    "name": "chatHub",
    "description": "Real-time messaging hub for one-on-one and group conversations"
  }
}

{
  "roomSettings": {
    "roomDataObject": "catalogEvent",
    "roomEligibility": "catalogEvent.chatEnabled == true",
    "absoluteRoles": ["superAdmin"],
    "checkRoles": ["premiumUser", "subscriber"],
    "checkScript": "user.city == catalogEvent.city",
    "authSources": [
      { "name": "eventOwner", "sourceObject": "catalogEvent", "userField": "createdBy", "roomField": "id", "hubRole": "owner" },
      { "name": "eventHost", "sourceObject": "eventHost", "userField": "userId", "roomField": "eventId", "hubRole": "moderator" },
      { "name": "ticketHolder", "sourceObject": "issuedTicket", "userField": "ownerUserId", "roomField": "eventId", "condition": "issuedTicket.status == 'active'", "hubRole": "attendee" }
    ],
    "authScripts": [
      { "name": "vipAccess", "script": "lib.checkVIPAccess(user, room)", "hubRole": "viewer" }
    ]
  }
}

 1. Fetch room record from Elasticsearch
 2. Room not found → DENY
 3. roomEligibility → eval({ roomDataObject, room }) → false → DENY (blocks everyone)
 4. Check if user is BLOCKED (Redis/ES) → DENY
 5. absoluteRoles → user.roleId in list → ALLOW with "system" role
 6. checkRoles → not in list → DENY
 7. checkScript → false → DENY
 8. authSources top-to-bottom → first match → ALLOW with hubRole (or default "member") → BREAK
 9. authScripts top-to-bottom → first match → ALLOW with hubRole (or default "member") → BREAK
10. No match → DENY

{
  "hubRoles": [
    { "name": "owner", "canRead": true, "canSend": true, "canModerate": true, "canDeleteAny": true, "canManageRoom": true },
    { "name": "moderator", "canRead": true, "canSend": true, "canModerate": true, "canDeleteAny": true },
    { "name": "attendee", "canRead": true, "canSend": true, "allowedMessageTypes": "text,image", "moderated": true },
    { "name": "viewer", "canRead": true, "canSend": false }
  ]
}

{
  "messageSettings": {
    "dataObjectName": "ChatHubMessage",
    "messageTypes": ["text", "image", "video", "audio", "document", "location"],
    "enableReplyTo": true,
    "enableReaction": true,
    "enableForwarded": true
  }
}

{
  "messageSettings": {
    "dataObjectName": "GameChatMessage",
    "messageTypes": ["text", "sticker"],
    "customMessageTypes": [
      {
        "name": "chessMove",
        "description": "A chess piece move with board coordinates",
        "fields": [
          { "name": "from", "fieldType": "String", "required": true, "description": "Source square (e.g. e2)" },
          { "name": "to", "fieldType": "String", "required": true, "description": "Target square (e.g. e4)" },
          { "name": "piece", "fieldType": "Enum", "required": true, "enumValues": "pawn,rook,knight,bishop,queen,king" },
          { "name": "captured", "fieldType": "Enum", "required": false, "enumValues": "pawn,rook,knight,bishop,queen" },
          { "name": "isCheck", "fieldType": "Boolean", "required": false, "defaultValue": "false" },
          { "name": "notation", "fieldType": "String", "required": false, "description": "Standard algebraic notation" }
        ]
      },
      {
        "name": "nudge",
        "description": "A visual buzz/shake signal",
        "fields": [
          { "name": "animation", "fieldType": "Enum", "required": false, "enumValues": "shake,bounce,flash", "defaultValue": "shake" }
        ]
      }
    ]
  }
}

{
  "eventSettings": {
    "enableTypingIndicator": true,
    "enableRecordingIndicator": true,
    "enableReadReceipts": true,
    "enableDeliveryReceipts": true,
    "enablePresence": true,
    "autoBridgeDataEvents": true
  }
}

{
  "eventSettings": {
    "customEvents": [
      {
        "name": "cursorMoved",
        "description": "User's cursor position in a collaborative editor",
        "ephemeral": true,
        "direction": "clientToRoom"
      }
    ]
  }
}

{
  "eventSettings": {
    "kafkaEvents": [
      {
        "name": "orderStatusChanged",
        "description": "Order status update from the commerce service",
        "topic": "order-events",
        "filterExpression": "data.type === 'status.changed'",
        "targetRoomExpression": "data.dashboardId"
      }
    ]
  }
}

{
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 50
  }
}

{
  "guardrails": {
    "maxUsersPerRoom": 1000,
    "maxRoomsPerUser": 50,
    "messageRateLimit": 60,
    "maxMessageSize": 65536,
    "connectionTimeout": 300000,
    "authCacheTTL": 300,
    "globalModeration": false,
    "defaultSilenced": false
  }
}

interface HubLogic = {
  stateScript : MScript;
  messageHandlers : HubMessageHandler[];
  scheduledActions : HubScheduledAction[];
}

interface HubMessageHandler = {
  messageType : String;
  script : MScript;
}

interface HubScheduledAction = {
  name : String;
  intervalMs : Integer;
  keepAlive : Boolean;
  script : MScript;
}

{
  accept: true,                    // false to reject
  rejectReason: "Not your turn",   // sent to sender if rejected

  broadcast: true,                 // false to suppress the original message
  broadcastTo: "all",              // "all" | "others" | "sender" | ["userId-1", "userId-2"]
  modifiedContent: { ... },        // replace content before broadcast
  persist: true,                   // false to skip persistence

  serverMessages: [                // server-generated messages
    {
      type: "gameEvent",
      content: { event: "check" },
      to: "all",                   // "all" | "others" | "sender" | ["userId-1"]
      persist: true                // false to skip persistence
    }
  ]
}

// Client receives:
socket.on("hub:state", ({ roomId, state }) => {
  renderChessBoard(state.board);
  setTurnIndicator(state.turn);
});

// Client can request state anytime (e.g., after reconnect):
socket.emit("hub:requestState", { roomId });

{
  "hubLogic": {
    "stateScript": "lib.chess.getState(roomId)",
    "messageHandlers": [
      {
        "messageType": "chessMove",
        "script": "lib.chess.processMove(roomId, session, message)"
      }
    ],
    "scheduledActions": []
  }
}

async function processMove(roomId, session, message) {
  const state = JSON.parse(await redis.get(`chess:${roomId}`));

  if (state.turn !== session.userId) {
    return { accept: false, rejectReason: "Not your turn" };
  }

  const result = validateAndApply(state.board, message.content);
  if (!result.valid) {
    return { accept: false, rejectReason: result.reason };
  }

  await redis.set(`chess:${roomId}`, JSON.stringify(result.newState));

  const serverMessages = [];
  if (result.isCheckmate) {
    serverMessages.push({
      type: "gameEvent",
      content: { event: "checkmate", winner: session.userId },
      to: "all"
    });
  } else if (result.isCheck) {
    serverMessages.push({
      type: "gameEvent",
      content: { event: "check" },
      to: "all"
    });
  }

  return { accept: true, broadcast: true, broadcastTo: "all", serverMessages };
}

{
  "hubLogic": {
    "stateScript": "lib.world.getVisibleState(roomId, session)",
    "messageHandlers": [
      { "messageType": "playerMove", "script": "lib.world.processMove(roomId, session, message)" },
      { "messageType": "playerAttack", "script": "lib.world.processAttack(roomId, session, message)" }
    ],
    "scheduledActions": [
      {
        "name": "worldTick",
        "intervalMs": 1000,
        "keepAlive": true,
        "script": "lib.world.tick(roomId)"
      }
    ]
  }
}

import { io } from "socket.io-client";

const socket = io("https://your-service.example.com/hub/chatHub", {
  path: "/your-service-api/socket.io/",   // HTTP path for reverse proxy routing
  auth: { token: "Bearer <jwt-token>" },
  transports: ["websocket", "polling"]
});

socket.on("connect", () => console.log("Connected to chatHub"));
socket.on("connect_error", (err) => console.error("Auth failed:", err.message));

const socket = io("https://your-service.example.com/hub/chatHub", {
  path: "/your-service-api/socket.io/",
  auth: {
    token: "Bearer <jwt-token>",
    tenantCodename: "my-tenant"       // required for multi-tenant projects
  },
  transports: ["websocket", "polling"]
});

socket.emit("hub:join", { roomId: "chat-uuid-123", meta: { displayName: "Alice" } });

socket.on("hub:joined", ({ roomId }) => console.log("Joined room", roomId));
socket.on("hub:history", ({ roomId, messages }) => console.log(`${messages.length} messages loaded`));
socket.on("hub:error", ({ error }) => console.error(error));

// Text message
socket.emit("hub:send", {
  roomId: "chat-uuid-123",
  messageType: "text",
  content: { body: "Hello everyone!" }
});

// Image message
socket.emit("hub:send", {
  roomId: "chat-uuid-123",
  messageType: "image",
  content: { mediaUrl: "https://cdn.example.com/photo.jpg", caption: "Check this out" }
});

// Custom message type (chess move)
socket.emit("hub:send", {
  roomId: "match-uuid",
  messageType: "chessMove",
  content: { from: "e2", to: "e4", piece: "pawn", notation: "e4" }
});

// With reply
socket.emit("hub:send", {
  roomId: "chat-uuid-123",
  messageType: "text",
  content: { body: "I agree!" },
  replyTo: { id: "msg-uuid-456", preview: "Should we meet at 5?" }
});

socket.on("hub:messageArrived", ({ roomId, sender, message }) => {
  console.log(`[${message.messageType}] from ${sender.id}:`, message.content);
});

// Emit typing
socket.emit("hub:event", { roomId: "chat-uuid-123", event: "typing", data: {} });
socket.emit("hub:event", { roomId: "chat-uuid-123", event: "stopTyping", data: {} });

// Receive typing
socket.on("hub:typing", ({ roomId, userId }) => console.log(userId, "is typing..."));
socket.on("hub:stopTyping", ({ roomId, userId }) => console.log(userId, "stopped typing"));

// Read receipts
socket.emit("hub:event", {
  roomId: "chat-uuid-123",
  event: "messageRead",
  data: { lastReadTimestamp: "2025-01-15T10:30:00Z" }
});

socket.on("hub:messageRead", ({ roomId, userId, lastReadTimestamp }) => {
  console.log(userId, "read up to", lastReadTimestamp);
});

// Presence
socket.on("hub:online", ({ roomId, userId }) => console.log(userId, "is online"));
socket.on("hub:offline", ({ roomId, userId }) => console.log(userId, "went offline"));

// These fire automatically when DataObject CRUD operations happen via REST/API
socket.on("hub:memberJoined", ({ roomId, ...data }) => console.log("New member:", data));
socket.on("hub:memberLeft", ({ roomId, ...data }) => console.log("Member left:", data));
socket.on("hub:messageEdited", ({ roomId, ...data }) => console.log("Message edited:", data));
socket.on("hub:messageDeleted", ({ roomId, messageId }) => console.log("Deleted:", messageId));
socket.on("hub:roomUpdated", ({ roomId, ...data }) => console.log("Room updated:", data));

{
  "hubBasics": {
    "name": "messenger",
    "description": "WhatsApp-style messaging hub with 1-on-1 and group conversations"
  },
  "roomSettings": {
    "roomDataObject": "conversation",
    "authSources": [
      { "name": "conversationAdmin", "sourceObject": "conversationMember", "userField": "userId", "roomField": "conversationId", "condition": "conversationMember.role == 'admin'", "hubRole": "admin" },
      { "name": "conversationMember", "sourceObject": "conversationMember", "userField": "userId", "roomField": "conversationId", "hubRole": "member" }
    ]
  },
  "hubRoles": [
    { "name": "admin", "canRead": true, "canSend": true, "canModerate": true, "canDeleteAny": true, "canManageRoom": true },
    { "name": "member", "canRead": true, "canSend": true }
  ],
  "messageSettings": {
    "dataObjectName": "ChatMessage",
    "messageTypes": ["text", "image", "video", "audio", "document", "sticker", "contact", "location", "system"],
    "enableReplyTo": true,
    "enableReaction": true,
    "enableForwarded": true
  },
  "eventSettings": {
    "enableTypingIndicator": true,
    "enableRecordingIndicator": true,
    "enableReadReceipts": true,
    "enableDeliveryReceipts": true,
    "enablePresence": true,
    "autoBridgeDataEvents": true
  },
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 50
  },
  "guardrails": {
    "maxUsersPerRoom": 1024,
    "maxRoomsPerUser": 500,
    "messageRateLimit": 30,
    "maxMessageSize": 65536,
    "connectionTimeout": 600000
  }
}

{
  "hubBasics": {
    "name": "chessLobby",
    "description": "Real-time chess game hub with move broadcasting and chat"
  },
  "roomSettings": {
    "roomDataObject": "chessMatch",
    "authSources": [
      { "name": "matchPlayer", "sourceObject": "matchPlayer", "userField": "playerId", "roomField": "matchId", "hubRole": "player" }
    ]
  },
  "hubRoles": [
    { "name": "player", "canRead": true, "canSend": true }
  ],
  "messageSettings": {
    "dataObjectName": "ChessMessage",
    "messageTypes": ["text", "sticker", "system"],
    "enableReplyTo": false,
    "enableReaction": true,
    "enableForwarded": false,
    "customMessageTypes": [
      {
        "name": "chessMove",
        "description": "A chess piece move with board coordinates",
        "fields": [
          { "name": "from", "fieldType": "String", "required": true, "description": "Source square" },
          { "name": "to", "fieldType": "String", "required": true, "description": "Target square" },
          { "name": "piece", "fieldType": "Enum", "required": true, "enumValues": "pawn,rook,knight,bishop,queen,king" },
          { "name": "captured", "fieldType": "Enum", "required": false, "enumValues": "pawn,rook,knight,bishop,queen" },
          { "name": "isCheck", "fieldType": "Boolean", "required": false, "defaultValue": "false" },
          { "name": "isCheckmate", "fieldType": "Boolean", "required": false, "defaultValue": "false" },
          { "name": "notation", "fieldType": "String", "required": false }
        ]
      },
      {
        "name": "nudge",
        "description": "A visual nudge to get attention",
        "fields": [
          { "name": "animation", "fieldType": "Enum", "required": false, "enumValues": "shake,bounce,flash", "defaultValue": "shake" }
        ]
      },
      {
        "name": "drawOffer",
        "description": "Player offers or responds to a draw",
        "fields": [
          { "name": "action", "fieldType": "Enum", "required": true, "enumValues": "offer,accept,decline" }
        ]
      }
    ]
  },
  "eventSettings": {
    "enableTypingIndicator": true,
    "enableRecordingIndicator": false,
    "enableReadReceipts": false,
    "enableDeliveryReceipts": false,
    "enablePresence": true,
    "autoBridgeDataEvents": true,
    "customEvents": [
      {
        "name": "clockUpdate",
        "description": "Timer sync from server",
        "ephemeral": true,
        "direction": "serverToRoom"
      }
    ]
  },
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 200
  },
  "guardrails": {
    "maxUsersPerRoom": 10,
    "maxRoomsPerUser": 5,
    "messageRateLimit": 120,
    "maxMessageSize": 4096,
    "connectionTimeout": 1800000
  }
}

{
  "hubBasics": {
    "name": "liveDashboard",
    "description": "Real-time dashboard streaming backend metrics and events"
  },
  "roomSettings": {
    "roomDataObject": "dashboard",
    "authSources": [
      { "name": "dashboardOwner", "sourceObject": "dashboard", "userField": "createdBy", "roomField": "id", "hubRole": "dashboardOwner" }
    ]
  },
  "hubRoles": [
    { "name": "dashboardOwner", "canRead": true, "canSend": false, "canManageRoom": true }
  ],
  "messageSettings": {
    "dataObjectName": "DashboardEvent",
    "messageTypes": ["system"],
    "enableReplyTo": false,
    "enableReaction": false,
    "enableForwarded": false
  },
  "eventSettings": {
    "enableTypingIndicator": false,
    "enableRecordingIndicator": false,
    "enableReadReceipts": false,
    "enableDeliveryReceipts": false,
    "enablePresence": false,
    "autoBridgeDataEvents": true,
    "kafkaEvents": [
      {
        "name": "metricUpdate",
        "description": "New metric data point",
        "topic": "analytics-events",
        "filterExpression": "data.type === 'metric'",
        "targetRoomExpression": "data.dashboardId"
      },
      {
        "name": "alertTriggered",
        "description": "Threshold alert",
        "topic": "analytics-events",
        "filterExpression": "data.type === 'alert'",
        "targetRoomExpression": "data.dashboardId"
      }
    ]
  },
  "historySettings": {
    "historyEnabled": false
  },
  "guardrails": {
    "maxUsersPerRoom": 200,
    "maxRoomsPerUser": 10,
    "messageRateLimit": 10,
    "maxMessageSize": 8192,
    "connectionTimeout": 900000
  }
}

{
  "hubBasics": {
    "name": "supportChat",
    "description": "Customer support live chat tied to support tickets"
  },
  "roomSettings": {
    "roomDataObject": "supportTicket",
    "absoluteRoles": ["supportAgent", "supportLead"],
    "authSources": [
      { "name": "ticketCreator", "sourceObject": "supportTicket", "userField": "createdBy", "roomField": "id", "hubRole": "customer" }
    ]
  },
  "hubRoles": [
    { "name": "customer", "canRead": true, "canSend": true }
  ],
  "messageSettings": {
    "dataObjectName": "SupportMessage",
    "messageTypes": ["text", "image", "document", "system"],
    "enableReplyTo": false,
    "enableReaction": false,
    "enableForwarded": false,
    "customMessageTypes": [
      {
        "name": "internalNote",
        "description": "Internal note visible only to support agents",
        "fields": [
          { "name": "note", "fieldType": "Text", "required": true },
          { "name": "isResolution", "fieldType": "Boolean", "required": false, "defaultValue": "false" }
        ]
      }
    ]
  },
  "eventSettings": {
    "enableTypingIndicator": true,
    "enableRecordingIndicator": false,
    "enableReadReceipts": true,
    "enableDeliveryReceipts": false,
    "enablePresence": true,
    "autoBridgeDataEvents": true
  },
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 100
  },
  "guardrails": {
    "maxUsersPerRoom": 10,
    "maxRoomsPerUser": 20,
    "messageRateLimit": 30,
    "maxMessageSize": 65536,
    "connectionTimeout": 600000
  }
}

{
  "hubBasics": {
    "name": "auctionRoom",
    "description": "Live auction bidding with real-time bid updates and timer"
  },
  "roomSettings": {
    "roomDataObject": "auctionListing",
    "roomEligibility": "auctionListing.status == 'active'",
    "checkRoles": ["verifiedBidder"],
    "authScripts": [
      { "name": "allVerifiedBidders", "script": "true", "hubRole": "bidder" }
    ]
  },
  "hubRoles": [
    { "name": "bidder", "canRead": true, "canSend": true, "allowedMessageTypes": "text,bid" }
  ],
  "messageSettings": {
    "dataObjectName": "AuctionActivity",
    "messageTypes": ["text", "system"],
    "enableReplyTo": false,
    "enableReaction": false,
    "enableForwarded": false,
    "customMessageTypes": [
      {
        "name": "bid",
        "description": "A bid placed on the auction listing",
        "fields": [
          { "name": "amount", "fieldType": "Decimal", "required": true, "description": "Bid amount" },
          { "name": "currency", "fieldType": "String", "required": true, "defaultValue": "USD" },
          { "name": "isAutoBid", "fieldType": "Boolean", "required": false, "defaultValue": "false" }
        ]
      }
    ]
  },
  "eventSettings": {
    "enableTypingIndicator": false,
    "enableRecordingIndicator": false,
    "enableReadReceipts": false,
    "enableDeliveryReceipts": false,
    "enablePresence": true,
    "autoBridgeDataEvents": true,
    "kafkaEvents": [
      {
        "name": "auctionEnding",
        "topic": "auction-events",
        "filterExpression": "data.type === 'auction.ending'",
        "targetRoomExpression": "data.listingId"
      },
      {
        "name": "auctionClosed",
        "topic": "auction-events",
        "filterExpression": "data.type === 'auction.closed'",
        "targetRoomExpression": "data.listingId"
      }
    ]
  },
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 200
  },
  "guardrails": {
    "maxUsersPerRoom": 10000,
    "maxRoomsPerUser": 30,
    "messageRateLimit": 10,
    "maxMessageSize": 2048,
    "connectionTimeout": 1800000
  }
}

{
  "hubBasics": {
    "name": "chessGame",
    "description": "Online chess game with real-time moves, chat, and spectator mode"
  },
  "roomSettings": {
    "roomDataObject": "ChessGame",
    "roomEligibility": "chessGame.status !== 'completed'",
    "absoluteRoles": ["superAdmin"],
    "authSources": [
      {
        "name": "player",
        "sourceObject": "ChessGameMembership",
        "userField": "userId",
        "roomField": "chessGameId",
        "hubRole": "player"
      }
    ],
    "authScripts": [
      {
        "name": "spectatorAccess",
        "script": "room.allowSpectators === true",
        "hubRole": "spectator"
      }
    ]
  },
  "hubRoles": [
    {
      "name": "player",
      "canRead": true,
      "canSend": true,
      "canModerate": false,
      "allowedMessageTypes": "text,sticker,chessMove,drawOffer,resign"
    },
    {
      "name": "spectator",
      "canRead": true,
      "canSend": true,
      "canModerate": false,
      "allowedMessageTypes": "text,sticker"
    }
  ],
  "messageSettings": {
    "dataObjectName": "ChessGameMessage",
    "messageTypes": ["text", "sticker", "system"],
    "enableReplyTo": false,
    "enableReaction": true,
    "enableForwarded": false,
    "customMessageTypes": [
      {
        "name": "chessMove",
        "description": "A chess move on the board",
        "fields": [
          { "name": "from", "fieldType": "String", "required": true },
          { "name": "to", "fieldType": "String", "required": true },
          { "name": "promotion", "fieldType": "String", "required": false }
        ]
      },
      {
        "name": "drawOffer",
        "description": "Offer or respond to a draw",
        "fields": [
          { "name": "action", "fieldType": "String", "required": true }
        ]
      },
      {
        "name": "resign",
        "description": "Player resigns the game",
        "fields": []
      },
      {
        "name": "gameEvent",
        "description": "Server-generated game events (check, checkmate, draw, time)",
        "fields": [
          { "name": "event", "fieldType": "String", "required": true },
          { "name": "winner", "fieldType": "String", "required": false },
          { "name": "reason", "fieldType": "String", "required": false }
        ]
      }
    ]
  },
  "eventSettings": {
    "enableTypingIndicator": true,
    "enableRecordingIndicator": false,
    "enableReadReceipts": false,
    "enableDeliveryReceipts": false,
    "enablePresence": true,
    "autoBridgeDataEvents": true
  },
  "historySettings": {
    "historyEnabled": true,
    "historyLimit": 100
  },
  "guardrails": {
    "maxUsersPerRoom": 50,
    "maxRoomsPerUser": 5,
    "messageRateLimit": 30,
    "maxMessageSize": 4096,
    "connectionTimeout": 1800000,
    "authCacheTTL": 600
  },
  "hubLogic": {
    "stateScript": "lib.chessEngine.getState(roomId, session)",
    "messageHandlers": [
      {
        "messageType": "chessMove",
        "script": "lib.chessEngine.processMove(roomId, session, message, lib)"
      },
      {
        "messageType": "drawOffer",
        "script": "lib.chessEngine.handleDrawOffer(roomId, session, message, lib)"
      },
      {
        "messageType": "resign",
        "script": "lib.chessEngine.handleResign(roomId, session, message, lib)"
      }
    ],
    "scheduledActions": [
      {
        "name": "clockTick",
        "intervalMs": 1000,
        "keepAlive": false,
        "script": "lib.chessEngine.clockTick(roomId, lib)"
      }
    ]
  }
}

const { getRedisData } = require("common");

async function getState(roomId, session) {
  const raw = await getRedisData(`chess:state:${roomId}`);
  if (!raw) return null;
  const state = JSON.parse(raw);

  return {
    board: state.board,
    turn: state.turn,
    moveCount: state.moveCount,
    whitePlayer: state.whitePlayer,
    blackPlayer: state.blackPlayer,
    whiteClock: state.whiteClock,
    blackClock: state.blackClock,
    status: state.status,
    lastMove: state.lastMove,
    capturedPieces: state.capturedPieces,
    isCheck: state.isCheck,
    legalMoves: state.turn === session.userId ? state.legalMoves : undefined
  };
}

const { getRedisData, setRedisData } = require("common");
const { createChessMove, updateChessGameById } = require("dbLayer");

async function processMove(roomId, session, message, lib) {
  const raw = await getRedisData(`chess:state:${roomId}`);
  if (!raw) return { accept: false, rejectReason: "Game not initialized" };

  const state = JSON.parse(raw);

  if (state.status !== "active") {
    return { accept: false, rejectReason: "Game is not active" };
  }

  if (state.turn !== session.userId) {
    return { accept: false, rejectReason: "Not your turn" };
  }

  const { from, to, promotion } = message.content;

  const moveResult = validateAndApplyMove(state, from, to, promotion);
  if (!moveResult.valid) {
    return { accept: false, rejectReason: moveResult.reason };
  }

  const newState = moveResult.newState;

  // Persist move to ChessMove DataObject for replay/analysis
  await createChessMove({
    chessGameId: roomId,
    moveNumber: newState.moveCount,
    playerId: session.userId,
    from,
    to,
    piece: moveResult.piece,
    captured: moveResult.captured || null,
    promotion: promotion || null,
    notation: moveResult.notation,
    fen: newState.fen,
    timestamp: new Date().toISOString()
  });

  // Save updated state to Redis
  await setRedisData(`chess:state:${roomId}`, JSON.stringify(newState));

  // Build the response
  const serverMessages = [];

  if (newState.isCheckmate) {
    newState.status = "completed";
    serverMessages.push({
      type: "gameEvent",
      content: { event: "checkmate", winner: session.userId, reason: "checkmate" },
      to: "all"
    });
    await updateChessGameById(roomId, {
      status: "completed",
      result: "checkmate",
      winnerId: session.userId
    });
  } else if (newState.isStalemate) {
    newState.status = "completed";
    serverMessages.push({
      type: "gameEvent",
      content: { event: "draw", reason: "stalemate" },
      to: "all"
    });
    await updateChessGameById(roomId, {
      status: "completed",
      result: "draw",
      reason: "stalemate"
    });
  } else if (newState.isCheck) {
    serverMessages.push({
      type: "gameEvent",
      content: { event: "check" },
      to: "all",
      persist: false
    });
  }

  // Update state in Redis with final status
  await setRedisData(`chess:state:${roomId}`, JSON.stringify(newState));

  return {
    accept: true,
    broadcast: true,
    broadcastTo: "all",
    modifiedContent: {
      from,
      to,
      promotion: promotion || null,
      piece: moveResult.piece,
      captured: moveResult.captured || null,
      notation: moveResult.notation,
      fen: newState.fen,
      isCheck: newState.isCheck
    },
    serverMessages
  };
}

function validateAndApplyMove(state, from, to, promotion) {
  // This is where the actual chess rules engine lives.
  // Uses a chess library (or custom implementation) to:
  // 1. Validate the move is legal for the current board position
  // 2. Apply the move and compute the new board state
  // 3. Detect check, checkmate, stalemate, draw conditions
  // 4. Compute legal moves for the next player
  // Returns: { valid, reason?, newState, piece, captured, notation }
}

async function handleDrawOffer(roomId, session, message, lib) {
  const raw = await getRedisData(`chess:state:${roomId}`);
  const state = JSON.parse(raw);
  const { action } = message.content;

  if (action === "offer") {
    state.drawOffer = { from: session.userId, timestamp: Date.now() };
    await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));
    return {
      accept: true,
      broadcast: true,
      broadcastTo: "all",
      serverMessages: [{
        type: "gameEvent",
        content: { event: "drawOffered", by: session.userId },
        to: "all",
        persist: false
      }]
    };
  }

  if (action === "accept" && state.drawOffer && state.drawOffer.from !== session.userId) {
    state.status = "completed";
    await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));
    await updateChessGameById(roomId, { status: "completed", result: "draw", reason: "agreement" });
    return {
      accept: true,
      broadcast: false,
      serverMessages: [{
        type: "gameEvent",
        content: { event: "draw", reason: "agreement" },
        to: "all"
      }]
    };
  }

  if (action === "decline") {
    state.drawOffer = null;
    await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));
    return {
      accept: true,
      broadcast: false,
      serverMessages: [{
        type: "gameEvent",
        content: { event: "drawDeclined" },
        to: "all",
        persist: false
      }]
    };
  }

  return { accept: false, rejectReason: "Invalid draw action" };
}

async function handleResign(roomId, session, message, lib) {
  const raw = await getRedisData(`chess:state:${roomId}`);
  const state = JSON.parse(raw);

  const winnerId = state.whitePlayer === session.userId
    ? state.blackPlayer
    : state.whitePlayer;

  state.status = "completed";
  await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));
  await updateChessGameById(roomId, {
    status: "completed",
    result: "resignation",
    winnerId
  });

  return {
    accept: true,
    broadcast: false,
    serverMessages: [{
      type: "gameEvent",
      content: { event: "resignation", winner: winnerId, resigned: session.userId },
      to: "all"
    }]
  };
}

async function clockTick(roomId, lib) {
  const raw = await getRedisData(`chess:state:${roomId}`);
  if (!raw) return { serverMessages: [] };
  const state = JSON.parse(raw);

  if (state.status !== "active") return { serverMessages: [] };

  const activeColor = state.turn === state.whitePlayer ? "white" : "black";
  if (activeColor === "white") {
    state.whiteClock = Math.max(0, state.whiteClock - 1);
  } else {
    state.blackClock = Math.max(0, state.blackClock - 1);
  }

  await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));

  // Time expired
  if (state.whiteClock <= 0 || state.blackClock <= 0) {
    const loser = state.whiteClock <= 0 ? state.whitePlayer : state.blackPlayer;
    const winner = loser === state.whitePlayer ? state.blackPlayer : state.whitePlayer;
    state.status = "completed";
    await setRedisData(`chess:state:${roomId}`, JSON.stringify(state));
    await updateChessGameById(roomId, {
      status: "completed",
      result: "timeout",
      winnerId: winner
    });

    return {
      serverMessages: [
        {
          type: "gameEvent",
          content: { event: "timeout", winner, loser },
          to: "all"
        }
      ]
    };
  }

  // Broadcast clock update every second (ephemeral, not persisted)
  return {
    serverMessages: [
      {
        type: "gameEvent",
        content: {
          event: "clockUpdate",
          whiteClock: state.whiteClock,
          blackClock: state.blackClock
        },
        to: "all",
        persist: false
      }
    ]
  };
}

import { io } from "socket.io-client";

const socket = io(`${baseUrl}/chess-api/hub/chessGame`, {
  auth: { token: `Bearer ${accessToken}` },
  transports: ["websocket"],
});

// ── Join a game room ──────────────────────────────────────────────────

socket.emit("hub:join", { roomId: gameId });

socket.on("hub:joined", ({ roomId, hubRole }) => {
  isPlayer = hubRole === "player";
  isSpectator = hubRole === "spectator";
});

// ── Receive board state (on join and on demand) ──────────────────────

socket.on("hub:state", ({ roomId, state }) => {
  renderBoard(state.board);
  setClocks(state.whiteClock, state.blackClock);
  setTurnIndicator(state.turn);
  if (state.legalMoves) highlightLegalMoves(state.legalMoves);
  setPlayerInfo(state.whitePlayer, state.blackPlayer);
  setCapturedPieces(state.capturedPieces);
});

// ── Receive all messages (chat + moves + game events) ────────────────

socket.on("hub:messageArrived", ({ sender, message }) => {
  switch (message.messageType) {
    case "chessMove":
      animateMove(message.content.from, message.content.to);
      updateBoardFromFen(message.content.fen);
      addToMoveList(message.content.notation);
      if (message.content.isCheck) flashCheck();
      break;

    case "gameEvent":
      handleGameEvent(message.content);
      break;

    case "text":
    case "sticker":
      appendChatMessage(sender, message);
      break;
  }
});

// ── Handle rejected moves ────────────────────────────────────────────

socket.on("hub:rejected", ({ messageType, reason }) => {
  if (messageType === "chessMove") {
    shakeBoard();
    showToast(`Invalid move: ${reason}`);
  }
});

// ── Make a move ──────────────────────────────────────────────────────

function onPieceDrop(from, to, promotion) {
  socket.emit("hub:send", {
    roomId: gameId,
    messageType: "chessMove",
    content: { from, to, promotion }
  });
}

// ── Chat messages (standard hub flow, no interception) ───────────────

function sendChatMessage(text) {
  socket.emit("hub:send", {
    roomId: gameId,
    messageType: "text",
    content: { body: text }
  });
}

// ── Game actions ─────────────────────────────────────────────────────

function offerDraw() {
  socket.emit("hub:send", {
    roomId: gameId,
    messageType: "drawOffer",
    content: { action: "offer" }
  });
}

function acceptDraw() {
  socket.emit("hub:send", {
    roomId: gameId,
    messageType: "drawOffer",
    content: { action: "accept" }
  });
}

function resign() {
  socket.emit("hub:send", {
    roomId: gameId,
    messageType: "resign",
    content: {}
  });
}

// ── Handle game events ───────────────────────────────────────────────

function handleGameEvent(content) {
  switch (content.event) {
    case "check":
      flashCheck();
      break;
    case "checkmate":
      showGameOver(`Checkmate! ${getPlayerName(content.winner)} wins.`);
      break;
    case "draw":
      showGameOver(`Draw by ${content.reason}.`);
      break;
    case "resignation":
      showGameOver(`${getPlayerName(content.resigned)} resigned. ${getPlayerName(content.winner)} wins.`);
      break;
    case "timeout":
      showGameOver(`Time's up! ${getPlayerName(content.winner)} wins on time.`);
      break;
    case "clockUpdate":
      setClocks(content.whiteClock, content.blackClock);
      break;
    case "drawOffered":
      if (content.by !== myUserId) showDrawOfferDialog();
      break;
    case "drawDeclined":
      showToast("Draw offer declined.");
      break;
  }
}

// ── Resync after reconnect ───────────────────────────────────────────

socket.on("connect", () => {
  socket.emit("hub:join", { roomId: gameId });
});

socket.on("hub:requestState", { roomId: gameId });

// ── Chat history on join ─────────────────────────────────────────────

socket.on("hub:history", ({ messages }) => {
  for (const msg of messages.reverse()) {
    if (msg.messageType === "text" || msg.messageType === "sticker") {
      appendChatMessage(msg.sender, msg);
    }
  }
});