dchain/client-app/lib/store.ts

/**
 * Global app state via Zustand.
 * Keeps runtime state; persistent data lives in storage.ts.
 */

import { create } from 'zustand';
import type { KeyFile, Contact, Chat, Message, ContactRequest, NodeSettings } from './types';

interface AppState {
  // Identity
  keyFile:    KeyFile | null;
  username:   string | null;
  setKeyFile: (kf: KeyFile | null) => void;
  setUsername: (u: string | null) => void;

  // Node settings
  settings:     NodeSettings;
  setSettings:  (s: Partial<NodeSettings>) => void;

  // Contacts
  contacts:    Contact[];
  setContacts: (contacts: Contact[]) => void;
  upsertContact: (c: Contact) => void;

  // Chats (derived from contacts + messages)
  chats:    Chat[];
  setChats: (chats: Chat[]) => void;

  // Active chat messages
  messages:    Record<string, Message[]>;  // key: contactAddress
  setMessages: (chatId: string, msgs: Message[]) => void;
  appendMessage: (chatId: string, msg: Message) => void;

  // Contact requests (pending)
  requests:    ContactRequest[];
  setRequests: (reqs: ContactRequest[]) => void;

  // Balance
  balance:    number;
  setBalance: (b: number) => void;

  // Loading / error states
  loading:  boolean;
  setLoading: (v: boolean) => void;
  error:    string | null;
  setError: (e: string | null) => void;

  // Nonce cache (to avoid refetching)
  nonce:    number;
  setNonce: (n: number) => void;

  // Per-contact unread counter (reset on chat open, bumped on peer msg arrive).
  // Keyed by contactAddress (Ed25519 pubkey hex).
  unreadByContact:   Record<string, number>;
  incrementUnread:   (contactAddress: string) => void;
  clearUnread:       (contactAddress: string) => void;
  /** Bootstrap state: `true` after initial loadKeyFile + loadSettings done. */
  booted:            boolean;
  setBooted:         (b: boolean) => void;
}

export const useStore = create<AppState>((set, get) => ({
  keyFile:    null,
  username:   null,
  setKeyFile: (kf) => set({ keyFile: kf }),
  setUsername: (u) => set({ username: u }),

  settings: {
    nodeUrl:    'http://localhost:8081',
    contractId: '',
  },
  setSettings: (s) => set(state => ({ settings: { ...state.settings, ...s } })),

  contacts:    [],
  setContacts: (contacts) => set({ contacts }),
  upsertContact: (c) => set(state => {
    const idx = state.contacts.findIndex(x => x.address === c.address);
    if (idx >= 0) {
      const updated = [...state.contacts];
      updated[idx] = c;
      return { contacts: updated };
    }
    return { contacts: [...state.contacts, c] };
  }),

  chats:    [],
  setChats: (chats) => set({ chats }),

  messages:    {},
  setMessages: (chatId, msgs) => set(state => ({
    messages: { ...state.messages, [chatId]: msgs },
  })),
  appendMessage: (chatId, msg) => set(state => {
    const current = state.messages[chatId] ?? [];
    if (current.find(m => m.id === msg.id)) return {};
    return { messages: { ...state.messages, [chatId]: [...current, msg] } };
  }),

  requests:    [],
  setRequests: (reqs) => set({ requests: reqs }),

  balance:    0,
  setBalance: (b) => set({ balance: b }),

  loading:    false,
  setLoading: (v) => set({ loading: v }),
  error:      null,
  setError:   (e) => set({ error: e }),

  nonce:    0,
  setNonce: (n) => set({ nonce: n }),

  unreadByContact: {},
  incrementUnread: (addr) => set(state => ({
    unreadByContact: {
      ...state.unreadByContact,
      [addr]: (state.unreadByContact[addr] ?? 0) + 1,
    },
  })),
  clearUnread: (addr) => set(state => {
    if (!state.unreadByContact[addr]) return {};
    const next = { ...state.unreadByContact };
    delete next[addr];
    return { unreadByContact: next };
  }),
  booted:    false,
  setBooted: (b) => set({ booted: b }),
}));