export interface TeacherReply {
  reply: string;
  quickReplies: string[];
  parseError?: string;
}

// Resource limits, not writing instructions. Ordinary answers below the transport
// limit are preserved in full, including Markdown and long suggested questions.
export const MAX_TEACHER_REPLY_BYTES = 1024 * 1024;
export const MAX_TEACHER_QUICK_REPLIES = 128;
export const MAX_TEACHER_QUICK_REPLY_BYTES = 64 * 1024;
const INVALID_REPLY = '这次回复没有完整解析，请重试。';
const INVALID_FORMAT = '回复格式不完整或无效。';
const RESOURCE_LIMIT = '回复超过可处理的数据大小。';
const protocolKeys = new Set(['reply', 'quickReplies', 'intro', 'questions', 'tool']);
const own = (value: object, key: string) => Object.prototype.hasOwnProperty.call(value, key);

function withinBytes(value: string, max: number): boolean {
  return value.length <= max && new TextEncoder().encode(value).length <= max;
}

function stringEnd(raw: string, start: number): number | undefined {
  for (let index = start + 1; index < raw.length; index++) {
    if (raw[index] === '\\') { index++; continue; }
    if (raw[index] === '"') return index + 1;
  }
  return undefined;
}

/** Find one complete value without interpreting nested legacy tool data. */
function valueEnd(raw: string, start: number): number | undefined {
  if (raw[start] === '"') return stringEnd(raw, start);
  if (raw[start] !== '{' && raw[start] !== '[') {
    let end = start;
    while (end < raw.length && !/[,}\]\s]/.test(raw[end])) end++;
    return end > start ? end : undefined;
  }
  const stack = [raw[start]];
  for (let index = start + 1; index < raw.length; index++) {
    const character = raw[index];
    if (character === '"') {
      const end = stringEnd(raw, index);
      if (end === undefined) return undefined;
      index = end - 1;
    } else if (character === '{' || character === '[') stack.push(character);
    else if (character === '}' || character === ']') {
      if (stack.pop() !== (character === '}' ? '{' : '[')) return undefined;
      if (!stack.length) return index + 1;
    }
  }
  return undefined;
}

/** Recover only complete top-level fields; nested reply-looking data stays inert. */
function fields(raw: string): { values: Map<string, unknown>; keys: Set<string>; duplicate: boolean; toolStart?: number } {
  const values = new Map<string, unknown>(), keys = new Set<string>();
  let duplicate = false, index = raw.indexOf('{') + 1;
  let toolStart: number | undefined;
  const whitespace = () => { while (index < raw.length && /\s/.test(raw[index])) index++; };
  while (index > 0 && index < raw.length) {
    whitespace();
    if (raw[index] !== '"') break;
    const end = stringEnd(raw, index);
    if (end === undefined) break;
    let key: string;
    try { key = JSON.parse(raw.slice(index, end)); } catch { break; }
    index = end;
    whitespace();
    if (raw[index++] !== ':') break;
    duplicate ||= keys.has(key);
    keys.add(key);
    whitespace();
    if (key === 'tool') toolStart = index;
    const next = valueEnd(raw, index);
    if (next === undefined) break;
    if ((protocolKeys.has(key) || key === 'kind') && key !== 'tool' && !values.has(key)) {
      try { values.set(key, JSON.parse(raw.slice(index, next))); } catch { break; }
    }
    index = next;
    whitespace();
    if (raw[index++] !== ',') break;
  }
  return { values, keys, duplicate, toolStart };
}

interface Candidate { start: number; end: number; content: string; incomplete?: boolean }
function isEnvelope(raw: string): boolean {
  const scanned = fields(raw);
  if (scanned.keys.has('reply') || scanned.keys.has('quickReplies')
    || (scanned.keys.has('intro') && scanned.keys.has('questions'))) return true;
  // "questions" and "tool" also occur in ordinary API/code examples. A tool
  // alone identifies the retired reply protocol only through its legacy kind.
  if (scanned.toolStart !== undefined && raw[scanned.toolStart] === '{') {
    const kind = fields(raw.slice(scanned.toolStart)).values.get('kind');
    if (typeof kind === 'string' && ['ideas', 'structure', 'flow', 'comparison'].includes(kind)) return true;
  }
  return /^\{\s*(?:reply|quickReplies)\s*:/.test(raw);
}

/** Markdown examples stay prose unless a top-level reply envelope identifies them. */
function candidates(raw: string): Candidate[] {
  const result: Candidate[] = [];
  const inspectText = (start: number, end: number) => {
    for (let index = start; index < end; index++) {
      if (raw[index] === '`') {
        let fenceEnd = index + 1;
        while (raw[fenceEnd] === '`') fenceEnd++;
        const close = raw.indexOf(raw.slice(index, fenceEnd), fenceEnd);
        index = close >= 0 && close < end ? close + fenceEnd - index - 1 : end;
      } else if (raw[index] === '[') {
        const endOfArray = valueEnd(raw, index);
        if (endOfArray !== undefined && endOfArray <= end) {
          try {
            if (Array.isArray(JSON.parse(raw.slice(index, endOfArray)))) index = endOfArray - 1;
          } catch { /* A Markdown link is not a JSON array. */ }
        }
      } else if (raw[index] === '{') {
        const objectEnd = valueEnd(raw, index);
        const stop = objectEnd !== undefined && objectEnd <= end ? objectEnd : end;
        const content = raw.slice(index, stop);
        if (isEnvelope(content)) result.push({ start: index, end: stop, content });
        index = stop - 1;
      }
    }
  };
  const opening = /(?:^|\n)[ \t]*(`{3,}|~{3,})([^\r\n]*)\r?\n/g;
  let processed = 0, match: RegExpExecArray | null;
  while ((match = opening.exec(raw))) {
    inspectText(processed, match.index);
    const bodyStart = opening.lastIndex;
    const marker = match[1][0], size = match[1].length;
    const closing = new RegExp('(?:^|\\n)[ \\t]*' + marker + '{' + size + ',}[ \\t]*(?=\\r?\\n|$)', 'g');
    closing.lastIndex = bodyStart;
    const close = closing.exec(raw);
    const body = raw.slice(bodyStart, close?.index ?? raw.length).trim();
    const language = match[2].trim().toLowerCase();
    const explicit = ['makelore-teacher', 'makelore-teacher-reply', 'makelore-teacher-discussion'].includes(language);
    if (explicit || ((language === 'json' || language === '') && body.startsWith('{') && isEnvelope(body))) {
      result.push({ start: match.index, end: close ? closing.lastIndex : raw.length, content: body, incomplete: !close });
    }
    processed = close ? closing.lastIndex : raw.length;
    opening.lastIndex = processed;
  }
  inspectText(processed, raw.length);
  return result;
}

function projectReply(envelope: Record<string, unknown>): TeacherReply {
  const reply = own(envelope, 'reply') ? envelope.reply : envelope.intro;
  const suggestions = own(envelope, 'quickReplies') ? envelope.quickReplies : envelope.questions;
  let parseError: string | undefined;
  let quickReplies: string[] = [];
  if (suggestions !== undefined) {
    if (!Array.isArray(suggestions) || suggestions.some(item => typeof item !== 'string' || !item.trim())) {
      parseError = INVALID_FORMAT;
    } else if (suggestions.length > MAX_TEACHER_QUICK_REPLIES
      || suggestions.some(item => !withinBytes(item, MAX_TEACHER_QUICK_REPLY_BYTES))) {
      parseError = RESOURCE_LIMIT;
    } else quickReplies = suggestions;
  }
  if (typeof reply !== 'string' || (!reply.trim() && !quickReplies.length)) {
    return { reply: INVALID_REPLY, quickReplies, parseError: INVALID_FORMAT };
  }
  return { reply, quickReplies, ...(parseError ? { parseError } : {}) };
}

/** Only text and suggested replies survive; legacy tool payloads are never restored. */
export function parseTeacherReply(raw: string): TeacherReply {
  if (!withinBytes(raw, MAX_TEACHER_REPLY_BYTES)) {
    return { reply: INVALID_REPLY, quickReplies: [], parseError: RESOURCE_LIMIT };
  }
  const text = raw.trim();
  if (!text) return { reply: INVALID_REPLY, quickReplies: [], parseError: INVALID_FORMAT };
  const found = candidates(text);
  if (!found.length) return { reply: text, quickReplies: [] };
  const candidate = found[0];
  let result: TeacherReply;
  const recovered = fields(candidate.content);
  try {
    const envelope: unknown = JSON.parse(candidate.content);
    if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)) throw new Error();
    result = projectReply(envelope as Record<string, unknown>);
  } catch {
    result = projectReply(Object.fromEntries(recovered.values));
    result.parseError = INVALID_FORMAT;
  }
  if (candidate.incomplete || recovered.duplicate || found.length > 1) result.parseError = INVALID_FORMAT;
  // Multiple envelopes are ambiguous; never append their JSON as visible prose.
  if (found.length === 1) {
    const suffix = text.slice(candidate.end).trim();
    const brokenTail = /^[,\s]*"(?:reply|quickReplies|intro|questions|tool)"\s*:/.test(suffix)
      || (suffix.length > 0 && /^[}\],\s]+$/.test(suffix));
    if (brokenTail) result.parseError = INVALID_FORMAT;
    result.reply = [text.slice(0, candidate.start).trim(), result.reply, brokenTail ? '' : suffix]
      .filter(part => part.length > 0).join('\n\n');
  }
  return result;
}