import { Injectable, Logger } from '@nestjs/common';
import { PrismaService } from '@core/database/prisma/prisma.service';
import { QueryStatsDto } from '../dto';

/**
 * 统计服务
 */
@Injectable()
export class StatsService {
  private readonly logger = new Logger(StatsService.name);

  constructor(private readonly prisma: PrismaService) {}

  /**
   * 获取统计概览
   */
  async getOverview(query: QueryStatsDto) {
    const { startDate, endDate, category } = query;

    const dateFilter: any = {};
    if (startDate) {
      dateFilter.gte = new Date(startDate);
    }
    if (endDate) {
      dateFilter.lte = new Date(endDate);
    }

    const conversationWhere: any = {
      createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
    };
    if (category) {
      conversationWhere.category = category;
    }

    // 并行查询统计数据
    const [
      totalConversations,
      totalMessages,
      totalTickets,
      categoryBreakdown,
      feedbackStats,
    ] = await Promise.all([
      // 总对话数
      this.prisma.aIConversation.count({ where: conversationWhere }),
      
      // 总消息数
      this.prisma.aIMessage.count({
        where: {
          conversation: conversationWhere,
        },
      }),
      
      // 总工单数
      this.prisma.aIAssistantTicket.count({
        where: {
          createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
        },
      }),
      
      // 分类分布
      this.prisma.aIConversation.groupBy({
        by: ['category'],
        _count: { id: true },
        where: conversationWhere,
      }),
      
      // 反馈统计
      this.prisma.aIMessageFeedback.groupBy({
        by: ['type'],
        _count: { id: true },
        where: {
          createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
        },
      }),
    ]);

    // 计算解决率
    const resolvedTickets = await this.prisma.aIAssistantTicket.count({
      where: {
        status: { in: ['RESOLVED', 'CLOSED'] },
        createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
      },
    });
    const resolutionRate = totalTickets > 0 ? resolvedTickets / totalTickets : 0;

    // 处理分类分布
    const categoryBreakdownMap: Record<string, number> = {};
    categoryBreakdown.forEach((item) => {
      categoryBreakdownMap[item.category] = item._count.id;
    });

    // 处理反馈统计
    const likes = feedbackStats.find((f) => f.type === 'LIKE')?._count.id || 0;
    const dislikes = feedbackStats.find((f) => f.type === 'DISLIKE')?._count.id || 0;
    const totalFeedback = likes + dislikes;
    const averageSatisfaction = totalFeedback > 0
      ? ((likes / totalFeedback) * 5).toFixed(1)
      : '0';

    return {
      totalConversations,
      totalMessages,
      totalTickets,
      resolutionRate: parseFloat(resolutionRate.toFixed(2)),
      averageSatisfaction: parseFloat(averageSatisfaction),
      categoryBreakdown: categoryBreakdownMap,
    };
  }

  /**
   * 获取反馈统计
   */
  async getFeedbackStats(query: QueryStatsDto) {
    const { startDate, endDate } = query;

    const dateFilter: any = {};
    if (startDate) {
      dateFilter.gte = new Date(startDate);
    }
    if (endDate) {
      dateFilter.lte = new Date(endDate);
    }

    const where: any = {
      createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
    };

    const feedbackStats = await this.prisma.aIMessageFeedback.groupBy({
      by: ['type'],
      _count: { id: true },
      where,
    });

    // 按分类统计（使用安全的 Prisma 查询替代原始 SQL）
    let categoryFeedback: any[] = [];
    try {
      const feedbacksWithCategory = await this.prisma.aIMessageFeedback.findMany({
        where,
        select: {
          type: true,
          message: {
            select: {
              conversation: {
                select: {
                  category: true,
                },
              },
            },
          },
        },
      });

      // 手动聚合分类统计
      const categoryMap: Record<string, { likes: number; dislikes: number }> = {};
      feedbacksWithCategory.forEach((f) => {
        const category = f.message.conversation.category;
        if (!categoryMap[category]) {
          categoryMap[category] = { likes: 0, dislikes: 0 };
        }
        if (f.type === 'LIKE') {
          categoryMap[category].likes++;
        } else {
          categoryMap[category].dislikes++;
        }
      });

      categoryFeedback = Object.entries(categoryMap).map(([category, counts]) => ({
        category,
        ...counts,
      }));
    } catch (error) {
      this.logger.warn('Failed to get category feedback stats:', error);
    }

    const likes = feedbackStats.find((f) => f.type === 'LIKE')?._count.id || 0;
    const dislikes = feedbackStats.find((f) => f.type === 'DISLIKE')?._count.id || 0;
    const total = likes + dislikes;
    const likeRate = total > 0 ? likes / total : 0;

    // 直接使用已处理的 categoryFeedback
    const byCategoryResult: Record<string, { likes: number; dislikes: number }> = {};
    categoryFeedback.forEach((item: any) => {
      byCategoryResult[item.category] = {
        likes: item.likes || 0,
        dislikes: item.dislikes || 0,
      };
    });

    return {
      total,
      likes,
      dislikes,
      likeRate: parseFloat(likeRate.toFixed(2)),
      byCategory: byCategoryResult,
    };
  }

  /**
   * 获取管理仪表盘数据
   */
  async getDashboard() {
    const now = new Date();
    const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
    const last7d = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);

    const [
      callsLast24h,
      callsLast7d,
      feedbackStats,
      categoryStats,
      knowledgeFixStats,
    ] = await Promise.all([
      // 最近 24 小时调用量
      this.prisma.aIConversation.count({
        where: { createdAt: { gte: last24h } },
      }),
      
      // 最近 7 天调用量
      this.prisma.aIConversation.count({
        where: { createdAt: { gte: last7d } },
      }),
      
      // 反馈统计
      this.prisma.aIMessageFeedback.groupBy({
        by: ['type'],
        _count: { id: true },
      }),
      
      // 分类分布
      this.prisma.aIConversation.groupBy({
        by: ['category'],
        _count: { id: true },
      }),
      
      // 知识纠正统计
      this.prisma.aIKnowledgeFix.groupBy({
        by: ['status'],
        _count: { id: true },
      }),
    ]);

    // 处理反馈
    const likes = feedbackStats.find((f) => f.type === 'LIKE')?._count.id || 0;
    const dislikes = feedbackStats.find((f) => f.type === 'DISLIKE')?._count.id || 0;
    const totalFeedback = likes + dislikes;

    // 处理分类分布
    const totalConversations = categoryStats.reduce(
      (sum, item) => sum + item._count.id,
      0,
    );
    const categoryDistribution: Record<string, number> = {};
    categoryStats.forEach((item) => {
      categoryDistribution[item.category] =
        totalConversations > 0
          ? parseFloat((item._count.id / totalConversations).toFixed(2))
          : 0;
    });

    // 处理知识纠正
    const pendingReviewCount =
      knowledgeFixStats.find((f) => f.status === 'PENDING')?._count.id || 0;
    const totalKnowledgeFix = knowledgeFixStats.reduce(
      (sum, item) => sum + item._count.id,
      0,
    );

    return {
      realtime: {
        callsLast24h,
        callsLast7d,
        successRate: 0.98, // TODO: 从监控系统获取
        errorRate: 0.02,
        avgResponseTime: 850, // TODO: 从监控系统获取
      },
      satisfaction: {
        likeRate: totalFeedback > 0 ? parseFloat((likes / totalFeedback).toFixed(2)) : 0,
        dislikeRate: totalFeedback > 0 ? parseFloat((dislikes / totalFeedback).toFixed(2)) : 0,
        noFeedbackRate: 0.1, // TODO: 计算无反馈率
      },
      categoryDistribution,
      hallucination: {
        markedCount: totalKnowledgeFix,
        pendingReviewCount,
      },
      topIssues: [], // TODO: 实现热门问题统计
      updatedAt: now,
    };
  }

  /**
   * 获取幻觉标记统计
   */
  async getHallucinationStats(query: QueryStatsDto) {
    const { startDate, endDate } = query;

    const dateFilter: any = {};
    if (startDate) {
      dateFilter.gte = new Date(startDate);
    }
    if (endDate) {
      dateFilter.lte = new Date(endDate);
    }

    const where: any = {
      createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
    };

    const [
      statusStats,
      totalMessages,
    ] = await Promise.all([
      this.prisma.aIKnowledgeFix.groupBy({
        by: ['status'],
        _count: { id: true },
        where,
      }),
      
      this.prisma.aIMessage.count({
        where: {
          role: 'ASSISTANT',
          createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
        },
      }),
    ]);

    const pending = statusStats.find((s) => s.status === 'PENDING')?._count.id || 0;
    const approved = statusStats.find((s) => s.status === 'APPROVED')?._count.id || 0;
    const rejected = statusStats.find((s) => s.status === 'REJECTED')?._count.id || 0;
    const totalMarked = pending + approved + rejected;

    // 计算点踩相关的幻觉标记
    const dislikesCount = await this.prisma.aIMessageFeedback.count({
      where: {
        type: 'DISLIKE',
        createdAt: Object.keys(dateFilter).length > 0 ? dateFilter : undefined,
      },
    });

    return {
      totalMarked,
      fromDislike: dislikesCount,
      fromKnowledgeFix: totalMarked,
      pendingReview: pending,
      approved,
      rejected,
      hallucinationRate: totalMessages > 0
        ? parseFloat((totalMarked / totalMessages).toFixed(4))
        : 0,
      byCategory: {}, // TODO: 按分类统计
      trend: [], // TODO: 趋势数据
    };
  }

  /**
   * 处理分类反馈数据
   */
  private processCategoryFeedback(data: any[]): Record<string, { likes: number; dislikes: number }> {
    const result: Record<string, { likes: number; dislikes: number }> = {};
    
    data.forEach((item) => {
      if (!result[item.category]) {
        result[item.category] = { likes: 0, dislikes: 0 };
      }
      if (item.type === 'LIKE') {
        result[item.category].likes = parseInt(item.count, 10);
      } else if (item.type === 'DISLIKE') {
        result[item.category].dislikes = parseInt(item.count, 10);
      }
    });

    return result;
  }
}