import { Injectable, Logger } from '@nestjs/common';
import { PrismaService } from '@core/database/prisma/prisma.service';
import { Prisma } from '@prisma/client';
import {
  CreateKnowledgeFixDto,
  ReviewKnowledgeFixDto,
  QueryKnowledgeFixDto,
  KnowledgeFixStatus,
} from '../dto';
import {
  MessageNotFoundException,
  KnowledgeFixExistsException,
  KnowledgeFixNotFoundException,
  ConversationAccessDeniedException,
} from '../exceptions';

/**
 * 知识补充服务
 */
@Injectable()
export class KnowledgeService {
  private readonly logger = new Logger(KnowledgeService.name);

  constructor(private readonly prisma: PrismaService) {}

  /**
   * 提交知识纠正
   */
  async createKnowledgeFix(
    dto: CreateKnowledgeFixDto,
    userId: string,
  ) {
    // 验证消息存在
    const message = await this.prisma.aIMessage.findFirst({
      where: { id: dto.messageId },
      include: {
        knowledgeFix: true,
      },
    });

    if (!message) {
      throw new MessageNotFoundException(dto.messageId);
    }

    // 检查是否已提交过纠正
    if (message.knowledgeFix) {
      throw new KnowledgeFixExistsException();
    }

    // 创建知识纠正
    const knowledgeFix = await this.prisma.aIKnowledgeFix.create({
      data: {
        messageId: dto.messageId,
        correctAnswer: dto.correctAnswer,
        contributorId: userId,
        status: 'PENDING',
      },
    });

    this.logger.log(`创建知识纠正: ${knowledgeFix.id}`);

    return {
      id: knowledgeFix.id,
      messageId: knowledgeFix.messageId,
      correctAnswer: knowledgeFix.correctAnswer,
      contributorId: knowledgeFix.contributorId,
      status: knowledgeFix.status,
      createdAt: knowledgeFix.createdAt,
    };
  }

  /**
   * 获取知识纠正列表
   */
  async findKnowledgeFixes(
    query: QueryKnowledgeFixDto,
    userId: string,
    isReviewer: boolean = false,
  ) {
    const { page = 1, limit = 20, status } = query;

    const where: Prisma.AIKnowledgeFixWhereInput = {};

    // 非审核员只能看自己的
    if (!isReviewer) {
      where.contributorId = userId;
    }

    if (status) {
      where.status = status;
    }

    const [total, fixes] = await Promise.all([
      this.prisma.aIKnowledgeFix.count({ where }),
      this.prisma.aIKnowledgeFix.findMany({
        where,
        orderBy: { createdAt: 'desc' },
        skip: (page - 1) * limit,
        take: limit,
        include: {
          message: {
            select: {
              id: true,
              content: true,
              role: true,
            },
          },
        },
      }),
    ]);

    const totalPages = Math.ceil(total / limit);

    return {
      items: fixes.map((fix) => ({
        id: fix.id,
        messageId: fix.messageId,
        originalAnswer: fix.message.content,
        correctAnswer: fix.correctAnswer,
        contributor: {
          id: fix.contributorId,
          name: '', // TODO: 从用户服务获取
        },
        status: fix.status,
        reviewNote: fix.reviewNote,
        createdAt: fix.createdAt,
        reviewedAt: fix.reviewedAt,
      })),
      total,
      page,
      limit,
      totalPages,
      hasNext: page < totalPages,
      hasPrev: page > 1,
    };
  }

  /**
   * 审核知识纠正
   */
  async reviewKnowledgeFix(
    id: string,
    dto: ReviewKnowledgeFixDto,
    reviewerId: string,
  ) {
    const knowledgeFix = await this.prisma.aIKnowledgeFix.findFirst({
      where: { id },
    });

    if (!knowledgeFix) {
      throw new KnowledgeFixNotFoundException(id);
    }

    const updated = await this.prisma.aIKnowledgeFix.update({
      where: { id },
      data: {
        status: dto.status,
        reviewerId,
        reviewNote: dto.reviewNote,
        reviewedAt: new Date(),
      },
    });

    this.logger.log(`审核知识纠正: ${id}, 结果: ${dto.status}`);

    return {
      id: updated.id,
      status: updated.status,
      reviewerId: updated.reviewerId,
      reviewNote: updated.reviewNote,
      reviewedAt: updated.reviewedAt,
    };
  }

  /**
   * 获取知识纠正详情
   */
  async findKnowledgeFix(id: string) {
    const fix = await this.prisma.aIKnowledgeFix.findFirst({
      where: { id },
      include: {
        message: {
          include: {
            conversation: true,
          },
        },
      },
    });

    if (!fix) {
      throw new KnowledgeFixNotFoundException(id);
    }

    return {
      id: fix.id,
      messageId: fix.messageId,
      originalAnswer: fix.message.content,
      correctAnswer: fix.correctAnswer,
      contributor: {
        id: fix.contributorId,
        name: '',
      },
      status: fix.status,
      reviewer: fix.reviewerId
        ? { id: fix.reviewerId, name: '' }
        : null,
      reviewNote: fix.reviewNote,
      createdAt: fix.createdAt,
      reviewedAt: fix.reviewedAt,
      conversation: {
        id: fix.message.conversation.id,
        title: fix.message.conversation.title,
      },
    };
  }
}