@hed-hog/lms 0.0.361 → 0.0.365

package/src/lesson-xp-map/lesson-xp-ai-calculation.service.ts

@@ -0,0 +1,570 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { buildAiConfigFromIntegration, SettingService } from '@hed-hog/core';
+import { DatabaseQueueProvider, IJobHandler, QueueHandlerRegistry } from '@hed-hog/queue';
+import {
+    BadRequestException,
+    forwardRef,
+    Inject,
+    Injectable,
+    Logger,
+    OnModuleInit,
+} from '@nestjs/common';
+import axios from 'axios';
+
+type XpSegmentAiResult = {
+  startSeconds: number;
+  endSeconds: number;
+  xpValue: number;
+  difficulty: 'easy' | 'medium' | 'hard' | 'expert';
+  shouldGrantXp: boolean;
+  aiSummary: string;
+  aiConfidence: number;
+  areas: { xpAreaId: number; weightPercent: number }[];
+  skills: { xpSkillId: number; weightPercent: number }[];
+  learningTypes: { xpLearningTypeId: number; weightPercent: number }[];
+};
+
+type LessonMeta = {
+  type: 'video' | 'text' | 'quiz';
+  content: string | null;
+  description: string | null;
+  durationSeconds: number;
+};
+
+@Injectable()
+export class LessonXpAiCalculationService implements OnModuleInit, IJobHandler {
+  private readonly logger = new Logger(LessonXpAiCalculationService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+    @Inject(forwardRef(() => QueueHandlerRegistry))
+    private readonly registry: QueueHandlerRegistry,
+    @Inject(forwardRef(() => DatabaseQueueProvider))
+    private readonly dbQueue: DatabaseQueueProvider,
+  ) {}
+
+  onModuleInit() {
+    this.registry.register('lms.lesson.xp.calculate', this);
+    this.logger.log('Registered handler for "lms.lesson.xp.calculate"');
+  }
+
+  async triggerCalculation(lessonId: number, userId: number) {
+    const lesson = await this.fetchLessonMeta(lessonId);
+
+    if (!lesson) {
+      throw new BadRequestException('Aula não encontrada.');
+    }
+
+    if (lesson.type === 'video') {
+      const segments = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+        `SELECT id FROM course_lesson_transcription_segment WHERE course_lesson_id = $1::int LIMIT 1`,
+        lessonId,
+      );
+      if (!segments.length) {
+        throw new BadRequestException(
+          'Esta aula ainda não possui transcrição. Gere ou importe a transcrição antes de calcular o XP.',
+        );
+      }
+    } else if (lesson.type === 'text') {
+      if (!lesson.durationSeconds || lesson.durationSeconds <= 0) {
+        throw new BadRequestException(
+          'Esta aula do tipo post precisa ter uma duração prevista configurada antes de calcular o XP.',
+        );
+      }
+      let parsed: any = {};
+      try { parsed = JSON.parse(lesson.content ?? '{}'); } catch { /* ignore */ }
+      if (!parsed.conteudoPost && !lesson.description) {
+        throw new BadRequestException(
+          'Esta aula do tipo post não possui conteúdo nem descrição pública. Adicione o conteúdo antes de calcular o XP.',
+        );
+      }
+    } else if (lesson.type === 'quiz') {
+      const questions = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+        `SELECT id FROM course_lesson_question WHERE course_lesson_id = $1::int LIMIT 1`,
+        lessonId,
+      );
+      if (!questions.length) {
+        throw new BadRequestException(
+          'Esta aula do tipo questão não possui questões vinculadas. Adicione questões antes de calcular o XP.',
+        );
+      }
+    }
+
+    const existing = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+      `SELECT id FROM lesson_xp_map WHERE course_lesson_id = $1::int`,
+      lessonId,
+    );
+
+    let mapId: number;
+
+    if (existing.length) {
+      mapId = existing[0].id;
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_map
+            SET status = 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum,
+                processing_error = NULL,
+                updated_at = NOW()
+          WHERE id = $1`,
+        mapId,
+      );
+    } else {
+      const created = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+        `INSERT INTO lesson_xp_map (course_lesson_id, version, total_xp, status, created_at, updated_at)
+         VALUES ($1, 1, 0, 'processing'::lesson_xp_map_status_d4e5f6a7b8_enum, NOW(), NOW())
+         RETURNING id`,
+        lessonId,
+      );
+      mapId = created[0].id;
+    }
+
+    try {
+      await this.dbQueue.enqueue({
+        type: 'lms.lesson.xp.calculate',
+        queueName: 'lms.lesson.xp.calculate',
+        payload: { lessonId, mapId, userId },
+        maxAttempts: 3,
+        sourceModule: 'lms',
+        sourceEntity: 'course_lesson',
+        sourceEntityId: String(lessonId),
+        userId,
+      });
+    } catch (err: any) {
+      // P2002 = unique constraint — a job for this lesson is already queued/running
+      if (err?.code !== 'P2002') throw err;
+    }
+
+    const rows = await this.prisma.$queryRawUnsafe<any[]>(
+      `SELECT
+          m.id,
+          m.course_lesson_id AS "courseLessonId",
+          m.version,
+          m.total_xp AS "totalXp",
+          m.status::text AS status,
+          m.generated_at::text AS "generatedAt",
+          m.processing_error AS "processingError",
+          m.created_at::text AS "createdAt",
+          m.updated_at::text AS "updatedAt"
+        FROM lesson_xp_map m WHERE m.id = $1`,
+      mapId,
+    );
+    return { ...rows[0], segments: [] };
+  }
+
+  async handle(job: {
+    id: number;
+    type: string;
+    queue_name: string;
+    payload: Record<string, any>;
+    attempts: number;
+    max_attempts: number;
+  }): Promise<void> {
+    const { lessonId, mapId } = job.payload as { lessonId: number; mapId: number };
+
+    this.logger.log(`Starting XP calculation for lesson ${lessonId}, map ${mapId}`);
+
+    try {
+      const lesson = await this.fetchLessonMeta(lessonId);
+
+      if (!lesson) {
+        await this.markError(mapId, 'Aula não encontrada.');
+        return;
+      }
+
+      let contentText: string;
+      const durationSeconds = lesson.durationSeconds ?? 0;
+
+      if (lesson.type === 'video') {
+        const transcriptionRows = await this.prisma.$queryRawUnsafe<
+          { startSeconds: number; endSeconds: number; text: string }[]
+        >(
+          `SELECT start_seconds::float AS "startSeconds", end_seconds::float AS "endSeconds", text
+             FROM course_lesson_transcription_segment
+            WHERE course_lesson_id = $1
+            ORDER BY start_seconds ASC`,
+          lessonId,
+        );
+
+        if (!transcriptionRows.length) {
+          await this.markError(mapId, 'Aula sem segmentos de transcrição.');
+          return;
+        }
+
+        contentText = transcriptionRows
+          .map((s) => {
+            const start = this.formatSeconds(s.startSeconds);
+            const end = this.formatSeconds(s.endSeconds);
+            return `[${start} - ${end}] ${s.text}`;
+          })
+          .join('\n');
+      } else if (lesson.type === 'text') {
+        contentText = this.buildPostContentText(lesson.content, lesson.description);
+        if (!contentText.trim()) {
+          await this.markError(mapId, 'Aula do tipo post sem conteúdo disponível para análise.');
+          return;
+        }
+      } else if (lesson.type === 'quiz') {
+        contentText = await this.buildQuizContentText(lessonId);
+        if (!contentText.trim()) {
+          await this.markError(mapId, 'Aula do tipo questão sem questões disponíveis para análise.');
+          return;
+        }
+      } else {
+        await this.markError(mapId, `Tipo de aula não suportado: ${(lesson as any).type}`);
+        return;
+      }
+
+      const [areas, skills, learningTypes] = await Promise.all([
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string }[]>(
+          `SELECT a.id, a.slug, COALESCE(al.name, a.slug) AS name
+             FROM xp_area a
+             LEFT JOIN xp_area_locale al ON al.xp_area_id = a.id
+             LEFT JOIN locale l ON l.id = al.locale_id AND l.code = 'pt'
+            WHERE a.status = 'active'
+            ORDER BY a.sort_order ASC`,
+        ),
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string; areaId: number | null }[]>(
+          `SELECT s.id, s.slug, COALESCE(sl.name, s.slug) AS name, s.xp_area_id AS "areaId"
+             FROM xp_skill s
+             LEFT JOIN xp_skill_locale sl ON sl.xp_skill_id = s.id
+             LEFT JOIN locale l ON l.id = sl.locale_id AND l.code = 'pt'
+            WHERE s.status = 'active'
+            ORDER BY s.sort_order ASC`,
+        ),
+        this.prisma.$queryRawUnsafe<{ id: number; slug: string; name: string; multiplier: number }[]>(
+          `SELECT lt.id, lt.slug, COALESCE(ltl.name, lt.slug) AS name, lt.multiplier::float AS multiplier
+             FROM xp_learning_type lt
+             LEFT JOIN xp_learning_type_locale ltl ON ltl.xp_learning_type_id = lt.id
+             LEFT JOIN locale l ON l.id = ltl.locale_id AND l.code = 'pt'
+            WHERE lt.status = 'active'
+            ORDER BY lt.sort_order ASC`,
+        ),
+      ]);
+
+      const settings = await this.settingService.getSettingValues(['ai-openai-profile-id']);
+      const profileId = Number(settings['ai-openai-profile-id']);
+
+      if (!profileId) {
+        await this.markError(mapId, 'Perfil de IA OpenAI não configurado em Settings → AI.');
+        return;
+      }
+
+      const profile = await (this.prisma as any).integration_profile.findUnique({
+        where: { id: profileId },
+        include: { integration_provider: { select: { slug: true } } },
+      });
+
+      if (!profile) {
+        await this.markError(mapId, 'Perfil de IA não encontrado.');
+        return;
+      }
+
+      const aiConfig = buildAiConfigFromIntegration(profile.integration_provider.slug, profile.config);
+
+      const prompt = this.buildPrompt(contentText, areas, skills, learningTypes, lesson.type, durationSeconds);
+
+      const response = await axios.post(
+        'https://api.openai.com/v1/chat/completions',
+        {
+          model: 'gpt-4o',
+          temperature: 0.2,
+          response_format: { type: 'json_object' },
+          messages: [
+            {
+              role: 'system',
+              content:
+                'Você é um especialista em design instrucional e mapeia competências técnicas de aulas de programação. Responda apenas com JSON válido.',
+            },
+            { role: 'user', content: prompt },
+          ],
+        },
+        {
+          headers: { Authorization: `Bearer ${aiConfig.apiKey}`, 'Content-Type': 'application/json' },
+          timeout: 120_000,
+        },
+      );
+
+      const rawContent: string = response.data?.choices?.[0]?.message?.content ?? '{}';
+      let parsed: { segments?: any[] };
+      try {
+        parsed = JSON.parse(rawContent);
+      } catch {
+        await this.markError(mapId, `IA retornou JSON inválido: ${rawContent.slice(0, 200)}`);
+        return;
+      }
+
+      const rawSegments: any[] = Array.isArray(parsed.segments) ? parsed.segments : [];
+      const areaIds = new Set(areas.map((a) => a.id));
+      const skillIds = new Set(skills.map((s) => s.id));
+      const ltIds = new Set(learningTypes.map((l) => l.id));
+
+      const validSegments: XpSegmentAiResult[] = rawSegments
+        .map((s: any) => ({
+          startSeconds: Number(s.startSeconds) || 0,
+          endSeconds: Number(s.endSeconds) || 60,
+          xpValue: Math.min(Math.max(Math.round(Number(s.xpValue) || 0), 0), 200),
+          difficulty: (['easy', 'medium', 'hard', 'expert'] as const).includes(s.difficulty)
+            ? s.difficulty
+            : 'medium',
+          shouldGrantXp: Boolean(s.shouldGrantXp),
+          aiSummary: String(s.aiSummary || '').slice(0, 500),
+          aiConfidence: Math.min(Math.max(Number(s.aiConfidence) || 0.5, 0), 1),
+          areas: (Array.isArray(s.areas) ? s.areas : [])
+            .filter((a: any) => areaIds.has(Number(a.xpAreaId)))
+            .map((a: any) => ({ xpAreaId: Number(a.xpAreaId), weightPercent: Number(a.weightPercent) || 0 })),
+          skills: (Array.isArray(s.skills) ? s.skills : [])
+            .filter((sk: any) => skillIds.has(Number(sk.xpSkillId)))
+            .map((sk: any) => ({ xpSkillId: Number(sk.xpSkillId), weightPercent: Number(sk.weightPercent) || 0 })),
+          learningTypes: (Array.isArray(s.learningTypes) ? s.learningTypes : [])
+            .filter((lt: any) => ltIds.has(Number(lt.xpLearningTypeId)))
+            .map((lt: any) => ({
+              xpLearningTypeId: Number(lt.xpLearningTypeId),
+              weightPercent: Number(lt.weightPercent) || 0,
+            })),
+        }))
+        .filter((s) => s.endSeconds > s.startSeconds);
+
+      await this.prisma.$executeRawUnsafe(
+        `DELETE FROM lesson_xp_segment WHERE lesson_xp_map_id = $1`,
+        mapId,
+      );
+
+      for (let i = 0; i < validSegments.length; i++) {
+        const seg = validSegments[i];
+        const inserted = await this.prisma.$queryRawUnsafe<{ id: number }[]>(
+          `INSERT INTO lesson_xp_segment
+             (lesson_xp_map_id, start_seconds, end_seconds, xp_value, difficulty,
+              should_grant_xp, ai_summary, ai_confidence, sort_order, created_at, updated_at)
+           VALUES ($1, $2, $3, $4, $5::lesson_xp_segment_difficulty_e5f6a7b8c9_enum,
+                   $6, $7, $8, $9, NOW(), NOW())
+           RETURNING id`,
+          mapId, seg.startSeconds, seg.endSeconds, seg.xpValue,
+          seg.difficulty, seg.shouldGrantXp, seg.aiSummary,
+          seg.aiConfidence, i,
+        );
+        const segId = inserted[0].id;
+
+        for (const area of seg.areas) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_area (lesson_xp_segment_id, xp_area_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, area.xpAreaId, area.weightPercent,
+          );
+        }
+        for (const skill of seg.skills) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_skill (lesson_xp_segment_id, xp_skill_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, skill.xpSkillId, skill.weightPercent,
+          );
+        }
+        for (const lt of seg.learningTypes) {
+          await this.prisma.$executeRawUnsafe(
+            `INSERT INTO lesson_xp_segment_learning_type (lesson_xp_segment_id, xp_learning_type_id, weight_percent, created_at, updated_at)
+             VALUES ($1, $2, $3, NOW(), NOW())`,
+            segId, lt.xpLearningTypeId, lt.weightPercent,
+          );
+        }
+      }
+
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_map
+            SET status = 'ready'::lesson_xp_map_status_d4e5f6a7b8_enum,
+                generated_at = NOW(),
+                ai_model_version = 'gpt-4o',
+                processing_error = NULL,
+                total_xp = COALESCE(
+                  (SELECT SUM(xp_value) FROM lesson_xp_segment
+                    WHERE lesson_xp_map_id = $1 AND should_grant_xp = true),
+                  0
+                ),
+                updated_at = NOW()
+          WHERE id = $1`,
+        mapId,
+      );
+
+      this.logger.log(
+        `XP calculation done for lesson ${lessonId}: ${validSegments.length} segments saved.`,
+      );
+    } catch (err: any) {
+      this.logger.error(`XP calculation failed for lesson ${lessonId}: ${err?.message}`);
+      await this.markError(mapId, err?.message ?? 'Erro desconhecido');
+    }
+  }
+
+  private async fetchLessonMeta(lessonId: number): Promise<LessonMeta | null> {
+    const rows = await this.prisma.$queryRawUnsafe<LessonMeta[]>(
+      `SELECT type::text AS type, content, description, duration_seconds AS "durationSeconds"
+         FROM course_lesson WHERE id = $1`,
+      lessonId,
+    );
+    return rows[0] ?? null;
+  }
+
+  private buildPostContentText(content: string | null, description: string | null): string {
+    const parts: string[] = [];
+
+    if (description?.trim()) {
+      parts.push(`Descrição pública:\n${description.trim()}`);
+    }
+
+    let postContent = '';
+    try {
+      const parsed = JSON.parse(content ?? '{}');
+      postContent = String(parsed.conteudoPost ?? '').trim();
+    } catch { /* ignore */ }
+
+    if (postContent) {
+      parts.push(`Conteúdo do post:\n${this.stripHtml(postContent)}`);
+    }
+
+    return parts.join('\n\n');
+  }
+
+  private async buildQuizContentText(lessonId: number): Promise<string> {
+    const questions = await this.prisma.$queryRawUnsafe<{
+      statement: string;
+      explanation: string | null;
+      options: { text: string; isCorrect: boolean; feedback: string | null }[] | null;
+    }[]>(
+      `SELECT
+          q.statement,
+          q.explanation,
+          COALESCE(
+            json_agg(
+              json_build_object('text', o.option_text, 'isCorrect', o.is_correct, 'feedback', o.feedback)
+              ORDER BY o.position ASC
+            ) FILTER (WHERE o.id IS NOT NULL),
+            '[]'
+          ) AS options
+        FROM course_lesson_question clq
+        JOIN question q ON q.id = clq.question_id
+        LEFT JOIN exam_option o ON o.question_id = q.id
+       WHERE clq.course_lesson_id = $1
+       GROUP BY clq.order, q.statement, q.explanation
+       ORDER BY clq.order ASC`,
+      lessonId,
+    );
+
+    if (!questions.length) return '';
+
+    return questions.map((q, i) => {
+      const lines: string[] = [`Questão ${i + 1}:`];
+      lines.push(`Enunciado: ${q.statement}`);
+
+      const opts = Array.isArray(q.options) ? q.options : [];
+      if (opts.length) {
+        const labels = 'abcdefghijklmnopqrstuvwxyz';
+        lines.push(
+          'Alternativas: ' +
+            opts
+              .map((o, idx) => `${labels[idx] ?? idx + 1}) ${o.text}${o.isCorrect ? ' [CORRETA]' : ''}`)
+              .join('; '),
+        );
+      }
+
+      if (q.explanation?.trim()) {
+        lines.push(`Explicação: ${q.explanation.trim()}`);
+      }
+
+      return lines.join('\n');
+    }).join('\n\n');
+  }
+
+  private async markError(mapId: number, message: string) {
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET status = 'needs_review'::lesson_xp_map_status_d4e5f6a7b8_enum,
+              processing_error = $1,
+              updated_at = NOW()
+        WHERE id = $2`,
+      message.slice(0, 1000),
+      mapId,
+    );
+  }
+
+  private buildPrompt(
+    content: string,
+    areas: { id: number; slug: string; name: string }[],
+    skills: { id: number; slug: string; name: string; areaId: number | null }[],
+    learningTypes: { id: number; slug: string; name: string; multiplier: number }[],
+    lessonType: 'video' | 'text' | 'quiz',
+    durationSeconds: number,
+  ): string {
+    const totalMinutes = Math.max(Math.ceil(durationSeconds / 60), 1);
+
+    const contentHeader =
+      lessonType === 'video'
+        ? 'TRANSCRIÇÃO DA AULA'
+        : lessonType === 'text'
+          ? 'CONTEÚDO DO POST'
+          : 'QUESTÕES DA AULA';
+
+    const segmentInstruction =
+      lessonType === 'video'
+        ? 'Analise a transcrição abaixo e mapeie as competências técnicas de cada segmento de ~60 segundos.'
+        : lessonType === 'text'
+          ? `Analise o conteúdo do post abaixo (duração estimada: ${totalMinutes} minutos) e mapeie as competências técnicas. Divida o conteúdo em segmentos de ~60 segundos cobrindo a duração total. Os valores de startSeconds e endSeconds devem cobrir de 0 até ${durationSeconds} segundos.`
+          : `Analise as questões da aula abaixo (duração estimada: ${totalMinutes} minutos). Cada questão representa um segmento; distribua o tempo total de ${durationSeconds} segundos igualmente entre as questões. Os valores de startSeconds e endSeconds devem cobrir de 0 até ${durationSeconds} segundos.`;
+
+    return `${segmentInstruction}
+
+CATÁLOGO DE ÁREAS MACRO (use APENAS estes IDs):
+${JSON.stringify(areas.map((a) => ({ id: a.id, slug: a.slug, name: a.name })))}
+
+CATÁLOGO DE SKILLS (use APENAS estes IDs):
+${JSON.stringify(skills.map((s) => ({ id: s.id, slug: s.slug, name: s.name, areaId: s.areaId })))}
+
+CATÁLOGO DE TIPOS DE APRENDIZADO (use APENAS estes IDs):
+${JSON.stringify(learningTypes.map((l) => ({ id: l.id, slug: l.slug, name: l.name, multiplier: l.multiplier })))}
+
+${contentHeader}:
+${content}
+
+Retorne um JSON com a chave "segments" contendo um array onde cada item representa um segmento de ~60s:
+{
+  "segments": [
+    {
+      "startSeconds": 0,
+      "endSeconds": 60,
+      "xpValue": 10,
+      "difficulty": "medium",
+      "shouldGrantXp": true,
+      "aiSummary": "Resumo curto do conteúdo do segmento",
+      "aiConfidence": 0.9,
+      "areas": [{"xpAreaId": 1, "weightPercent": 70}, {"xpAreaId": 2, "weightPercent": 30}],
+      "skills": [{"xpSkillId": 5, "weightPercent": 100}],
+      "learningTypes": [{"xpLearningTypeId": 2, "weightPercent": 100}]
+    }
+  ]
+}
+
+Regras obrigatórias:
+- Use APENAS IDs do catálogo acima. Nunca invente IDs.
+- xpValue entre 0 e 50 por segmento. Segmentos com conteúdo irrelevante (intro, pausa, avisos) devem ter shouldGrantXp=false e xpValue=0.
+- Os weightPercent de areas, skills e learningTypes devem somar 100 cada.
+- difficulty: easy (conceitos básicos), medium (aplicação), hard (avançado), expert (arquitetura/otimização).
+- aiConfidence: 0 a 1, indica certeza do mapeamento.`;
+  }
+
+  private stripHtml(html: string): string {
+    return html
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/&amp;/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/&nbsp;/g, ' ')
+      .replace(/\s{2,}/g, ' ')
+      .trim();
+  }
+
+  private formatSeconds(s: number): string {
+    const m = Math.floor(s / 60);
+    const sec = Math.floor(s % 60);
+    return `${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+  }
+}

package/src/lesson-xp-map/lesson-xp-map.controller.ts

@@ -0,0 +1,116 @@
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    HttpCode,
+    HttpStatus,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+    Request,
+} from '@nestjs/common';
+import { CreateLessonXpMapDto } from './dto/create-lesson-xp-map.dto';
+import { CreateLessonXpSegmentDto } from './dto/create-lesson-xp-segment.dto';
+import { RejectLessonXpMapDto } from './dto/review-lesson-xp-map.dto';
+import { UpdateLessonXpMapDto } from './dto/update-lesson-xp-map.dto';
+import { LessonXpAiCalculationService } from './lesson-xp-ai-calculation.service';
+import { LessonXpMapService } from './lesson-xp-map.service';
+import { LessonXpSegmentService } from './lesson-xp-segment.service';
+
+@Role()
+@Controller('lms/xp/lesson-maps')
+export class LessonXpMapController {
+  constructor(
+    private readonly lessonXpMapService: LessonXpMapService,
+    private readonly lessonXpSegmentService: LessonXpSegmentService,
+    private readonly lessonXpAiCalculationService: LessonXpAiCalculationService,
+  ) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('courseLessonId') courseLessonId?: string,
+  ) {
+    return this.lessonXpMapService.list({
+      page: Number(page) || 1,
+      pageSize: Number(pageSize) || 20,
+      search,
+      status,
+      courseLessonId: courseLessonId ? Number(courseLessonId) : undefined,
+    });
+  }
+
+  @Post()
+  create(@Body() dto: CreateLessonXpMapDto) {
+    return this.lessonXpMapService.create(dto);
+  }
+
+  @Get('lesson/:lessonId')
+  getByLesson(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.lessonXpMapService.getByLessonId(lessonId);
+  }
+
+  @Get('course/:courseId/overview')
+  getCourseOverview(@Param('courseId', ParseIntPipe) courseId: number) {
+    return this.lessonXpMapService.getCourseOverview(courseId);
+  }
+
+  @Post('lesson/:lessonId/recalculate')
+  recalculate(@Param('lessonId', ParseIntPipe) lessonId: number, @Request() req: any) {
+    return this.lessonXpAiCalculationService.triggerCalculation(lessonId, req.user?.id ?? 0);
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpMapService.getById(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateLessonXpMapDto) {
+    return this.lessonXpMapService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpMapService.delete(id);
+  }
+
+  @Post(':id/approve')
+  approve(@Param('id', ParseIntPipe) id: number, @Request() req: any) {
+    const reviewerPersonId: number = req.user?.personId ?? req.user?.id ?? 0;
+    return this.lessonXpMapService.approve(id, reviewerPersonId);
+  }
+
+  @Post(':id/reject')
+  reject(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: RejectLessonXpMapDto,
+    @Request() req: any,
+  ) {
+    const reviewerPersonId: number = req.user?.personId ?? req.user?.id ?? 0;
+    return this.lessonXpMapService.reject(id, reviewerPersonId, dto.reviewNotes);
+  }
+
+  // Segment sub-resource
+  @Get(':id/segments')
+  listSegments(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.lessonXpSegmentService.listByMap(id, { page: Number(page) || 1, pageSize: Number(pageSize) || 50 });
+  }
+
+  @Post(':id/segments')
+  createSegment(@Param('id', ParseIntPipe) id: number, @Body() dto: CreateLessonXpSegmentDto) {
+    return this.lessonXpSegmentService.create(id, dto);
+  }
+}