import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '../../database/prisma.service';
import { RewardEngine } from '../time-wallet/reward-engine.service';
import { UserRole, AutonomyLevel } from '@prisma/client';

export interface CreateChildDto {
  name: string;
  birthDate?: string;
  grade?: string;
  avatarEmoji?: string;
  dailyFreeMinutes?: number;
  dailyConditionalMinutes?: number;
  dailyMaxMinutes?: number;
}

@Injectable()
export class ChildrenService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly rewardEngine: RewardEngine,
  ) {}

  async createChild(guardianUserId: string, dto: CreateChildDto) {
    const guardianMembership = await this.prisma.familyMember.findFirst({
      where: { userId: guardianUserId },
      include: { guardian: true, family: true },
    });

    if (!guardianMembership || !guardianMembership.guardian) {
      throw new NotFoundException('Perfil de responsável não encontrado');
    }

    const result = await this.prisma.$transaction(async (tx) => {
      // Criar usuário filho (sem senha, acesso via device token)
      const childUser = await tx.user.create({
        data: {
          name: dto.name,
          role: UserRole.CHILD,
          timezone: guardianMembership.family.timezone,
          locale: guardianMembership.family.locale,
        },
      });

      // Vincular à família
      const childMember = await tx.familyMember.create({
        data: {
          familyId: guardianMembership.familyId,
          userId: childUser.id,
        },
      });

      // Criar perfil filho
      const child = await tx.child.create({
        data: {
          familyMemberId: childMember.id,
          birthDate: dto.birthDate ? new Date(dto.birthDate) : undefined,
          grade: dto.grade,
          avatarEmoji: dto.avatarEmoji || '🧒',
          autonomyLevel: AutonomyLevel.PROTECTED,
        },
      });

      // Vincular ao guardião
      await tx.childGuardian.create({
        data: {
          childId: child.id,
          guardianId: guardianMembership.guardian!.id,
        },
      });

      // Criar política padrão
      await tx.policy.create({
        data: { childId: child.id, version: 1 },
      });

      return { child, user: childUser };
    });

    // Inicializar carteira de tempo
    await this.rewardEngine.initializeWallet(result.child.id, {
      dailyFreeMinutes: dto.dailyFreeMinutes ?? 60,
      dailyConditionalMinutes: dto.dailyConditionalMinutes ?? 60,
      dailyMaxMinutes: dto.dailyMaxMinutes ?? 120,
    });

    return result.child;
  }

  async getChild(childId: string) {
    const child = await this.prisma.child.findUnique({
      where: { id: childId },
      include: {
        familyMember: {
          include: { user: { select: { id: true, name: true, avatarUrl: true } } },
        },
        devices: { where: { isActive: true } },
        policy: true,
        timeWallet: true,
      },
    });

    if (!child) throw new NotFoundException('Criança não encontrada');
    return child;
  }

  async updateChild(
    childId: string,
    data: {
      autonomyLevel?: AutonomyLevel;
      grade?: string;
      avatarEmoji?: string;
    },
  ) {
    return this.prisma.child.update({ where: { id: childId }, data });
  }

  async getChildProfile(childId: string) {
    // Para o app do filho: perfil + wallet + assignments pendentes
    const [child, wallet, pendingMissions, pendingRequests] = await Promise.all([
      this.prisma.child.findUnique({
        where: { id: childId },
        include: { familyMember: { include: { user: true } } },
      }),
      this.prisma.timeWallet.findUnique({ where: { childId } }),
      this.prisma.missionAssignment.findMany({
        where: { childId, status: { in: ['PENDING', 'IN_PROGRESS'] } },
        include: { mission: { include: { subject: true } } },
        take: 5,
      }),
      this.prisma.timeRequest.count({ where: { childId, status: 'PENDING' } }),
    ]);

    if (!child) throw new NotFoundException();

    return {
      id: child.id,
      name: child.familyMember.user.name,
      avatarEmoji: child.avatarEmoji,
      autonomyLevel: child.autonomyLevel,
      wallet,
      pendingMissions,
      pendingRequests,
    };
  }
}