import { AuthService } from './services/auth-service.js';
import { listStoredMessages, putStoredMessage, deleteStoredMessage, clearStoredMessages } from './services/message-store.js';
import { SOLANA_ENDPOINT_DEFAULT } from './solana-programs.js';
import {
  DEFAULT_SHINE_SERVER_HTTP,
  DEFAULT_SHINE_SERVER_LOGIN,
  DEFAULT_SHINE_SERVER_WS,
  resolveShineServerByServerLogin,
} from './services/shine-server-resolver.js';
import { emptyPasswordWords } from './services/password-words.js';

const clone = (value) => JSON.parse(JSON.stringify(value));
const SESSION_STORAGE_KEY = 'shine-ui-current-session-v1';
const PROFILES_STORAGE_KEY = 'shine-ui-profiles-v1';
const ACTIVE_PROFILE_STORAGE_KEY = 'shine-ui-active-profile-v1';
const REACTIONS_STORAGE_KEY = 'shine-ui-message-reactions-v2';
const WEB_PUSH_SUBSCRIPTION_KEY = 'shine-ui-webpush-subscription-v1';
const ENTRY_SETTINGS_STORAGE_KEY = 'shine-ui-entry-settings-v1';
const CHANNEL_NOTIFY_KEY = 'shine-channels-notify-v1';
const CHANNELS_DEMO_KEY = 'shine-channels-demo';
const CREATE_CHANNEL_FLASH_KEY = 'shine-channels-create-success';
const MAX_APP_LOG_ENTRIES = 500;
const INVALID_SESSION_CODES = new Set([
  'NOT_AUTHENTICATED',
  'SESSION_NOT_FOUND',
  'SESSION_KEY_NOT_ACTUAL',
  'SESSION_OF_ANOTHER_USER',
]);

function isLocalPreviewHost() {
  const host = String(window.location.hostname || '').toLowerCase();
  return host === 'localhost' || host === '127.0.0.1' || host === '::1';
}

function readLocalWsOverrideUrl() {
  try {
    const params = new URLSearchParams(window.location.search);

    const explicitWsUrl = String(params.get('wsUrl') || '').trim();
    if (explicitWsUrl) {
      if (explicitWsUrl.startsWith('ws://') || explicitWsUrl.startsWith('wss://')) {
        try {
          const parsed = new URL(explicitWsUrl);
          if (!parsed.pathname || parsed.pathname === '/') parsed.pathname = '/ws';
          return parsed.toString();
        } catch {
          return explicitWsUrl;
        }
      }
      if (explicitWsUrl.startsWith('http://') || explicitWsUrl.startsWith('https://')) {
        try {
          const parsed = new URL(explicitWsUrl);
          parsed.protocol = parsed.protocol === 'https:' ? 'wss:' : 'ws:';
          if (!parsed.pathname || parsed.pathname === '/') parsed.pathname = '/ws';
          return parsed.toString();
        } catch {
          return `${explicitWsUrl.replace(/^http/, 'ws').replace(/\/$/, '')}/ws`;
        }
      }
      return '';
    }

    const value = params.get('localWsPort');
    const asNum = Number(value);
    if (!Number.isFinite(asNum)) return '';
    const port = Math.trunc(asNum);
    if (port <= 0 || port > 65535) return '';
    const isHttpsPage = window.location.protocol === 'https:';
    const forceInsecureLocal = params.get('allowInsecureLocalWs') === '1';
    const scheme = (isHttpsPage && !forceInsecureLocal) ? 'wss' : 'ws';
    return `${scheme}://localhost:${port}/ws`;
  } catch {
    return '';
  }
}

function inferTunnelWsUrl() {
  try {
    const host = String(window.location.host || '').toLowerCase();
    const isTunnelHost = (
      host.endsWith('.ngrok-free.dev') ||
      host.endsWith('.ngrok.io') ||
      host.endsWith('.trycloudflare.com')
    );
    if (!isTunnelHost) return '';
    const scheme = window.location.protocol === 'https:' ? 'wss' : 'ws';
    return `${scheme}://${window.location.host}/ws`;
  } catch {
    return '';
  }
}

const LOCAL_WS_OVERRIDE_URL = readLocalWsOverrideUrl() || inferTunnelWsUrl();
const DEFAULT_SOLANA_SERVER = SOLANA_ENDPOINT_DEFAULT;
const DEFAULT_SHINE_SERVER = DEFAULT_SHINE_SERVER_WS;
const DEFAULT_SHINE_SERVER_LOGIN_VALUE = DEFAULT_SHINE_SERVER_LOGIN;
const DEFAULT_SHINE_SERVER_HTTP_VALUE = DEFAULT_SHINE_SERVER_HTTP;
const DEFAULT_ARWEAVE_SERVER = 'https://arweave.net';
const DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS = 6000;

function normalizeStoredSolanaServer(value) {
  const raw = String(value || '').trim();
  if (!raw) return DEFAULT_SOLANA_SERVER;
  return raw.replace(/\/+$/u, '');
}

export function normalizeDmChatId(value) {
  return String(value || '').trim().toLowerCase();
}

function normalizeToolsSettings(rawTools) {
  const source = rawTools && typeof rawTools === 'object' ? rawTools : {};
  const tts = source.textToSpeech && typeof source.textToSpeech === 'object' ? source.textToSpeech : {};
  return {
    textToSpeech: {
      provider: String(tts.provider || 'openai'),
      quality: String(tts.quality || 'medium'),
      voice: String(tts.voice || ''),
      piperBaseUrl: String(tts.piperBaseUrl || 'http://127.0.0.1:5000'),
      externalBaseUrl: String(tts.externalBaseUrl || ''),
      apiKey: String(tts.apiKey || ''),
      model: String(tts.model || ''),
    },
  };
}


function normalizeProfileLogin(value) {
  return String(value || '').trim().toLowerCase();
}

function loadProfileStoreRaw() {
  try {
    const raw = localStorage.getItem(PROFILES_STORAGE_KEY);
    if (!raw) return [];
    const parsed = JSON.parse(raw);
    if (!Array.isArray(parsed)) return [];
    return parsed.filter((item) => item && normalizeProfileLogin(item.login) && String(item.sessionId || '').trim());
  } catch {
    return [];
  }
}

function persistProfileStoreRaw(items) {
  try {
    localStorage.setItem(PROFILES_STORAGE_KEY, JSON.stringify(Array.isArray(items) ? items : []));
  } catch {
    // ignore storage errors
  }
}

function getActiveProfileLoginRaw() {
  try {
    return normalizeProfileLogin(localStorage.getItem(ACTIVE_PROFILE_STORAGE_KEY));
  } catch {
    return '';
  }
}

function setActiveProfileLoginRaw(login) {
  const normalized = normalizeProfileLogin(login);
  try {
    if (normalized) localStorage.setItem(ACTIVE_PROFILE_STORAGE_KEY, normalized);
    else localStorage.removeItem(ACTIVE_PROFILE_STORAGE_KEY);
  } catch {
    // ignore storage errors
  }
}

function profileEntrySettingsSnapshot(settings = {}) {
  return {
    solanaServer: String(settings.solanaServer || ''),
    shineServer: String(settings.shineServer || ''),
    shineServerLogin: String(settings.shineServerLogin || ''),
    shineServerHttp: String(settings.shineServerHttp || ''),
    arweaveServer: String(settings.arweaveServer || ''),
    callPreflightTimeoutMs: Number(settings.callPreflightTimeoutMs || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS),
    remoteAddBlockSessionId: String(settings.remoteAddBlockSessionId || ''),
  };
}

function upsertSavedProfileInternal({ login, sessionId, isLocalDemo = false, entrySettings = null } = {}) {
  const normalized = normalizeProfileLogin(login);
  const cleanSessionId = String(sessionId || '').trim();
  if (!normalized || !cleanSessionId) return;
  const items = loadProfileStoreRaw();
  const index = items.findIndex((item) => normalizeProfileLogin(item.login) === normalized);
  const previous = index >= 0 ? items[index] : {};
  const next = {
    ...previous,
    login: String(login || '').trim(),
    sessionId: cleanSessionId,
    isLocalDemo: Boolean(isLocalDemo),
    entrySettings: entrySettings ? profileEntrySettingsSnapshot(entrySettings) : (previous.entrySettings || {}),
    updatedAtMs: Date.now(),
  };
  if (index >= 0) items[index] = next;
  else items.push(next);
  persistProfileStoreRaw(items);
  setActiveProfileLoginRaw(normalized);
}

function migrateLegacySessionToProfileStore() {
  const existing = loadProfileStoreRaw();
  if (existing.length) return;
  try {
    const raw = localStorage.getItem(SESSION_STORAGE_KEY);
    if (!raw) return;
    const legacy = JSON.parse(raw);
    if (!legacy?.login || !legacy?.sessionId) return;
    let entrySettings = {};
    try {
      entrySettings = JSON.parse(localStorage.getItem(ENTRY_SETTINGS_STORAGE_KEY) || '{}') || {};
    } catch {}
    upsertSavedProfileInternal({
      login: legacy.login,
      sessionId: legacy.sessionId,
      isLocalDemo: legacy.isLocalDemo,
      entrySettings,
    });
  } catch {
    // ignore migration errors
  }
}

function loadStoredSession() {
  migrateLegacySessionToProfileStore();
  const profiles = loadProfileStoreRaw();
  if (profiles.length) {
    const activeLogin = getActiveProfileLoginRaw();
    const active = profiles.find((item) => normalizeProfileLogin(item.login) === activeLogin) || profiles[0];
    if (active) {
      setActiveProfileLoginRaw(active.login);
      return {
        isAuthorized: false,
        isLocalDemo: Boolean(active.isLocalDemo),
        login: String(active.login || '').trim(),
        sessionId: String(active.sessionId || '').trim(),
      };
    }
  }
  try {
    const raw = localStorage.getItem(SESSION_STORAGE_KEY);
    if (!raw) return null;
    return JSON.parse(raw);
  } catch {
    return null;
  }
}

function loadStoredReactions() {
  try {
    const raw = localStorage.getItem(REACTIONS_STORAGE_KEY);
    if (!raw) return {};
    const parsed = JSON.parse(raw);
    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
    return parsed;
  } catch {
    return {};
  }
}

function persistStoredReactions(reactions) {
  try {
    localStorage.setItem(REACTIONS_STORAGE_KEY, JSON.stringify(reactions || {}));
  } catch {
    // ignore storage errors
  }
}

function persistSession(session) {
  try {
    localStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(session));
  } catch {
    // ignore quota/storage errors for prototype
  }
}

function clearStoredSession() {
  try {
    localStorage.removeItem(SESSION_STORAGE_KEY);
  } catch {
    // ignore
  }
}

function loadStoredEntrySettings() {
  migrateLegacySessionToProfileStore();
  const profiles = loadProfileStoreRaw();
  if (profiles.length) {
    const activeLogin = getActiveProfileLoginRaw();
    const active = profiles.find((item) => normalizeProfileLogin(item.login) === activeLogin) || profiles[0];
    if (active?.entrySettings && typeof active.entrySettings === 'object') {
      return active.entrySettings;
    }
  }
  try {
    const raw = localStorage.getItem(ENTRY_SETTINGS_STORAGE_KEY);
    if (!raw) return null;
    const parsed = JSON.parse(raw);
    if (!parsed || typeof parsed !== 'object') return null;
    return parsed;
  } catch {
    return null;
  }
}

function persistEntrySettings(settings) {
  try {
    const payload = {
      language: String(settings?.language || 'ru'),
      solanaServer: normalizeStoredSolanaServer(settings?.solanaServer),
      shineServer: String(settings?.shineServer || DEFAULT_SHINE_SERVER),
      shineServerLogin: String(settings?.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE),
      shineServerHttp: String(settings?.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE),
      arweaveServer: String(settings?.arweaveServer || DEFAULT_ARWEAVE_SERVER),
      callPreflightTimeoutMs: Math.max(1000, Math.min(20000, Number(settings?.callPreflightTimeoutMs || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS) || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS)),
      remoteAddBlockSessionId: String(settings?.remoteAddBlockSessionId || ''),
      statuses: {
        solanaServer: String(settings?.statuses?.solanaServer || 'idle'),
        shineServerLogin: String(settings?.statuses?.shineServerLogin || settings?.statuses?.shineServer || 'idle'),
        arweaveServer: String(settings?.statuses?.arweaveServer || 'idle'),
      },
      tools: normalizeToolsSettings(settings?.tools),
    };
    localStorage.setItem(ENTRY_SETTINGS_STORAGE_KEY, JSON.stringify(payload));
    const activeLogin = getActiveProfileLoginRaw();
    if (activeLogin) {
      const profiles = loadProfileStoreRaw();
      const index = profiles.findIndex((item) => normalizeProfileLogin(item.login) === activeLogin);
      if (index >= 0) {
        profiles[index] = {
          ...profiles[index],
          entrySettings: profileEntrySettingsSnapshot(payload),
          updatedAtMs: Date.now(),
        };
        persistProfileStoreRaw(profiles);
      }
    }
  } catch {
    // ignore storage errors
  }
}

export function clearBrowserClientData() {
  const localKeys = [
    SESSION_STORAGE_KEY,
    REACTIONS_STORAGE_KEY,
    WEB_PUSH_SUBSCRIPTION_KEY,
    CHANNEL_NOTIFY_KEY,
    CHANNELS_DEMO_KEY,
  ];
  localKeys.forEach((key) => {
    try {
      localStorage.removeItem(key);
    } catch {
      // ignore
    }
  });

  try {
    sessionStorage.removeItem(CREATE_CHANNEL_FLASH_KEY);
  } catch {
    // ignore
  }
}

function createInitialState({ withStoredSession = true } = {}) {
  const storedSession = withStoredSession ? loadStoredSession() : null;
  const storedLocalDemo = Boolean(storedSession?.isLocalDemo && isLocalPreviewHost());
  const storedReactions = loadStoredReactions();
  const storedEntrySettings = loadStoredEntrySettings();
  const initialShineServer = LOCAL_WS_OVERRIDE_URL || DEFAULT_SHINE_SERVER;

  return {
    chats: {},
    contacts: [],
    appLog: [],
    incomingDedup: {},
    knownMessageKeys: {},
    pendingOutgoingReadByBaseKey: {},
    pendingIncomingReadByBaseKey: {},
    outgoingTempSeq: 1,
    notificationsTab: 'replies',
    notificationUnreadTotal: 0,
    userCounters: { dmUnreadCount: 0, channelsUnreadCount: 0, notificationsUnreadCount: 0, notifications: { replies: 0, connections: 0, events: 0 } },
    pageLabelCollapsed: false,
    session: {
      isAuthorized: storedLocalDemo,
      isLocalDemo: storedLocalDemo,
      login: storedSession?.login || '',
      sessionId: storedSession?.sessionId || '',
      storagePwdInMemory: '',
    },
    startHint: '',
    entrySettings: {
      language: String(storedEntrySettings?.language || 'ru'),
      solanaServer: normalizeStoredSolanaServer(storedEntrySettings?.solanaServer),
      shineServer: String(LOCAL_WS_OVERRIDE_URL || storedEntrySettings?.shineServer || initialShineServer),
      shineServerLogin: String(storedEntrySettings?.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE),
      shineServerHttp: String(storedEntrySettings?.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE),
      arweaveServer: String(storedEntrySettings?.arweaveServer || DEFAULT_ARWEAVE_SERVER),
      callPreflightTimeoutMs: Math.max(1000, Math.min(20000, Number(storedEntrySettings?.callPreflightTimeoutMs || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS) || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS)),
      remoteAddBlockSessionId: String(storedEntrySettings?.remoteAddBlockSessionId || ''),
      statuses: {
        solanaServer: String(storedEntrySettings?.statuses?.solanaServer || 'idle'),
        shineServerLogin: String(storedEntrySettings?.statuses?.shineServerLogin || storedEntrySettings?.statuses?.shineServer || 'idle'),
        arweaveServer: String(storedEntrySettings?.statuses?.arweaveServer || 'idle'),
      },
      tools: normalizeToolsSettings(storedEntrySettings?.tools),
    },
    registrationDraft: {
      flowType: '',
      login: '',
      password: '',
      passwordMode: 'single',
      passwordWords: emptyPasswordWords(),
      passwordWordsLinked: false,
      usePromoCode: false,
      promoCode: '',
      sessionId: '',
      storagePwd: '',
      pendingKeyBundle: null,
      pendingSessionMaterial: null,
      preGeneratedKeyBundle: null,
    },
    registrationHelp: {
      selectedTopic: 'keys-storage',
    },
    loginDraft: {
      login: storedSession?.login || '',
      password: '',
      passwordMode: 'single',
      passwordWords: emptyPasswordWords(),
    },
    registrationPayment: {
      walletAddress: '',
      balanceSOL: '0.0000',
    },
    keyStorage: {
      rootKey: 'Ключ root хранится в зашифрованном виде',
      blockchainKey: 'Ключ blockchain хранится в зашифрованном виде',
      clientKey: 'Client key хранится в зашифрованном виде',
      saveRoot: true,
      saveBlockchain: true,
      saveClient: true,
    },
    deviceConnect: {
      root: true,
      blockchain: true,
      client: true,
    },
    authUi: {
      busy: false,
      error: '',
      info: '',
    },
    authReturnHash: '',
    sessions: [],
    channelsFeed: null,
    channelsIndex: {},
    localChannelPosts: {},
    messageReactions: storedReactions,
  };
}

export const state = createInitialState();

export const authService = new AuthService(state.entrySettings.shineServer);
authService.setRemoteAddBlockSessionId(state.entrySettings.remoteAddBlockSessionId);
authService.setActiveSessionContext({
  login: state.session.login,
  sessionId: state.session.sessionId,
});
let onSessionReset = null;
let onSessionAuthorized = null;

function parseMessageTimeFromKey(rawKey) {
  const value = String(rawKey || '').trim();
  if (!value) return 0;
  const parts = value.split('|');
  if (parts.length < 4) return 0;
  const timeMs = Number(parts[2] || 0);
  if (!Number.isFinite(timeMs) || timeMs <= 0) return 0;
  return Math.trunc(timeMs);
}

function resolveChatMessageTimeMs(row) {
  const fromBaseKey = parseMessageTimeFromKey(row?.baseKey);
  if (fromBaseKey > 0) return fromBaseKey;

  const fromMessageKey = parseMessageTimeFromKey(row?.messageKey);
  if (fromMessageKey > 0) return fromMessageKey;

  const fromCreatedAt = Number(row?.createdAtMs || row?.ts || 0);
  if (Number.isFinite(fromCreatedAt) && fromCreatedAt > 0) return Math.trunc(fromCreatedAt);

  const tempId = String(row?.tempId || '').trim();
  if (tempId.startsWith('tmp-')) {
    const parts = tempId.split('-');
    const ts = Number(parts[1] || 0);
    if (Number.isFinite(ts) && ts > 0) return Math.trunc(ts);
  }

  return 0;
}

function stableMessageOrderKey(row) {
  const key = String(row?.messageKey || '').trim();
  if (key) return `mk:${key}`;
  const tmp = String(row?.tempId || '').trim();
  if (tmp) return `tmp:${tmp}`;
  const base = String(row?.baseKey || '').trim();
  if (base) return `bk:${base}`;
  const text = String(row?.text || '').trim();
  return `txt:${text}`;
}

function sortChatMessagesInPlace(chatId) {
  const list = getChatMessages(chatId);
  list.sort((a, b) => {
    const ta = resolveChatMessageTimeMs(a);
    const tb = resolveChatMessageTimeMs(b);
    if (ta !== tb) return ta - tb;

    const ka = stableMessageOrderKey(a);
    const kb = stableMessageOrderKey(b);
    const byKey = ka.localeCompare(kb, 'ru');
    if (byKey !== 0) return byKey;

    if ((a?.from || '') !== (b?.from || '')) {
      return (a?.from === 'in') ? -1 : 1;
    }
    return 0;
  });
}

function persistMessageRecord(chatId, row) {
  const normalizedChatId = normalizeDmChatId(chatId);
  if (!normalizedChatId || !row?.messageKey) return;
  const resolvedTs = resolveChatMessageTimeMs(row);
  void putStoredMessage({
    messageKey: row.messageKey,
    ownerLogin: String(state.session.login || '').trim().toLowerCase(),
    chatId: normalizedChatId,
    from: row.from || 'in',
    text: String(row.text || ''),
    baseKey: String(row.baseKey || ''),
    messageType: Number(row.messageType || 0),
    rawBlobB64: String(row.rawBlobB64 || ''),
    revisionTimeMs: Number(row.revisionTimeMs || 0),
    unread: Boolean(row.unread),
    firstTick: Boolean(row.firstTick),
    secondTick: Boolean(row.secondTick),
    readAtMs: Number(row.readAtMs || 0),
    readReceiptSent: Boolean(row.readReceiptSent),
    refBaseKey: String(row.refBaseKey || ''),
    deliveryState: String(row.deliveryState || ''),
    ts: resolvedTs > 0 ? resolvedTs : Date.now(),
  }).catch(() => {});
}

function removeStoredMessageRecord(messageKey) {
  if (!messageKey) return;
  void deleteStoredMessage(messageKey, state.session.login).catch(() => {});
}

export async function hydrateMessagesFromStore() {
  try {
    const rows = await listStoredMessages(state.session.login);
    const touchedChats = new Set();
    rows
      .sort((a, b) => Number(a?.ts || 0) - Number(b?.ts || 0))
      .forEach((row) => {
        const chatId = normalizeDmChatId(row?.chatId);
        const messageKey = String(row?.messageKey || '').trim();
        if (!chatId || !messageKey) return;
        if (state.knownMessageKeys[messageKey]) return;
        state.knownMessageKeys[messageKey] = true;
        touchedChats.add(chatId);
        getChatMessages(chatId).push({
          from: row.from === 'out' ? 'out' : 'in',
          text: String(row.text || ''),
          messageKey,
          baseKey: String(row.baseKey || ''),
          messageType: Number(row.messageType || 0),
          rawBlobB64: String(row.rawBlobB64 || ''),
          revisionTimeMs: Number(row.revisionTimeMs || 0),
          unread: Boolean(row.unread),
          firstTick: Boolean(row.firstTick),
          secondTick: Boolean(row.secondTick),
          readAtMs: Number(row.readAtMs || 0),
          readReceiptSent: Boolean(row.readReceiptSent),
          refBaseKey: String(row.refBaseKey || ''),
          deliveryState: String(row.deliveryState || ''),
          createdAtMs: Number(row.ts || 0),
        });
      });
    touchedChats.forEach((chatId) => sortChatMessagesInPlace(chatId));
  } catch {
    // ignore broken storage
  }
}

export function getChatMessages(chatId) {
  const normalizedChatId = normalizeDmChatId(chatId);
  if (!normalizedChatId) return [];
  if (!state.chats[normalizedChatId]) {
    state.chats[normalizedChatId] = [];
  }
  return state.chats[normalizedChatId];
}

export function addChatMessage(chatId, text) {
  const message = text.trim();
  if (!message) return;
  getChatMessages(chatId).push({
    from: 'out',
    text: message,
    firstTick: false,
    secondTick: false,
    unread: false,
    createdAtMs: Date.now(),
  });
  sortChatMessagesInPlace(chatId);
}

export function addSystemChatMessage(chatId, text, { from = 'out', kind = 'system' } = {}) {
  const message = String(text || '').trim();
  if (!message) return;
  getChatMessages(chatId).push({
    from: from === 'in' ? 'in' : 'out',
    text: message,
    kind: String(kind || 'system'),
    unread: from === 'in',
    firstTick: from !== 'in',
    secondTick: false,
    createdAtMs: Date.now(),
  });
  sortChatMessagesInPlace(chatId);
}


export function addIncomingMessage(chatId, text, messageId = '') {
  const msg = text?.trim();
  if (!msg) return false;
  if (messageId && state.incomingDedup[messageId]) return false;
  if (messageId) state.incomingDedup[messageId] = true;
  getChatMessages(chatId).push({
    from: 'in',
    text: msg,
    messageId,
    unread: true,
    createdAtMs: Date.now(),
  });
  sortChatMessagesInPlace(chatId);
  return true;
}

export function addOutgoingPendingMessage(chatId, text) {
  const msg = String(text || '').trim();
  if (!msg) return null;
  const tempId = `tmp-${Date.now()}-${state.outgoingTempSeq++}`;
  getChatMessages(chatId).push({
    from: 'out',
    text: msg,
    tempId,
    firstTick: false,
    secondTick: false,
    unread: false,
    createdAtMs: Date.now(),
  });
  sortChatMessagesInPlace(chatId);
  return tempId;
}

export function markOutgoingSent(tempId, {
  messageKey = '',
  baseKey = '',
  deliveryState = 'accepted',
} = {}) {
  if (!tempId) return;
  const keys = Object.keys(state.chats || {});
  keys.forEach((chatId) => {
    const list = getChatMessages(chatId);
    const row = list.find((item) => item?.tempId === tempId);
    if (!row) return;
    row.firstTick = true;
    row.messageKey = messageKey || row.messageKey || '';
    row.baseKey = baseKey || row.baseKey || '';
    row.deliveryState = String(deliveryState || row.deliveryState || 'accepted');
    if (messageKey) {
      state.knownMessageKeys[messageKey] = true;
      persistMessageRecord(chatId, row);
    }
    sortChatMessagesInPlace(chatId);
  });
}

export function markOutgoingDeliveryState({
  outgoingKey = '',
  baseKey = '',
  deliveryState = '',
} = {}) {
  const normalizedOutgoingKey = String(outgoingKey || '').trim();
  const normalizedBaseKey = String(baseKey || '').trim();
  let changed = false;
  Object.keys(state.chats || {}).forEach((chatId) => {
    getChatMessages(chatId).forEach((row) => {
      if (row?.from !== 'out') return;
      const matches = (
        (normalizedOutgoingKey && String(row.messageKey || '') === normalizedOutgoingKey)
        || (normalizedBaseKey && String(row.baseKey || '') === normalizedBaseKey)
      );
      if (!matches) return;
      row.deliveryState = String(deliveryState || row.deliveryState || 'accepted');
      if (row.deliveryState === 'delivered') {
        row.firstTick = true;
      }
      persistMessageRecord(chatId, row);
      changed = true;
    });
  });
  return changed;
}

export function markOutgoingReadByBaseKey(baseKey, readAtMs = 0) {
  if (!baseKey) return;
  const normalizedReadAtMs = Number(readAtMs || 0);
  const keys = Object.keys(state.chats || {});
  let matched = false;
  keys.forEach((chatId) => {
    const list = getChatMessages(chatId);
    list.forEach((row) => {
      if (row?.from !== 'out') return;
      if (row.baseKey === baseKey) {
        matched = true;
        row.secondTick = true;
        if (Number.isFinite(normalizedReadAtMs) && normalizedReadAtMs > 0) {
          row.readAtMs = normalizedReadAtMs;
        }
        persistMessageRecord(chatId, row);
      }
    });
  });
  if (matched) {
    delete state.pendingOutgoingReadByBaseKey[baseKey];
  } else {
    state.pendingOutgoingReadByBaseKey[baseKey] = (Number.isFinite(normalizedReadAtMs) && normalizedReadAtMs > 0)
      ? normalizedReadAtMs
      : true;
  }
  return matched;
}

export function markIncomingReadByBaseKey(baseKey) {
  if (!baseKey) return;
  const keys = Object.keys(state.chats || {});
  let matched = false;
  keys.forEach((chatId) => {
    const list = getChatMessages(chatId);
    list.forEach((row) => {
      if (row?.from !== 'in') return;
      if (row.baseKey === baseKey) {
        matched = true;
        row.unread = false;
        row.readReceiptSent = true;
        persistMessageRecord(chatId, row);
      }
    });
  });
  if (matched) {
    delete state.pendingIncomingReadByBaseKey[baseKey];
  } else {
    state.pendingIncomingReadByBaseKey[baseKey] = true;
  }
  return matched;
}

export function markReadReceiptSentByBaseKey(baseKey) {
  if (!baseKey) return;
  const keys = Object.keys(state.chats || {});
  keys.forEach((chatId) => {
    const list = getChatMessages(chatId);
    list.forEach((row) => {
      if (row?.from !== 'in') return;
      if (row.baseKey === baseKey) {
        row.readReceiptSent = true;
        persistMessageRecord(chatId, row);
      }
    });
  });
}

export function addSignedMessageToChat({
  chatId,
  messageKey,
  baseKey = '',
  from = 'in',
  text = '',
  messageType = 1,
  unread = false,
  readAtMs = 0,
  rawBlobB64 = '',
  refBaseKey = '',
  revisionTimeMs = 0,
  deliveryState = '',
  deleted = false,
} = {}) {
  const normalizedChatId = normalizeDmChatId(chatId);
  const id = String(messageKey || '').trim();
  if (!normalizedChatId || !id) return false;
  const list = getChatMessages(normalizedChatId);
  const existingIndex = list.findIndex((row) => String(row?.messageKey || '').trim() === id);
  const existing = existingIndex >= 0 ? list[existingIndex] : null;
  const nextRevision = Number(revisionTimeMs || 0);
  const currentRevision = Number(existing?.revisionTimeMs || 0);

  if (existing && Number.isFinite(currentRevision) && nextRevision < currentRevision) {
    return false;
  }

  if (deleted) {
    if (existingIndex >= 0) {
      list.splice(existingIndex, 1);
      removeStoredMessageRecord(id);
      sortChatMessagesInPlace(normalizedChatId);
      return true;
    }
    return false;
  }

  state.knownMessageKeys[id] = true;
  const row = existing || {};
  row.from = from === 'out' ? 'out' : 'in';
  row.text = String(text || '');
  row.messageKey = id;
  row.baseKey = String(baseKey || '');
  row.messageType = Number(messageType || 0);
  row.rawBlobB64 = String(rawBlobB64 || '');
  row.revisionTimeMs = nextRevision;
  row.deliveryState = String(deliveryState || existing?.deliveryState || (row.from === 'out' ? 'accepted' : ''));
  row.unread = row.from === 'in' ? Boolean(unread) : false;
  row.refBaseKey = String(refBaseKey || '');
  row.firstTick = row.from === 'out';
  row.secondTick = Boolean(existing?.secondTick);
  row.readAtMs = Number(existing?.readAtMs || 0);
  row.readReceiptSent = Boolean(existing?.readReceiptSent);
  if (row.baseKey && row.from === 'out' && state.pendingOutgoingReadByBaseKey[row.baseKey]) {
    row.secondTick = true;
    const pendingReadAtMs = Number(state.pendingOutgoingReadByBaseKey[row.baseKey] || 0);
    if (Number.isFinite(pendingReadAtMs) && pendingReadAtMs > 0) {
      row.readAtMs = pendingReadAtMs;
    }
    delete state.pendingOutgoingReadByBaseKey[row.baseKey];
  }
  if (row.baseKey && row.from === 'in' && state.pendingIncomingReadByBaseKey[row.baseKey]) {
    row.unread = false;
    row.readReceiptSent = true;
    delete state.pendingIncomingReadByBaseKey[row.baseKey];
  }

  if (existingIndex < 0) {
    list.push(row);
  }
  const nextReadAtMs = Number(readAtMs || 0);
  if (Number.isFinite(nextReadAtMs) && nextReadAtMs > 0) {
    row.readAtMs = nextReadAtMs;
    if (row.from === 'out') {
      row.secondTick = true;
    }
  }
  sortChatMessagesInPlace(normalizedChatId);
  persistMessageRecord(normalizedChatId, row);
  return true;
}

export function deleteSignedMessageByBaseKey(chatId, baseKey) {
  const normalizedChatId = normalizeDmChatId(chatId);
  const normalizedBaseKey = String(baseKey || '').trim();
  if (!normalizedChatId || !normalizedBaseKey) return false;
  const list = getChatMessages(normalizedChatId);
  let changed = false;
  for (let i = list.length - 1; i >= 0; i -= 1) {
    const row = list[i];
    if (String(row?.baseKey || '').trim() !== normalizedBaseKey) continue;
    changed = true;
    removeStoredMessageRecord(String(row?.messageKey || '').trim());
    list.splice(i, 1);
  }
  if (changed) {
    sortChatMessagesInPlace(normalizedChatId);
  }
  return changed;
}

export function deleteConversationMessagesBefore(chatId, boundaryTimeMs) {
  const normalizedChatId = normalizeDmChatId(chatId);
  const boundary = Number(boundaryTimeMs || 0);
  if (!normalizedChatId || !Number.isFinite(boundary) || boundary <= 0) return 0;
  const list = getChatMessages(normalizedChatId);
  let removed = 0;
  for (let i = list.length - 1; i >= 0; i -= 1) {
    const row = list[i];
    const rowTime = resolveChatMessageTimeMs(row);
    if (!Number.isFinite(rowTime) || rowTime >= boundary) continue;
    removed += 1;
    removeStoredMessageRecord(String(row?.messageKey || '').trim());
    list.splice(i, 1);
  }
  if (removed > 0) {
    sortChatMessagesInPlace(normalizedChatId);
  }
  return removed;
}

export function markChatRead(chatId) {
  const normalizedChatId = normalizeDmChatId(chatId);
  const list = getChatMessages(normalizedChatId);
  let changed = 0;
  list.forEach((row) => {
    if (row?.from === 'in' && row?.unread) {
      row.unread = false;
      persistMessageRecord(normalizedChatId, row);
      changed += 1;
    }
  });
  return changed;
}

export function setContacts(list) {
  state.contacts = Array.isArray(list) ? [...list] : [];
}

function toText(value) {
  if (typeof value === 'string') return value;
  if (value == null) return '';
  try {
    return JSON.stringify(value);
  } catch {
    return String(value);
  }
}

export function addAppLogEntry({
  level = 'info',
  source = 'ui',
  message = '',
  details = '',
} = {}) {
  const cleanMessage = String(message || '').trim();
  if (!cleanMessage) return;
  const cleanLevel = String(level || 'info').trim().toLowerCase();
  const normalizedLevel = (cleanLevel === 'error' || cleanLevel === 'warn') ? cleanLevel : 'info';

  state.appLog.push({
    id: `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`,
    ts: Date.now(),
    level: normalizedLevel,
    source: String(source || 'ui').trim() || 'ui',
    message: cleanMessage,
    details: toText(details),
  });

  if (state.appLog.length > MAX_APP_LOG_ENTRIES) {
    state.appLog.splice(0, state.appLog.length - MAX_APP_LOG_ENTRIES);
  }
}

export function getAppLogEntries() {
  return [...state.appLog];
}

export function clearAppLogEntries() {
  state.appLog = [];
}

export function togglePageLabel() {
  state.pageLabelCollapsed = !state.pageLabelCollapsed;
}

export function ensureChat(chatId) {
  return getChatMessages(chatId);
}

export function checkServerAvailability(address) {
  const normalized = String(address || '').trim().toLowerCase();
  if (!normalized) return 'unavailable';
  return /^(https?:\/\/|wss?:\/\/)/i.test(normalized) ? 'available' : 'unavailable';
}

export function saveEntryLanguage(language) {
  state.entrySettings.language = String(language || 'ru');
  persistEntrySettings(state.entrySettings);
}

export async function saveEntrySettings(nextSettings) {
  const nextSolanaServer = normalizeStoredSolanaServer(nextSettings?.solanaServer || state.entrySettings.solanaServer || DEFAULT_SOLANA_SERVER);
  const nextShineServerLogin = String(nextSettings?.shineServerLogin || state.entrySettings.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE).trim().toLowerCase()
    || DEFAULT_SHINE_SERVER_LOGIN_VALUE;
  let forcedShineServer = LOCAL_WS_OVERRIDE_URL || '';
  let resolvedShineServerHttp = String(state.entrySettings.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE).trim() || DEFAULT_SHINE_SERVER_HTTP_VALUE;

  if (!forcedShineServer) {
    const resolved = await resolveShineServerByServerLogin({
      serverLogin: nextShineServerLogin,
      solanaEndpoint: nextSolanaServer,
    });
    forcedShineServer = resolved.wsUrl;
    resolvedShineServerHttp = resolved.httpBase;
  }

  state.entrySettings = {
    ...state.entrySettings,
    ...nextSettings,
    solanaServer: nextSolanaServer,
    shineServer: forcedShineServer,
    shineServerLogin: nextShineServerLogin,
    shineServerHttp: resolvedShineServerHttp,
    statuses: {
      ...state.entrySettings.statuses,
      ...(nextSettings.statuses || {}),
    },
    tools: normalizeToolsSettings(nextSettings.tools || state.entrySettings.tools),
  };
  persistEntrySettings(state.entrySettings);
  authService.setRemoteAddBlockSessionId(state.entrySettings.remoteAddBlockSessionId);
  await authService.reconnect(state.entrySettings.shineServer);
  state.startHint = `Настройки входа сохранены. SHiNE: ${state.entrySettings.shineServerHttp}`;
}

export function clearStartHint() {
  state.startHint = '';
}

export function setAuthBusy(flag) {
  state.authUi.busy = flag;
}

export function setAuthError(message) {
  state.authUi.error = message || '';
}

export function setAuthInfo(message) {
  state.authUi.info = message || '';
}

export function clearAuthMessages() {
  state.authUi.error = '';
  state.authUi.info = '';
}

export function authorizeSession({
  login = state.session.login,
  sessionId = state.session.sessionId,
  storagePwd = state.session.storagePwdInMemory,
  isLocalDemo = false,
} = {}) {
  const localDemo = Boolean(isLocalDemo && isLocalPreviewHost());
  state.session.isAuthorized = true;
  state.session.isLocalDemo = localDemo;
  state.session.login = login;
  state.session.sessionId = sessionId;
  state.session.storagePwdInMemory = storagePwd;
  persistSession({
    isAuthorized: true,
    isLocalDemo: localDemo,
    login,
    sessionId,
  });
  upsertSavedProfileInternal({ login, sessionId, isLocalDemo: localDemo, entrySettings: state.entrySettings });
  authService.setActiveSessionContext({ login, sessionId });
  state.startHint = '';
  if (onSessionAuthorized) {
    onSessionAuthorized();
  }
}

export function isLocalDemoAvailable() {
  return isLocalPreviewHost();
}

export function authorizeLocalDemoSession() {
  if (!isLocalPreviewHost()) return false;
  authorizeSession({
    login: 'local-tester',
    sessionId: 'local-ui-demo',
    storagePwd: '',
    isLocalDemo: true,
  });
  return true;
}

export function setSessionResetHandler(handler) {
  onSessionReset = typeof handler === 'function' ? handler : null;
}

export function setSessionAuthorizedHandler(handler) {
  onSessionAuthorized = typeof handler === 'function' ? handler : null;
}

export function isSessionInvalidError(error) {
  return INVALID_SESSION_CODES.has(error?.code);
}

export async function refreshSessions() {
  state.sessions = await authService.listSessions();
  return state.sessions;
}

export function resetRegistrationFlow() {
  const next = createInitialState();
  state.registrationDraft = next.registrationDraft;
  state.registrationHelp = next.registrationHelp;
  state.registrationPayment = next.registrationPayment;
  state.keyStorage = next.keyStorage;
}

function resetStateForSignedOut() {
  const next = createInitialState({ withStoredSession: false });
  state.chats = next.chats;
  state.contacts = next.contacts;
  state.appLog = next.appLog;
  state.incomingDedup = next.incomingDedup;
  state.knownMessageKeys = next.knownMessageKeys;
  state.pendingOutgoingReadByBaseKey = next.pendingOutgoingReadByBaseKey;
  state.pendingIncomingReadByBaseKey = next.pendingIncomingReadByBaseKey;
  state.outgoingTempSeq = next.outgoingTempSeq;
  state.notificationsTab = next.notificationsTab;
  state.pageLabelCollapsed = next.pageLabelCollapsed;
  state.session = next.session;
  state.startHint = next.startHint;
  state.entrySettings = next.entrySettings;
  state.registrationDraft = next.registrationDraft;
  state.loginDraft = next.loginDraft;
  state.registrationPayment = next.registrationPayment;
  state.keyStorage = next.keyStorage;
  state.deviceConnect = next.deviceConnect;
  state.authUi = next.authUi;
  state.sessions = next.sessions;
  state.channelsFeed = next.channelsFeed;
  state.channelsIndex = next.channelsIndex;
  state.localChannelPosts = next.localChannelPosts;
  state.messageReactions = next.messageReactions;
}

async function tryCloseCurrentSessionOnServer() {
  const currentSessionId = String(state.session.sessionId || '').trim();
  if (!state.session.isAuthorized || state.session.isLocalDemo || !currentSessionId) return;

  try {
    await authService.closeSession(currentSessionId);
  } catch (error) {
    addAppLogEntry({
      level: 'warn',
      source: 'session',
      message: 'Не удалось завершить текущую сессию на сервере',
      details: { sessionId: currentSessionId, error: error?.message || 'unknown' },
    });
  }
}

export async function terminateCurrentSession({ infoMessage = '', closeServerSession = false, notifySessionReset = true } = {}) {
  const signedOutLogin = String(state.session.login || '').trim();
  if (closeServerSession) {
    await tryCloseCurrentSessionOnServer();
  }

  clearStoredSession();
  resetStateForSignedOut();
  await clearStoredMessages(signedOutLogin).catch(() => {});
  authService.close();
  authService.clearActiveSessionContext();
  if (infoMessage) {
    state.startHint = infoMessage;
  }
  try {
    await authService.reconnect(state.entrySettings.shineServer);
  } catch {
    // ignore reconnect errors on sign out
  }
  if (notifySessionReset && onSessionReset) {
    onSessionReset();
  }
}

export async function closeCurrentSessionAndSignOut({ infoMessage = '' } = {}) {
  await terminateCurrentSession({ infoMessage, closeServerSession: true });
}


export function getSavedProfiles() {
  migrateLegacySessionToProfileStore();
  const activeLogin = getActiveProfileLoginRaw();
  return loadProfileStoreRaw().map((item) => ({
    login: String(item.login || '').trim(),
    sessionId: String(item.sessionId || '').trim(),
    isLocalDemo: Boolean(item.isLocalDemo),
    isActive: normalizeProfileLogin(item.login) === activeLogin,
    entrySettings: item.entrySettings || {},
  }));
}

export async function switchToSavedProfile(login) {
  const targetLogin = normalizeProfileLogin(login);
  const target = loadProfileStoreRaw().find((item) => normalizeProfileLogin(item.login) === targetLogin);
  if (!target) throw new Error('Профиль не найден на этом устройстве');
  if (targetLogin === normalizeProfileLogin(state.session.login)) return target;

  const origin = {
    login: String(state.session.login || '').trim(),
    sessionId: String(state.session.sessionId || '').trim(),
    isLocalDemo: Boolean(state.session.isLocalDemo),
    server: String(state.entrySettings.shineServer || DEFAULT_SHINE_SERVER).trim(),
  };
  const targetServer = String(target?.entrySettings?.shineServer || state.entrySettings.shineServer || DEFAULT_SHINE_SERVER).trim();

  // В каждый момент времени держим только один WebSocket: сначала полностью
  // закрываем transport активного профиля, затем создаём новый для target.
  authService.resetConnection(targetServer, { clearSessionContext: true });
  try {
    const resumed = await authService.resumeSession(target.login, target.sessionId);
    target.login = resumed.login || target.login;
    target.sessionId = resumed.sessionId || target.sessionId;
    target.updatedAtMs = Date.now();
    authService.setActiveSessionContext({ login: target.login, sessionId: target.sessionId });
    persistProfileStoreRaw(loadProfileStoreRaw().map((item) => (
      normalizeProfileLogin(item.login) === targetLogin ? target : item
    )));
    setActiveProfileLoginRaw(target.login);
    persistSession({ isAuthorized: true, isLocalDemo: Boolean(target.isLocalDemo), login: target.login, sessionId: target.sessionId });
    if (target.entrySettings && typeof target.entrySettings === 'object') {
      persistEntrySettings({ ...state.entrySettings, ...target.entrySettings });
    }
    return target;
  } catch (switchError) {
    // Если новый профиль не поднялся — создаём новый socket обратно для старого.
    try {
      authService.resetConnection(origin.server, { clearSessionContext: true });
      if (origin.login && origin.sessionId && !origin.isLocalDemo) {
        const restored = await authService.resumeSession(origin.login, origin.sessionId);
        authService.setActiveSessionContext({
          login: restored?.login || origin.login,
          sessionId: restored?.sessionId || origin.sessionId,
        });
      } else if (origin.login) {
        authService.setActiveSessionContext({ login: origin.login, sessionId: origin.sessionId });
      }
    } catch (restoreError) {
      console.warn('[profiles] failed to restore previous profile connection after switch failure', restoreError);
    }
    throw switchError;
  }
}

async function closeSavedProfileSessionBestEffort(profile) {
  if (!profile || profile.isLocalDemo) return;
  const cleanSessionId = String(profile.sessionId || '').trim();
  if (!cleanSessionId) return;
  const normalized = normalizeProfileLogin(profile.login);
  const activeNormalized = normalizeProfileLogin(state.session.login);
  if (normalized === activeNormalized && state.session.isAuthorized) {
    try { await authService.closeSession(cleanSessionId); } catch {}
    return;
  }

  const origin = {
    login: String(state.session.login || '').trim(),
    sessionId: String(state.session.sessionId || '').trim(),
    isLocalDemo: Boolean(state.session.isLocalDemo),
    server: String(state.entrySettings.shineServer || DEFAULT_SHINE_SERVER).trim(),
  };
  const targetServer = String(profile?.entrySettings?.shineServer || state.entrySettings.shineServer || DEFAULT_SHINE_SERVER).trim();
  try {
    authService.resetConnection(targetServer, { clearSessionContext: true });
    await authService.resumeSession(profile.login, cleanSessionId);
    await authService.closeSession(cleanSessionId);
  } catch {
    // Закрытие профиля на устройстве не блокируем из-за недоступного сервера.
  } finally {
    try {
      authService.resetConnection(origin.server, { clearSessionContext: true });
      if (origin.login && origin.sessionId && !origin.isLocalDemo) {
        const restored = await authService.resumeSession(origin.login, origin.sessionId);
        authService.setActiveSessionContext({
          login: restored?.login || origin.login,
          sessionId: restored?.sessionId || origin.sessionId,
        });
      } else if (origin.login) {
        authService.setActiveSessionContext({ login: origin.login, sessionId: origin.sessionId });
      }
    } catch (error) {
      console.warn('[profiles] failed to restore active profile after closing another profile', error);
    }
  }
}

export async function closeSavedProfile(login) {
  const normalized = normalizeProfileLogin(login);
  const items = loadProfileStoreRaw();
  const index = items.findIndex((item) => normalizeProfileLogin(item.login) === normalized);
  if (index < 0) return { closed: false, nextProfile: null };
  const target = items[index];
  await closeSavedProfileSessionBestEffort(target);
  await clearStoredMessages(target.login).catch(() => {});

  const nextItems = items.filter((_, itemIndex) => itemIndex !== index);
  persistProfileStoreRaw(nextItems);
  const wasActive = normalized === getActiveProfileLoginRaw();
  if (!wasActive) return { closed: true, nextProfile: null };

  const next = nextItems[index] || nextItems[index - 1] || nextItems[0] || null;
  if (!next) {
    setActiveProfileLoginRaw('');
    clearStoredSession();
    authService.resetConnection(state.entrySettings.shineServer, { clearSessionContext: true });
    return { closed: true, nextProfile: null };
  }
  setActiveProfileLoginRaw(next.login);
  persistSession({ isAuthorized: true, isLocalDemo: Boolean(next.isLocalDemo), login: next.login, sessionId: next.sessionId });
  if (next.entrySettings && typeof next.entrySettings === 'object') {
    persistEntrySettings({ ...state.entrySettings, ...next.entrySettings });
  }
  return { closed: true, nextProfile: next };
}

export async function closeAllSavedProfiles() {
  const items = loadProfileStoreRaw();
  for (const item of items) {
    await clearStoredMessages(item.login).catch(() => {});
    if (item.isLocalDemo || !String(item.sessionId || '').trim()) continue;
    const targetServer = String(item?.entrySettings?.shineServer || state.entrySettings.shineServer || DEFAULT_SHINE_SERVER).trim();
    try {
      authService.resetConnection(targetServer, { clearSessionContext: true });
      await authService.resumeSession(item.login, item.sessionId);
      await authService.closeSession(item.sessionId);
    } catch {
      // Все локальные профили всё равно закрываем, даже если один сервер недоступен.
    }
  }
  persistProfileStoreRaw([]);
  setActiveProfileLoginRaw('');
  clearStoredSession();
  authService.close();
  authService.clearActiveSessionContext();
}

export function isAddingProfileLogin() {
  return state.session.isAuthorized && String(state.authReturnHash || '').trim() === '/profiles';
}

export async function prepareAddProfileLogin() {
  state.loginDraft.login = '';
  state.loginDraft.password = '';
  clearAuthMessages();
  // While an existing profile stays authorized, PRE_AUTH login pages are normally
  // blocked by app.js. This return target also acts as an explicit add-profile mode.
  state.authReturnHash = '/profiles';

  // Не пытаемся авторизовать второй login через уже authenticated socket.
  // Старую серверную сессию НЕ закрываем: закрываем только локальный transport.
  authService.resetConnection(state.entrySettings.shineServer, { clearSessionContext: true });
}

export async function cancelAddProfileLogin() {
  const wasAddingProfile = isAddingProfileLogin();
  const shouldRestoreActiveConnection = wasAddingProfile
    && state.session.isAuthorized
    && Boolean(String(state.session.login || '').trim())
    && Boolean(String(state.session.sessionId || '').trim());

  state.authReturnHash = '';
  state.loginDraft.login = '';
  state.loginDraft.password = '';
  resetRegistrationFlow();
  clearAuthMessages();

  if (shouldRestoreActiveConnection) {
    try {
      authService.resetConnection(state.entrySettings.shineServer, { clearSessionContext: true });
      await authService.resumeSession(state.session.login, state.session.sessionId);
      authService.setActiveSessionContext({ login: state.session.login, sessionId: state.session.sessionId });
    } catch (error) {
      console.warn('[profiles] failed to restore active profile connection after cancelling add-profile flow', error);
    }
  }
  return wasAddingProfile;
}

export function consumeAuthReturnPage(fallback = 'profile-view') {
  const nextHash = String(state.authReturnHash || '').trim();
  state.authReturnHash = '';
  if (nextHash.startsWith('/')) return nextHash.slice(1) || fallback;
  return fallback;
}

export function refreshRegistrationBalance() {
  const next = (0.005 + Math.random() * 0.03).toFixed(4);
  state.registrationPayment.balanceSOL = next;
  return next;
}

export function setChannelsFeed(feed, index) {
  state.channelsFeed = feed || null;
  state.channelsIndex = index || {};
}

export function getLocalChannelPosts(channelId) {
  if (!channelId) return [];
  if (!state.localChannelPosts[channelId]) {
    state.localChannelPosts[channelId] = [];
  }
  return state.localChannelPosts[channelId];
}

export function addLocalChannelPost(channelId, post) {
  if (!channelId) return;
  const text = post?.body?.trim();
  if (!text) return;

  getLocalChannelPosts(channelId).push({
    title: post.title || `${state.session.login || 'Вы'} • сейчас`,
    body: text,
  });
}

function makeMessageReactionKey(messageRef, login = state.session.login) {
  const bch = String(messageRef?.blockchainName || '').trim();
  const blockNumber = Number(messageRef?.blockNumber);
  const blockHash = String(messageRef?.blockHash || '').trim().toLowerCase();
  const cleanLogin = String(login || '').trim().toLowerCase();
  if (!cleanLogin || !bch || !Number.isFinite(blockNumber) || blockNumber < 0 || !blockHash) return '';
  return `${cleanLogin}|${bch}|${blockNumber}|${blockHash}`;
}

export function getMessageReactionState(messageRef) {
  const key = makeMessageReactionKey(messageRef);
  if (!key) return '';
  return state.messageReactions[key] || '';
}

export function setMessageReactionState(messageRef, nextState) {
  const key = makeMessageReactionKey(messageRef);
  if (!key) return;
  const normalized = String(nextState || '').trim().toLowerCase();
  if (normalized === 'liked' || normalized === 'unliked') {
    state.messageReactions[key] = normalized;
    persistStoredReactions(state.messageReactions);
    return;
  }
  delete state.messageReactions[key];
  persistStoredReactions(state.messageReactions);
}