// @vitest-environment node
import { describe, expect, it } from 'vitest';
import {
  applyDiscussionReply,
  discussionInstructions,
  editDiscussion,
  validateDiscussionContext,
} from '../../electron/coding-teacher/discussion';
import type {
  TeacherDefinition,
  TeacherDiscussionAction,
  TeacherDiscussionContext,
  TeacherRequest,
  TeacherTopic,
} from '../../shared/coding-teacher';
import type { TeacherDiscussion, TeacherDiscussionContent } from '../../shared/teacher-discussion';

const definition: TeacherDefinition = {
  schema_version: 1, teacher_id: 'coding-teacher', name: '老师', description: '', avatar_id: 'avatar-01',
  welcome_message: '一起想一想', suggested_questions: [], system_prompt: '帮助孩子理解自己的想法。',
  skills: [], model: { model_id: 'model', reasoning_choice: { mode: 'default' } },
  limits: { max_input_tokens: 8000, max_output_tokens: 1500 },
};
const ideas: Extract<TeacherDiscussionContent, { kind: 'ideas' }> = {
  kind: 'ideas', title: '小狗游戏', items: [
    { id: 'dog', text: '养一只自己的小狗', state: 'kept' },
    { id: 'breed', text: '柯基', parentId: 'dog', state: 'kept' },
    { id: 'adventure', text: '带它去冒险', state: 'suggested' },
  ], firstItemId: 'dog',
};
const structure: Extract<TeacherDiscussionContent, { kind: 'structure' }> = {
  kind: 'structure', title: '这些想法的关系', nodes: [
    { id: 'dog', label: '自己的小狗' },
    { id: 'breed', label: '柯基', parentId: 'dog', relation: '品种' },
  ],
};
const flow: Extract<TeacherDiscussionContent, { kind: 'flow' }> = {
  kind: 'flow', title: '回家时的回应', nodes: [
    { id: 'door', label: '打开门', kind: 'event' },
    { id: 'awake', label: '醒着吗', kind: 'condition' },
    { id: 'sleep', label: '继续睡', kind: 'outcome' },
  ], edges: [{ id: 'start', from: 'door', to: 'awake' }, { id: 'no', from: 'awake', to: 'sleep', label: '睡着' }],
};
const comparison: Extract<TeacherDiscussionContent, { kind: 'comparison' }> = {
  kind: 'comparison', title: '两种提示',
  columns: [{ id: 'direct', label: '直接说' }, { id: 'hint', label: '给线索' }],
  rows: [{ id: 'new', label: '新玩家', cells: [{ columnId: 'direct', text: '马上知道做什么' }, { columnId: 'hint', text: '还需要判断' }] }],
};

function topic(content?: TeacherDiscussionContent, status: TeacherDiscussion['status'] = 'active'): TeacherTopic {
  return {
    schemaVersion: 1, revision: 1, id: 'topic', accountId: 'account', projectId: 'project',
    sourceConversationId: 'source', version: 1, definition, createdAt: 'now', updatedAt: 'now', requests: [],
    ...(content ? { discussion: { id: 'tool-1', revision: 7, status, content: structuredClone(content) } } : {}),
  };
}

function request(owner: TeacherTopic, context?: TeacherDiscussionContext): TeacherRequest {
  const value: TeacherRequest = {
    id: 'request-' + owner.requests.length, text: '我的补充', references: [], createdAt: 'now',
    sourceCursor: { workerGeneration: 1, seq: 1 }, sourceCapturedAt: 'now', includedSourceMessageIds: [],
    omittedMessages: 0, status: 'running', response: '', presentation: 'discussion-v1',
    ...(context ? { discussionContext: structuredClone(context) } : {}),
  };
  owner.requests.push(value);
  return value;
}

function context(owner: TeacherTopic, extra: Partial<TeacherDiscussionContext> = {}): TeacherDiscussionContext {
  return { toolId: owner.discussion!.id, revision: owner.discussion!.revision, ...extra };
}

function act(owner: TeacherTopic, action: TeacherDiscussionAction['action'], itemId?: string): void {
  editDiscussion(owner, { ...context(owner), action, ...(itemId ? { itemId } : {}) });
}

function reply(content?: TeacherDiscussionContent | null, text = '我把你的想法接上了。'): string {
  return JSON.stringify({ reply: text, quickReplies: ['接着说'], ...(content === undefined ? {} : { tool: content }) });
}

describe('teacher discussion lifecycle', () => {
  it('offers a new component without activating it and keeps an independent history snapshot', () => {
    const owner = topic();
    const turn = request(owner);
    applyDiscussionReply(owner, turn, reply(ideas));
    expect(owner.discussion).toMatchObject({ revision: 1, status: 'offered', content: ideas });
    expect(owner.discussion?.id).toMatch(/^[0-9a-f-]{36}$/);
    expect(turn.response).toBe('我把你的想法接上了。');
    expect(turn.suggestedQuestions).toEqual(['接着说']);
    expect(turn.discussionSnapshot).toEqual(ideas);
    expect(turn.discussionSnapshot).not.toBe(owner.discussion?.content);
    act(owner, 'enter');
    act(owner, 'aside-idea', 'breed');
    expect(turn.discussionSnapshot).toEqual(ideas);
  });

  it('enters, pauses, resumes, finishes and reopens the same component without losing content', () => {
    const owner = topic(ideas, 'offered');
    const original = structuredClone(owner.discussion!);
    for (const [action, status] of [
      ['enter', 'active'], ['pause', 'paused'], ['resume', 'active'], ['finish', 'finished'], ['resume', 'active'],
    ] as const) {
      const priorRevision = owner.discussion!.revision;
      act(owner, action);
      expect(owner.discussion).toEqual({ ...original, status, revision: priorRevision + 1 });
    }
    expect(owner.requests).toEqual([]);
  });

  it('allows a first offer to be declined while retaining it for later use', () => {
    const owner = topic(flow, 'offered');
    act(owner, 'pause');
    expect(owner.discussion).toMatchObject({ id: 'tool-1', status: 'paused', content: flow });
    act(owner, 'resume');
    expect(owner.discussion).toMatchObject({ id: 'tool-1', status: 'active', content: flow });
  });

  it('keeps and shelves ideas explicitly and removes a shelved first-item marker', () => {
    const owner = topic(ideas);
    act(owner, 'keep-idea', 'adventure');
    act(owner, 'first-idea', 'adventure');
    expect(owner.discussion!.content).toMatchObject({ firstItemId: 'adventure' });
    act(owner, 'aside-idea', 'adventure');
    expect(owner.discussion!.content).not.toHaveProperty('firstItemId');
    expect(owner.discussion!.content).toMatchObject({ items: [ideas.items[0], ideas.items[1], { ...ideas.items[2], state: 'aside' }] });
    const before = structuredClone(owner.discussion);
    expect(() => act(owner, 'first-idea', 'adventure')).toThrowError();
    expect(owner.discussion).toEqual(before);
  });

  it.each(['enter', 'pause', 'finish', 'resume', 'keep-idea', 'aside-idea', 'first-idea', 'back-ideas'] as const)(
    'rejects stale %s actions without mutating the current component', action => {
      const owner = topic(ideas);
      const before = structuredClone(owner);
      expect(() => editDiscussion(owner, { toolId: 'tool-1', revision: 6, action, itemId: 'dog' }))
        .toThrowError(expect.objectContaining({ code: 'teacher_discussion_changed', status: 409 }));
      expect(owner).toEqual(before);
    }
  );

  it('rejects actions against another tool or a missing item without a partial edit', () => {
    const owner = topic(ideas);
    const before = structuredClone(owner);
    expect(() => editDiscussion(owner, { toolId: 'other', revision: 7, action: 'pause' })).toThrowError();
    expect(() => act(owner, 'keep-idea', 'missing')).toThrowError();
    expect(() => act(owner, 'back-ideas')).toThrowError();
    expect(owner).toEqual(before);
  });
});

describe('discussion request context and focus', () => {
  it('permits ordinary chat without context even when a component exists', () => {
    expect(validateDiscussionContext(topic(flow))).toBeUndefined();
  });

  it.each([
    [ideas, 'breed'], [structure, 'breed'], [flow, 'sleep'], [comparison, 'new:hint'],
  ] as const)('validates a stable focus id inside $0.kind', (content, focusId) => {
    const owner = topic(content);
    const expected = context(owner, { focusId });
    expect(validateDiscussionContext(owner, { ...expected, clientOnly: 'drop me' } as TeacherDiscussionContext)).toEqual(expected);
    expect(() => validateDiscussionContext(owner, context(owner, { focusId: 'missing' })))
      .toThrowError(expect.objectContaining({ code: 'teacher_discussion_changed' }));
  });

  it.each(['offered', 'paused', 'finished'] as const)('rejects tool-maintenance context while %s', status => {
    const owner = topic(flow, status);
    expect(() => validateDiscussionContext(owner, context(owner))).toThrowError();
  });

  it('rejects stale revisions, foreign identities, invalid types and non-cell comparison focus', () => {
    const owner = topic(comparison);
    for (const input of [
      context(owner, { revision: 6 }), context(owner, { toolId: 'other' }),
      context(owner, { revision: 1.5 }), context(owner, { focusId: 'new' }),
      { ...context(owner), focusId: 3 }, { ...context(owner), transition: 'flow' },
    ]) {
      expect(() => validateDiscussionContext(owner, input as TeacherDiscussionContext)).toThrowError();
    }
    const withFlow = topic(flow);
    expect(() => validateDiscussionContext(withFlow, context(withFlow, { focusId: 'no' }))).toThrowError();
  });

  it('allows an explicit structure transition only from active ideas', () => {
    const owner = topic(ideas);
    const transition = context(owner, { transition: 'structure' });
    expect(validateDiscussionContext(owner, transition)).toEqual(transition);
    for (const content of [structure, flow, comparison]) {
      const other = topic(content);
      expect(() => validateDiscussionContext(other, context(other, { transition: 'structure' }))).toThrowError();
    }
  });
});

describe('applying completed teacher replies', () => {
  it('updates the same active component and preserves all earlier turn snapshots', () => {
    const owner = topic(flow);
    const oldTurn = request(owner);
    oldTurn.status = 'completed';
    oldTurn.discussionSnapshot = structuredClone(flow);
    const turn = request(owner, context(owner, { focusId: 'sleep' }));
    const updated = structuredClone(flow);
    updated.nodes[2].label = '动动耳朵，继续睡';
    applyDiscussionReply(owner, turn, reply(updated));
    expect(owner.discussion).toEqual({ id: 'tool-1', revision: 8, status: 'active', content: updated });
    expect(turn.discussionSnapshot).toEqual(updated);
    expect(oldTurn.discussionSnapshot).toEqual(flow);
    expect(turn.discussionSnapshot).not.toBe(owner.discussion!.content);
    updated.nodes[2].label = '改变调用方数据';
    expect(turn.discussionSnapshot).toEqual(owner.discussion!.content);
  });

  it.each([ideas, structure, comparison])('rejects changing an active flow into $kind', content => {
    const owner = topic(flow);
    const before = structuredClone(owner.discussion);
    const turn = request(owner, context(owner));
    applyDiscussionReply(owner, turn, reply(content));
    expect(owner.discussion).toEqual(before);
    expect(turn.discussionError).toBeTruthy();
    expect(turn.response).toBe('我把你的想法接上了。');
    expect(turn.discussionSnapshot).toBeUndefined();
  });

  it('requires an explicit ideas-to-structure transition and preserves both directions for later discussion', () => {
    const owner = topic(ideas);
    const unconfirmed = request(owner, context(owner));
    applyDiscussionReply(owner, unconfirmed, reply(structure));
    expect(owner.discussion!.content).toEqual(ideas);
    expect(unconfirmed.discussionError).toBeTruthy();
    const transitionContext = validateDiscussionContext(owner, context(owner, { transition: 'structure' }));
    const converted = request(owner, transitionContext);
    applyDiscussionReply(owner, converted, reply(structure));
    expect(owner.discussion).toMatchObject({ id: 'tool-1', revision: 8, status: 'active', content: structure, previousIdeas: ideas });
    const expanded = structuredClone(structure);
    expanded.nodes.push({ id: 'personality', label: '胆小但好奇', relation: '性格', parentId: 'dog' });
    const supplement = request(owner, context(owner));
    applyDiscussionReply(owner, supplement, reply(expanded));
    act(owner, 'back-ideas');
    expect(owner.discussion).toMatchObject({ id: 'tool-1', revision: 10, status: 'active', content: ideas, previousStructure: expanded });
    const nextContext = context(owner, { transition: 'structure' });
    const instructions = discussionInstructions(owner, nextContext);
    expect(JSON.parse(instructions.split('\n').at(-1)!)).toMatchObject({ previousStructure: expanded });
    act(owner, 'aside-idea', 'breed');
    expect(owner.discussion!.previousIdeas).toEqual(ideas);
    expect(owner.discussion!.previousStructure).toEqual(expanded);
    expect(converted.discussionSnapshot).toEqual(structure);
    expect(supplement.discussionSnapshot).toEqual(expanded);
  });

  it.each(['active', 'offered', 'paused', 'finished'] as const)('does not modify a %s component during ordinary chat', status => {
    const owner = topic(flow, status);
    const before = structuredClone(owner.discussion);
    const turn = request(owner);
    applyDiscussionReply(owner, turn, reply(ideas, '我们先聊这个想法。'));
    expect(owner.discussion).toEqual(before);
    expect(turn.response).toBe('我们先聊这个想法。');
    expect(turn.discussionSnapshot).toBeUndefined();
  });

  it('ignores a late reply after revision/status changed while retaining its readable response', () => {
    const owner = topic(flow);
    const turn = request(owner, context(owner));
    act(owner, 'pause');
    const before = structuredClone(owner.discussion);
    const update = structuredClone(flow);
    update.nodes[2].label = '轻轻摇尾巴';
    applyDiscussionReply(owner, turn, reply(update));
    expect(owner.discussion).toEqual(before);
    expect(turn.response).toBe('我把你的想法接上了。');
    expect(turn.discussionSnapshot).toBeUndefined();
    act(owner, 'resume');
    const resumed = structuredClone(owner.discussion);
    const stillStale = request(owner, turn.discussionContext);
    applyDiscussionReply(owner, stillStale, reply(update));
    expect(owner.discussion).toEqual(resumed);
  });

  it.each([null, undefined, flow])('keeps revision and snapshots unchanged when there is no component change: %s', content => {
    const owner = topic(flow);
    const before = structuredClone(owner.discussion);
    const turn = request(owner, context(owner));
    applyDiscussionReply(owner, turn, reply(content, '同一个动作，在不同情况下可以有不同反应。'));
    expect(owner.discussion).toEqual(before);
    expect(turn.response).toBe('同一个动作，在不同情况下可以有不同反应。');
    expect(turn.discussionSnapshot).toBeUndefined();
    expect(turn.discussionError).toBeUndefined();
  });

  it.each([
    JSON.stringify({ reply: '你的补充收到啦。', tool: { ...flow, edges: [{ id: 'bad', from: 'door', to: 'missing' }] } }),
    '{"reply":"你的补充收到啦。","tool":{"kind":"flow",',
  ])('keeps the old component and historical snapshot when a model update is invalid', raw => {
    const owner = topic(flow);
    const oldTurn = request(owner);
    oldTurn.status = 'completed';
    oldTurn.discussionSnapshot = structuredClone(flow);
    const before = structuredClone(owner.discussion);
    const turn = request(owner, context(owner));
    applyDiscussionReply(owner, turn, raw);
    expect(owner.discussion).toEqual(before);
    expect(oldTurn.discussionSnapshot).toEqual(flow);
    expect(turn.response).toBe('你的补充收到啦。');
    expect(turn.discussionError).toBeTruthy();
    expect(turn.discussionSnapshot).toBeUndefined();
  });

  it('keeps legacy text as a normal answer without creating a component', () => {
    const owner = topic();
    const turn = request(owner);
    applyDiscussionReply(owner, turn, '先听听朋友玩的时候怎么想。');
    expect(turn.response).toBe('先听听朋友玩的时候怎么想。');
    expect(owner.discussion).toBeUndefined();
    expect(turn.discussionSnapshot).toBeUndefined();
  });
});