import { BadRequestException, ForbiddenException, Injectable, NotFoundException } from '@nestjs/common'
import { PrismaService } from '../prisma/prisma.service'
import { BodyMetricDto, MemberNoteDto, ProgressPhotoDto } from './dto/member-progress.dto'
import { ProgressPhotoStorageService } from './progress-photo-storage.service'
import { BODY_MEASUREMENT_FIELDS, emptyPostureAssessment, isPostureAssessment, postureAnswerCount } from '@mp-pilates/shared'
import { Prisma } from '@prisma/client'
@Injectable()
export class MemberProgressService {
  constructor(private readonly prisma: PrismaService, private readonly storage: ProgressPhotoStorageService) {}
  private async member(userId: string) {
    const user = await this.prisma.user.findUnique({ where: { id: userId }, select: { nickname: true } })
    if (!user) throw new NotFoundException('学员不存在')
    return user
  }
  private date(value: string) {
    const date = new Date(value + 'T00:00:00.000Z')
    if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value || value > new Date(Date.now() + 8 * 3600000).toISOString().slice(0, 10)) throw new BadRequestException('请选择有效的记录日期，不能晚于今天')
    return date
  }
  async archive(userId: string, admin = false) {
    const user = await this.member(userId)
    const [count, supplements, metrics, notes, photos] = await Promise.all([
      this.prisma.booking.count({ where: { userId, status: 'COMPLETED' } }),
      this.prisma.lessonSupplement.aggregate({ where: { userId, revokedAt: null }, _sum: { quantity: true } }),
      this.prisma.bodyMetric.findMany({ where: { userId }, orderBy: [{ recordedAt: 'desc' }, { createdAt: 'desc' }] }),
      this.prisma.memberNote.findMany({ where: { userId, ...(admin ? {} : { shared: true }) }, orderBy: { createdAt: 'desc' }, include: { booking: { select: { timeSlot: { select: { date: true, startTime: true } } } } } }),
      this.prisma.progressPhoto.findMany({ where: { userId, uploadedAt: { not: null } }, orderBy: { recordedAt: 'desc' }, select: { id: true, caption: true, recordedAt: true, consentedAt: true, revokedAt: true } }),
    ])
    const completedCount = count + (supplements._sum.quantity || 0)
    return { nickname: user.nickname, completedCount, milestones: [10, 30, 50].filter(n => completedCount >= n), metrics, notes, photos }
  }
  async addMetric(userId: string, operatorId: string, dto: BodyMetricDto) {
    await this.member(userId)
    return this.prisma.bodyMetric.create({ data: { ...this.metricData(dto), userId, operatorId } })
  }
  async metric(userId: string, id: string) {
    const member = await this.member(userId)
    const record = await this.prisma.bodyMetric.findFirst({ where: { id, userId } })
    if (!record) throw new NotFoundException('体测记录不存在')
    return { nickname: member.nickname, record }
  }
  async updateMetric(userId: string, id: string, operatorId: string, dto: BodyMetricDto) {
    const data = this.metricData(dto)
    const result = await this.prisma.bodyMetric.updateMany({ where: { id, userId }, data: { ...data, operatorId } })
    if (!result.count) throw new NotFoundException('体测记录不存在')
    return this.prisma.bodyMetric.findFirst({ where: { id, userId } })
  }
  private metricData(dto: BodyMetricDto) {
    const assessment = dto.assessment ?? emptyPostureAssessment()
    if (!isPostureAssessment(assessment)) throw new BadRequestException('体态检查内容无效')
    const measurements = Object.fromEntries(BODY_MEASUREMENT_FIELDS.map(field => [field.key, dto[field.key] ?? null]))
    if (BODY_MEASUREMENT_FIELDS.every(field => dto[field.key] == null) && !postureAnswerCount(assessment) && !dto.remark?.trim()) throw new BadRequestException('请至少填写一项体测数据、体态检查或评估备注')
    return { ...measurements, recordedAt: this.date(dto.recordedAt), remark: dto.remark?.trim() || '', assessment: assessment as unknown as Prisma.InputJsonValue }
  }
  async addNote(userId: string, operatorId: string, dto: MemberNoteDto) {
    await this.member(userId)
    if (!dto.content.trim()) throw new BadRequestException('请填写笔记内容')
    if (dto.bookingId && !await this.prisma.booking.findFirst({ where: { id: dto.bookingId, userId, status: 'COMPLETED' } })) throw new BadRequestException('只能批注该学员已完成的课程')
    return this.prisma.memberNote.create({ data: { userId, operatorId, content: dto.content.trim(), shared: dto.shared, bookingId: dto.bookingId || null } })
  }
  async remove(userId: string, kind: string, id: string) {
    if (kind === 'metrics') {
      const result = await this.prisma.bodyMetric.deleteMany({ where: { id, userId } })
      if (!result.count) throw new NotFoundException('记录不存在')
      return { deleted: true }
    }
    if (kind === 'notes') {
      const result = await this.prisma.memberNote.deleteMany({ where: { id, userId } })
      if (!result.count) throw new NotFoundException('记录不存在')
      return { deleted: true }
    }
    if (kind === 'photos') {
      const photo = await this.prisma.progressPhoto.findFirst({ where: { id, userId } })
      if (!photo) throw new NotFoundException('照片不存在')
      await this.storage.removeObject(photo.objectKey)
      await this.prisma.progressPhoto.delete({ where: { id } })
      return { deleted: true }
    }
    throw new BadRequestException('记录类型无效')
  }
  async upload(userId: string, operatorId: string, dto: ProgressPhotoDto) {
    await this.member(userId)
    const recordedAt = this.date(dto.recordedAt)
    const credential = this.storage.credential(userId, dto.fileName)
    const photo = await this.prisma.progressPhoto.create({ data: { userId, operatorId, objectKey: credential.key, recordedAt, caption: dto.caption } })
    return { ...credential, id: photo.id }
  }
  async finishUpload(userId: string, id: string) {
    const photo = await this.prisma.progressPhoto.findFirst({ where: { id, userId } })
    if (!photo) throw new NotFoundException('照片不存在')
    await this.storage.verify(photo.objectKey)
    await this.prisma.progressPhoto.update({ where: { id }, data: { uploadedAt: new Date() } })
    return { uploaded: true }
  }
  async consent(userId: string, id: string, consent: boolean) {
    const result = await this.prisma.progressPhoto.updateMany({ where: { id, userId, uploadedAt: { not: null } }, data: { consentedAt: consent ? new Date() : null, revokedAt: consent ? null : new Date() } })
    if (!result.count) throw new NotFoundException('照片不存在')
    return { consent }
  }
  async photoUrl(userId: string, id: string, admin = false) {
    const photo = await this.prisma.progressPhoto.findFirst({ where: { id, userId, uploadedAt: { not: null } } })
    if (!photo) throw new NotFoundException('照片不存在')
    // Members can privately preview their own photo to make an informed consent decision.
    if (admin && !photo.consentedAt) throw new ForbiddenException('学员尚未授权展示这张照片')
    return { url: this.storage.signedUrl(photo.objectKey), expiresIn: 60 }
  }
}