import type {
  ChatImageAttachment,
  ChatTimelineItem,
  ChatTimelineMessageItem,
} from '@easyflow/common-ui';
import { ChatTimelineBuilder } from '@easyflow/common-ui';
import { useUserStore } from '@easyflow/stores';

import {
  onAgentChatCacheClear,
  resolveAgentChatIdentity,
  RUNTIME_STORAGE_PREFIX,
} from '#/utils/agent-chat-cache';

import type { AgentChatCapabilityPayload } from './api';
import {
  generateAgentSessionId,
  sendAgentChat,
  stopAgentChatStream,
} from './api';

import {
  applyAgentSseEnvelope,
  parseAgentSseMessage,
} from './adapters/agentTimelineAdapter';

interface RuntimeSessionState {
  agentId: string;
  agentName?: string;
  completed: boolean;
  error?: string;
  identity: string;
  items: ChatTimelineItem[];
  prompt: string;
  roundId: string;
  sending: boolean;
  sessionId: string;
  updatedAt: number;
}

interface StoredRuntimeSession {
  agentId: string;
  agentName?: string;
  completed: boolean;
  error?: string;
  items: ChatTimelineItem[];
  prompt: string;
  roundId: string;
  sessionId: string;
  updatedAt: number;
  version: number;
}

interface StartOptions {
  agentId: string;
  agentName?: string;
  baseItems?: ChatTimelineItem[];
  capabilities?: AgentChatCapabilityPayload[];
  imageUploadIds?: string[];
  images?: ChatImageAttachment[];
  onInputAccepted?: () => void | Promise<void>;
  prompt: string;
  sessionId?: string;
}

const STORAGE_VERSION = 2;
const STREAM_NOTIFY_INTERVAL_MS = 50;
const STREAM_PERSIST_INTERVAL_MS = 300;
const MAX_RUNTIME_SESSIONS_PER_IDENTITY = 10;

const sessions = new Map<string, RuntimeSessionState>();
const listeners = new Set<() => void>();
const latestSessionIds = new Map<string, string>();
const persistTimers = new Map<string, ReturnType<typeof setTimeout>>();
let notifyTimer: ReturnType<typeof setTimeout> | undefined;

function clone<T>(value: T): T {
  const serialized = JSON.stringify(value);
  return JSON.parse(serialized) as T;
}

function createRoundId() {
  return `agent-chat-round-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
}

function identityScope() {
  return resolveAgentChatIdentity(useUserStore().userInfo);
}

function sessionKey(identity: string, sessionId: string) {
  return `${identity}:${sessionId}`;
}

function storageKey(identity: string, sessionId: string) {
  return `${RUNTIME_STORAGE_PREFIX}:${identity}:${sessionId}`;
}

function latestStorageKey(identity: string) {
  return `${RUNTIME_STORAGE_PREFIX}:${identity}:latest`;
}

function safeSessionStorage() {
  try {
    return globalThis.sessionStorage;
  } catch {
    return undefined;
  }
}

function notify() {
  for (const listener of listeners) {
    listener();
  }
}

function notifyNow() {
  if (notifyTimer) {
    clearTimeout(notifyTimer);
    notifyTimer = undefined;
  }
  notify();
}

function scheduleNotify() {
  if (notifyTimer || listeners.size === 0) {
    return;
  }
  notifyTimer = setTimeout(() => {
    notifyTimer = undefined;
    notify();
  }, STREAM_NOTIFY_INTERVAL_MS);
}

function persistSession(state: RuntimeSessionState) {
  const storage = safeSessionStorage();
  if (!storage) {
    return;
  }
  const snapshot: StoredRuntimeSession = {
    agentId: state.agentId,
    agentName: state.agentName,
    completed: state.completed,
    error: state.error,
    items: state.items,
    prompt: state.prompt,
    roundId: state.roundId,
    sessionId: state.sessionId,
    updatedAt: state.updatedAt,
    version: STORAGE_VERSION,
  };
  try {
    storage.setItem(
      storageKey(state.identity, state.sessionId),
      JSON.stringify(snapshot),
    );
    storage.setItem(latestStorageKey(state.identity), state.sessionId);
  } catch {
    // 缓存失败不影响正式聊天主流程。
  }
}

function cancelPersistTimer(scopedSessionKey: string) {
  const timer = persistTimers.get(scopedSessionKey);
  if (!timer) {
    return;
  }
  clearTimeout(timer);
  persistTimers.delete(scopedSessionKey);
}

function removeSessionCache(
  scopedSessionKey: string,
  state: RuntimeSessionState,
) {
  cancelPersistTimer(scopedSessionKey);
  sessions.delete(scopedSessionKey);
  try {
    safeSessionStorage()?.removeItem(
      storageKey(state.identity, state.sessionId),
    );
  } catch {
    // 本地缓存清理失败不影响服务端会话。
  }
}

function pruneRuntimeSessions(identity: string, currentSessionId: string) {
  const scopedSessions = [...sessions.entries()]
    .filter(([, session]) => session.identity === identity)
    .sort((first, second) => second[1].updatedAt - first[1].updatedAt);
  if (scopedSessions.length <= MAX_RUNTIME_SESSIONS_PER_IDENTITY) {
    return;
  }
  const protectedKeys = new Set(
    scopedSessions
      .filter(
        ([, session]) =>
          session.sending || session.sessionId === currentSessionId,
      )
      .map(([key]) => key),
  );
  let retainedCount = protectedKeys.size;
  for (const [key, session] of scopedSessions) {
    if (protectedKeys.has(key)) {
      continue;
    }
    if (retainedCount < MAX_RUNTIME_SESSIONS_PER_IDENTITY) {
      retainedCount += 1;
      continue;
    }
    removeSessionCache(key, session);
  }
}

function touchState(state: RuntimeSessionState) {
  state.updatedAt = Date.now();
  latestSessionIds.set(state.identity, state.sessionId);
  sessions.set(sessionKey(state.identity, state.sessionId), state);
}

function scheduleStateUpdate(state: RuntimeSessionState) {
  touchState(state);
  const scopedSessionKey = sessionKey(state.identity, state.sessionId);
  if (!persistTimers.has(scopedSessionKey)) {
    persistTimers.set(
      scopedSessionKey,
      setTimeout(() => {
        persistTimers.delete(scopedSessionKey);
        const current = sessions.get(scopedSessionKey);
        if (current) {
          persistSession(current);
        }
      }, STREAM_PERSIST_INTERVAL_MS),
    );
  }
  scheduleNotify();
}

function restoreSession(identity: string, sessionId: string) {
  if (!identity) {
    return undefined;
  }
  const scopedSessionKey = sessionKey(identity, sessionId);
  const existing = sessions.get(scopedSessionKey);
  if (existing) {
    return existing;
  }
  const storage = safeSessionStorage();
  if (!storage) {
    return undefined;
  }
  try {
    const raw = storage.getItem(storageKey(identity, sessionId));
    if (!raw) {
      return undefined;
    }
    const parsed = JSON.parse(raw) as StoredRuntimeSession;
    if (parsed.version !== STORAGE_VERSION || parsed.sessionId !== sessionId) {
      return undefined;
    }
    const restored: RuntimeSessionState = {
      agentId: parsed.agentId,
      agentName: parsed.agentName,
      completed: parsed.completed,
      error: parsed.error,
      identity,
      items: Array.isArray(parsed.items) ? parsed.items : [],
      prompt: parsed.prompt,
      roundId: parsed.roundId,
      sending: false,
      sessionId,
      updatedAt: parsed.updatedAt,
    };
    sessions.set(scopedSessionKey, restored);
    return restored;
  } catch {
    return undefined;
  }
}

function upsertState(state: RuntimeSessionState) {
  touchState(state);
  cancelPersistTimer(sessionKey(state.identity, state.sessionId));
  persistSession(state);
  pruneRuntimeSessions(state.identity, state.sessionId);
  notifyNow();
}

function runningSession(identity = identityScope()) {
  return [...sessions.values()].find(
    (session) => session.identity === identity && session.sending,
  );
}

function restoreLatestSession(identity = identityScope()) {
  if (!identity) {
    return undefined;
  }
  const running = runningSession(identity);
  if (running) {
    return running;
  }
  const storage = safeSessionStorage();
  const storedSessionId = storage?.getItem(latestStorageKey(identity)) || '';
  const sessionId = latestSessionIds.get(identity) || storedSessionId;
  return sessionId ? restoreSession(identity, sessionId) : undefined;
}

async function resolveSessionId(sessionId?: string) {
  if (sessionId) {
    return sessionId;
  }
  const res = await generateAgentSessionId();
  if (res.errorCode !== 0 || !res.data) {
    throw new Error(res.message || '会话创建失败');
  }
  return String(res.data);
}

function errorMessage(error: unknown) {
  return error instanceof Error ? error.message : '发送失败，请稍后再试';
}

function normalizeAcceptedImages(payload: Record<string, any>) {
  if (!Array.isArray(payload.images)) {
    return [];
  }
  return payload.images
    .map((value): ChatImageAttachment | undefined => {
      if (!value || typeof value !== 'object' || Array.isArray(value)) {
        return undefined;
      }
      const image = value as Record<string, any>;
      const previewUrl = String(image.previewUrl || '');
      if (!previewUrl) {
        return undefined;
      }
      return {
        height: Number(image.height || 0) || undefined,
        imageRef: String(image.imageRef || ''),
        mimeType: String(image.mimeType || ''),
        name: String(image.name || '图片'),
        previewUrl,
        size: Number(image.size || 0) || undefined,
        status: 'ready',
        width: Number(image.width || 0) || undefined,
      };
    })
    .filter((image): image is ChatImageAttachment => Boolean(image));
}

function replaceAcceptedImages(
  items: ChatTimelineItem[],
  roundId: string,
  payload: Record<string, any>,
) {
  const acceptedImages = normalizeAcceptedImages(payload);
  if (acceptedImages.length === 0) {
    return;
  }
  const userMessage = items.find(
    (item): item is ChatTimelineMessageItem =>
      item.type === 'message' &&
      item.role === 'user' &&
      item.roundId === roundId,
  );
  if (userMessage) {
    userMessage.images = acceptedImages;
  }
}

onAgentChatCacheClear((identity) => {
  for (const [key, session] of sessions) {
    if (session.identity === identity) {
      cancelPersistTimer(key);
      sessions.delete(key);
    }
  }
  latestSessionIds.delete(identity);
  notifyNow();
});

export const agentChatRuntimeManager = {
  getSnapshot(sessionId?: string) {
    if (!sessionId) {
      return undefined;
    }
    const state = restoreSession(identityScope(), sessionId);
    return state ? clone(state) : undefined;
  },

  getLatestSnapshot() {
    const state = restoreLatestSession();
    return state ? clone(state) : undefined;
  },

  hasRunning() {
    return Boolean(runningSession());
  },

  replaceItems(sessionId: string, items: ChatTimelineItem[]) {
    const state = restoreSession(identityScope(), sessionId);
    if (!state) {
      return;
    }
    state.items = clone(items);
    upsertState(state);
  },

  async start(options: StartOptions) {
    const identity = identityScope();
    if (!identity) {
      throw new Error('当前登录状态失效');
    }
    const active = runningSession(identity);
    if (active) {
      throw new Error('当前回复完成后再发送新消息');
    }
    const sessionId = await resolveSessionId(options.sessionId);
    const roundId = createRoundId();
    const state: RuntimeSessionState = {
      agentId: options.agentId,
      agentName: options.agentName,
      completed: false,
      identity,
      items: clone(options.baseItems || []),
      prompt: options.prompt,
      roundId,
      sending: true,
      sessionId,
      updatedAt: Date.now(),
    };
    ChatTimelineBuilder.appendUserMessage(state.items, options.prompt, {
      images: options.images,
      roundId,
    });
    upsertState(state);

    void sendAgentChat(
      {
        agentId: options.agentId,
        capabilities: options.capabilities,
        imageUploadIds: options.imageUploadIds,
        prompt: options.prompt,
        sessionId,
      },
      {
        onError(error) {
          const current = sessions.get(sessionKey(identity, sessionId));
          if (!current || !current.sending) {
            return;
          }
          current.error = errorMessage(error);
          current.sending = false;
          current.completed = true;
          ChatTimelineBuilder.appendError(current.items, current.error);
          ChatTimelineBuilder.finalize(current.items);
          upsertState(current);
        },
        onFinished() {
          const current = sessions.get(sessionKey(identity, sessionId));
          if (!current) {
            return;
          }
          current.sending = false;
          current.completed = true;
          ChatTimelineBuilder.finalize(current.items);
          upsertState(current);
        },
        onMessage(message) {
          const current = sessions.get(sessionKey(identity, sessionId));
          if (!current || !current.sending) {
            return;
          }
          const envelope = parseAgentSseMessage(message);
          if (!envelope) {
            return;
          }
          if (
            envelope.domain === 'SYSTEM' &&
            envelope.type === 'INPUT_ACCEPTED'
          ) {
            replaceAcceptedImages(current.items, roundId, envelope.payload);
            void options.onInputAccepted?.();
          }
          applyAgentSseEnvelope(current.items, envelope, { roundId });
          scheduleStateUpdate(current);
        },
      },
    );

    return sessionId;
  },

  stop(sessionId?: string) {
    const identity = identityScope();
    const state = sessionId
      ? restoreSession(identity, sessionId)
      : runningSession(identity);
    if (!state || !state.sending) {
      return;
    }
    stopAgentChatStream();
    state.sending = false;
    state.completed = true;
    ChatTimelineBuilder.finalize(state.items);
    upsertState(state);
  },

  subscribe(listener: () => void) {
    listeners.add(listener);
    return () => {
      listeners.delete(listener);
    };
  },
};