import { Injectable, Logger } from '@nestjs/common';
import { PrismaService } from '@core/database/prisma/prisma.service';
import {
  CreatePromptTemplateDto,
  UpdatePromptTemplateDto,
  QueryPromptTemplateDto,
  ConversationCategory,
} from '../dto';
import { PromptTemplateNotFoundException } from '../exceptions';

/**
 * Prompt 模板服务
 */
@Injectable()
export class PromptService {
  private readonly logger = new Logger(PromptService.name);

  constructor(private readonly prisma: PrismaService) {}

  /**
   * 获取当前激活的 Prompt（用于 AI 对话）
   */
  async getActivePrompt(category: string): Promise<string | null> {
    const template = await this.prisma.aIPromptTemplate.findFirst({
      where: {
        category: category as any,
        isActive: true,
      },
      orderBy: { version: 'desc' },
    });

    return template?.content || null;
  }

  /**
   * 创建 Prompt 模板
   */
  async createPromptTemplate(dto: CreatePromptTemplateDto, userId: string) {
    // 获取该分类下的最新版本号
    const latestTemplate = await this.prisma.aIPromptTemplate.findFirst({
      where: { category: dto.category },
      orderBy: { version: 'desc' },
    });

    const nextVersion = (latestTemplate?.version || 0) + 1;

    const template = await this.prisma.aIPromptTemplate.create({
      data: {
        name: dto.name,
        category: dto.category,
        content: dto.content,
        version: nextVersion,
        isActive: false,
        createdBy: userId,
      },
    });

    this.logger.log(`创建 Prompt 模板: ${template.id}, 版本: ${nextVersion}`);

    return {
      id: template.id,
      name: template.name,
      category: template.category,
      version: template.version,
      isActive: template.isActive,
      createdAt: template.createdAt,
    };
  }

  /**
   * 获取 Prompt 模板列表
   */
  async findPromptTemplates(query: QueryPromptTemplateDto) {
    const where: any = {};

    if (query.category) {
      where.category = query.category;
    }

    if (query.isActive !== undefined) {
      where.isActive = query.isActive;
    }

    const templates = await this.prisma.aIPromptTemplate.findMany({
      where,
      orderBy: [{ category: 'asc' }, { version: 'desc' }],
    });

    return {
      items: templates.map((t) => ({
        id: t.id,
        name: t.name,
        category: t.category,
        version: t.version,
        isActive: t.isActive,
        createdBy: {
          id: t.createdBy,
          name: '', // TODO: 从用户服务获取
        },
        createdAt: t.createdAt,
        updatedAt: t.updatedAt,
      })),
      total: templates.length,
    };
  }

  /**
   * 获取 Prompt 模板详情
   */
  async findPromptTemplate(id: string) {
    const template = await this.prisma.aIPromptTemplate.findFirst({
      where: { id },
    });

    if (!template) {
      throw new PromptTemplateNotFoundException(id);
    }

    return {
      id: template.id,
      name: template.name,
      category: template.category,
      content: template.content,
      version: template.version,
      isActive: template.isActive,
      createdBy: {
        id: template.createdBy,
        name: '',
      },
      createdAt: template.createdAt,
      updatedAt: template.updatedAt,
    };
  }

  /**
   * 更新 Prompt 模板
   */
  async updatePromptTemplate(id: string, dto: UpdatePromptTemplateDto) {
    const template = await this.prisma.aIPromptTemplate.findFirst({
      where: { id },
    });

    if (!template) {
      throw new PromptTemplateNotFoundException(id);
    }

    // 如果内容变化，增加版本号
    let newVersion = template.version;
    if (dto.content && dto.content !== template.content) {
      newVersion = template.version + 1;
    }

    const updated = await this.prisma.aIPromptTemplate.update({
      where: { id },
      data: {
        name: dto.name,
        content: dto.content,
        version: newVersion,
      },
    });

    this.logger.log(`更新 Prompt 模板: ${id}, 版本: ${newVersion}`);

    return {
      id: updated.id,
      name: updated.name,
      version: updated.version,
      updatedAt: updated.updatedAt,
    };
  }

  /**
   * 激活 Prompt 模板
   */
  async activatePromptTemplate(id: string) {
    const template = await this.prisma.aIPromptTemplate.findFirst({
      where: { id },
    });

    if (!template) {
      throw new PromptTemplateNotFoundException(id);
    }

    // 先停用同分类下的其他模板
    await this.prisma.aIPromptTemplate.updateMany({
      where: {
        category: template.category,
        isActive: true,
      },
      data: { isActive: false },
    });

    // 激活当前模板
    const updated = await this.prisma.aIPromptTemplate.update({
      where: { id },
      data: { isActive: true },
    });

    this.logger.log(`激活 Prompt 模板: ${id}`);

    return {
      id: updated.id,
      category: updated.category,
      version: updated.version,
      isActive: updated.isActive,
      activatedAt: updated.updatedAt,
    };
  }
}