import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '../../database/prisma.service';
import { AiProviderService, GenerateMissionInput } from './ai-provider.service';
import { MissionStatus, MissionType } from '@prisma/client';

@Injectable()
export class LearningService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly ai: AiProviderService,
  ) {}

  async generateMissionWithAi(input: GenerateMissionInput, guardianId: string) {
    const subjectRecord = await this.prisma.subject.findFirst({
      where: { name: { contains: input.subject, mode: 'insensitive' } },
    });

    const generated = await this.ai.generateMission(input, guardianId);

    // Criar missão em draft para o guardião revisar
    const mission = await this.prisma.mission.create({
      data: {
        subjectId: subjectRecord?.id,
        type: MissionType.EDUCATIONAL,
        status: MissionStatus.DRAFT,
        title: generated.title,
        description: generated.description,
        estimatedMinutes: generated.estimatedMinutes,
        rewardMinutes: generated.rewardMinutes,
        isAiGenerated: true,
        createdBy: guardianId,
        lessons: {
          create: generated.lessons.map((lesson, li) => ({
            title: lesson.title,
            content: lesson.content,
            sortOrder: li,
            questions: {
              create: lesson.questions.map((q, qi) => ({
                type: q.type as any,
                stem: q.stem,
                explanation: q.explanation,
                sortOrder: qi,
                options: {
                  create: q.options.map((opt, oi) => ({
                    text: opt.text,
                    isCorrect: opt.isCorrect,
                    sortOrder: oi,
                  })),
                },
              })),
            },
          })),
        },
      },
      include: {
        lessons: { include: { questions: { include: { options: true } } } },
      },
    });

    return mission;
  }

  async publishMission(missionId: string) {
    return this.prisma.mission.update({
      where: { id: missionId },
      data: { status: MissionStatus.PUBLISHED },
    });
  }

  async getTutorHint(questionId: string, childId: string, history: any[]) {
    const question = await this.prisma.question.findUnique({
      where: { id: questionId },
      include: { lesson: { include: { mission: { include: { subject: true } } } } },
    });
    if (!question) throw new NotFoundException('Questão não encontrada');

    const child = await this.prisma.child.findUnique({
      where: { id: childId },
      include: { familyMember: { include: { user: true } } },
    });

    const ageYears = child?.birthDate
      ? new Date().getFullYear() - new Date(child.birthDate).getFullYear()
      : 10;

    const context = `${question.lesson.mission.subject?.name ?? ''} - ${question.lesson.mission.title}`;

    return this.ai.tutorHint(question.stem, context, ageYears, history);
  }

  async getRecommendations(childId: string) {
    // Buscar habilidades com menor domínio
    const weakSkills = await this.prisma.skillProgress.findMany({
      where: { childId, domainPercent: { lt: 70 } },
      include: { skill: { include: { subject: true } } },
      orderBy: { domainPercent: 'asc' },
      take: 3,
    });

    if (weakSkills.length === 0) {
      // Se tudo bem, sugerir missões não tentadas
      return this.prisma.mission.findMany({
        where: {
          status: MissionStatus.PUBLISHED,
          assignments: { none: { childId } },
        },
        include: { subject: true },
        take: 3,
      });
    }

    // Sugerir missões relacionadas às habilidades fracas
    const subjectIds = [...new Set(weakSkills.map((s) => s.skill.subjectId))];
    return this.prisma.mission.findMany({
      where: {
        status: MissionStatus.PUBLISHED,
        subjectId: { in: subjectIds },
        assignments: { none: { childId } },
      },
      include: { subject: true },
      take: 3,
    });
  }
}