import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  console.log('=== MySQL CRUD 测试 ===\n');

  const user = await prisma.user.create({
    data: {
      email: 'test-crud@zhixi.com',
      nickname: 'CRUD测试用户',
      status: 'active',
    },
  });
  console.log(`✅ INSERT user: id=${user.id}, email=${user.email}, nickname=${user.nickname}`);

  const profile = await prisma.userProfile.create({
    data: {
      userId: user.id,
      learningIdentity: '知识工作者',
      learningDirection: '产品设计',
    },
  });
  console.log(`✅ INSERT profile: userId=${profile.userId}, direction=${profile.learningDirection}`);

  const kb = await prisma.knowledgeBase.create({
    data: { userId: user.id, title: '测试知识库', description: 'CRUD测试' },
  });
  console.log(`✅ INSERT knowledgeBase: id=${kb.id}, title=${kb.title}`);

  const item = await prisma.knowledgeItem.create({
    data: {
      userId: user.id,
      knowledgeBaseId: kb.id,
      itemType: 'lesson',
      title: '测试知识点-数据结构入门',
      content: '## 数组与链表\n数组是连续内存...',
    },
  });
  console.log(`✅ INSERT knowledgeItem: id=${item.id}, title=${item.title}`);

  const foundKB = await prisma.knowledgeBase.findUnique({ where: { id: kb.id } });
  console.log(`✅ SELECT knowledgeBase: ${foundKB?.title} (status=${foundKB?.status})`);

  const items = await prisma.knowledgeItem.findMany({ where: { knowledgeBaseId: kb.id } });
  console.log(`✅ SELECT knowledgeItems: ${items.length} 条`);

  const session = await prisma.learningSession.create({
    data: {
      userId: user.id,
      knowledgeBaseId: kb.id,
      knowledgeItemId: item.id,
      mode: 'reading',
      status: 'active',
      startedAt: new Date(),
    },
  });
  console.log(`✅ INSERT learningSession: id=${session.id}, mode=${session.mode}`);

  const updated = await prisma.learningSession.update({
    where: { id: session.id },
    data: { status: 'completed', endedAt: new Date(), durationSeconds: 300 },
  });
  console.log(`✅ UPDATE learningSession: status=${updated.status}, duration=${updated.durationSeconds}s`);

  const job = await prisma.aiAnalysisJob.create({
    data: {
      userId: user.id,
      sessionId: session.id,
      jobType: 'active_recall_analysis',
      status: 'pending',
    },
  });
  console.log(`✅ INSERT aiAnalysisJob: id=${job.id}, type=${job.jobType}`);

  await prisma.aiAnalysisJob.update({
    where: { id: job.id },
    data: { status: 'success', completedAt: new Date(), progress: 100 },
  });
  console.log(`✅ UPDATE aiAnalysisJob: success`);

  await prisma.aiAnalysisResult.create({
    data: {
      userId: user.id,
      jobId: job.id,
      summary: '用户掌握了数组的基本概念',
      masteryScore: 85,
      strengths: JSON.stringify(['理解清晰', '举例恰当']),
      weaknesses: JSON.stringify(['链表概念有混淆']),
    },
  });
  console.log(`✅ INSERT aiAnalysisResult: score=85`);

  const focus = await prisma.focusItem.create({
    data: {
      userId: user.id,
      knowledgeItemId: item.id,
      title: '链表与数组的区别需要巩固',
      priority: 'high',
      status: 'open',
    },
  });
  console.log(`✅ INSERT focusItem: id=${focus.id}, title=${focus.title}`);

  await prisma.focusItem.update({
    where: { id: focus.id },
    data: { status: 'completed', completedAt: new Date() },
  });
  console.log(`✅ UPDATE focusItem: completed`);

  const card = await prisma.reviewCard.create({
    data: {
      userId: user.id,
      knowledgeItemId: item.id,
      frontText: '数组和链表的主要区别是什么?',
      backText: '数组是连续内存分配...',
      nextReviewAt: new Date(Date.now() + 86400000),
    },
  });
  console.log(`✅ INSERT reviewCard: id=${card.id}`);

  await prisma.reviewLog.create({
    data: {
      userId: user.id,
      reviewCardId: card.id,
      rating: 'good',
      reviewedAt: new Date(),
    },
  });
  console.log(`✅ INSERT reviewLog: rating=good`);

  await prisma.feedback.create({
    data: { userId: user.id, category: 'feature', content: '希望支持Markdown导入', status: 'open' },
  });
  console.log(`✅ INSERT feedback`);

  await prisma.notification.create({
    data: { userId: user.id, type: 'ai_analysis_done', title: 'AI分析完成', content: '你的学习分析已生成' },
  });
  console.log(`✅ INSERT notification`);

  await prisma.dailyLearningActivity.create({
    data: {
      userId: user.id,
      activityDate: new Date(),
      durationSeconds: 300,
      sessionsCount: 1,
      activityLevel: 2,
    },
  });
  console.log(`✅ INSERT dailyLearningActivity`);

  // 关联查询 - KnowledgeBase + Items
  const kbWithItems = await prisma.knowledgeBase.findUnique({
    where: { id: kb.id },
    include: { items: true },
  });
  console.log(`✅ RELATION: knowledgeBase '${kbWithItems?.title}' 包含 ${kbWithItems?.items.length} 个知识点`);

  // ----- 清理测试数据 -----
  await prisma.reviewLog.deleteMany({ where: { userId: user.id } });
  await prisma.reviewCard.deleteMany({ where: { userId: user.id } });
  await prisma.focusItem.deleteMany({ where: { userId: user.id } });
  await prisma.aiAnalysisResult.deleteMany({ where: { userId: user.id } });
  await prisma.aiAnalysisJob.deleteMany({ where: { userId: user.id } });
  await prisma.learningSession.deleteMany({ where: { userId: user.id } });
  await prisma.knowledgeItem.deleteMany({ where: { userId: user.id } });
  await prisma.knowledgeBase.deleteMany({ where: { userId: user.id } });
  await prisma.userProfile.deleteMany({ where: { userId: user.id } });
  await prisma.feedback.deleteMany({ where: { userId: user.id } });
  await prisma.notification.deleteMany({ where: { userId: user.id } });
  await prisma.dailyLearningActivity.deleteMany({ where: { userId: user.id } });
  await prisma.user.delete({ where: { id: user.id } });

  console.log('\n✅ DELETE 清理完成 - 无残留数据');
  console.log('=== MySQL CRUD 全部通过 ===');
}

main()
  .catch((e) => {
    console.error('❌ FAILED:', e.message);
    process.exit(1);
  })
  .finally(() => prisma.$disconnect());