package cache

import (
	"eta/eta_api/utils"
	"fmt"
)

// WechatPlatformOp
// @Description: 微信公众号操作请求
type WechatPlatformOp struct {
	Source           string
	WechatPlatformId int
}

// AddWechatArticleOpToCache
// @Description: 将公众号操作加入缓存
// @param wechatPlatformId
// @param source
// @return bool
func AddWechatArticleOpToCache(wechatPlatformId int, source string) bool {
	// 如果不在发布和调试模式，那么就不加入缓存
	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
		return true
	}

	record := new(WechatPlatformOp)
	record.Source = source
	record.WechatPlatformId = wechatPlatformId
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_WECHAT_PLATFORM_ARTICLE, record)

		utils.FileLog.Info(fmt.Sprintf("将公众号文章操作 加入缓存 AddWechatArticleOpToCache LPush: 操作类型：%s，公众号id：%d", source, wechatPlatformId))
		if err != nil {
			fmt.Println("AddWechatArticleOpToCache LPush Err:" + err.Error())
		}
		return true
	}
	return false
}

// WechatArticleOp
// @Description: 微信公众号文章操作
type WechatArticleOp struct {
	Source          string
	WechatArticleId int
	QuestionId      int
}

// AddWechatArticleLlmOpToCache
// @Description: 将公众号文章llm操作加入缓存
// @param wechatPlatformId
// @param source
// @return bool
func AddWechatArticleLlmOpToCache(wechatArticleId, questionId int, source string) bool {
	// 如果不在发布和调试模式，那么就不加入缓存
	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
		return true
	}
	record := new(WechatArticleOp)
	record.Source = source
	record.WechatArticleId = wechatArticleId
	record.QuestionId = questionId
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_WECHAT_PLATFORM_ARTICLE_KNOWLEDGE, record)

		utils.FileLog.Info(fmt.Sprintf("将公众号文章llm操作加入缓存 加入缓存 AddWechatArticleLlmOpToCache LPush: 操作类型：%s，公众号稳扎id：%d", source, wechatArticleId))
		if err != nil {
			fmt.Println("AddWechatArticleOpToCache LPush Err:" + err.Error())
		}
		return true
	}
	return false
}

type RagEtaReportOp struct {
	Source          string
	ReportId        int
	ReportChapterId int
}

// RagEtaReportOpToCache
// @Description: 将eta报告入知识库操作加入缓存
// @author: Roc
// @datetime 2025-04-07 15:05:22
// @param reportId int
// @param reportChapterId int
// @param source string
// @return bool
func RagEtaReportOpToCache(reportId, reportChapterId int, source string) bool {
	record := new(RagEtaReportOp)
	record.Source = source
	record.ReportId = reportId
	record.ReportChapterId = reportChapterId
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_ETA_REPORT_KNOWLEDGE, record)

		utils.FileLog.Info(fmt.Sprintf("将eta报告入知识库操作加入缓存 加入缓存 RagEtaReportOpToCache LPush: 操作类型：%s，报告id：%d，章节id：%d", source, reportId, reportChapterId))
		if err != nil {
			fmt.Println("RagEtaReportOpToCache LPush Err:" + err.Error())
		}
		return true
	}
	return false
}

// RagEtaReportLlmOp
// @Description:
type RagEtaReportLlmOp struct {
	RagEtaReportId int
	QuestionId     int
	ForceGenerate  bool
}

// AddRagEtaReportLlmOpToCache
// @Description: 将ETA报告llm操作加入缓存
// @author: Roc
// @datetime 2025-04-24 13:59:16
// @param ragEtaReportId int
// @param questionId int
// @return bool
func AddRagEtaReportLlmOpToCache(ragEtaReportId, questionId int, forceGenerate bool) bool {
	// 如果不在发布和调试模式，那么就不加入缓存
	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
		return true
	}
	record := new(RagEtaReportLlmOp)
	record.RagEtaReportId = ragEtaReportId
	record.QuestionId = questionId
	record.ForceGenerate = forceGenerate
	if utils.Re != nil {
		return false
	}

	err := utils.Rc.LPush(utils.CACHE_ETA_REPORT_KNOWLEDGE_LLM, record)
	utils.FileLog.Info(fmt.Sprintf("将eta报告llm操作加入缓存 加入缓存 RagEtaReportLlmOpToCache LPush: ETA报告id：%d", ragEtaReportId))
	if err != nil {
		fmt.Println("RagEtaReportLlmOpToCache LPush Err:" + err.Error())
	}
	return true
}

type AiTaskRecordOp struct {
	AiTaskRecordId int
}

// AddAiTaskRecordOpToCache
// @Description: AI任务操作调度入队列
// @author: Roc
// @datetime 2025-04-24 09:41:11
// @param aiTaskRecordId int
// @return bool
func AddAiTaskRecordOpToCache(aiTaskRecordId int) bool {
	// 如果不在发布和调试模式，那么就不加入缓存
	if !utils.InArrayByStr([]string{utils.BusinessCodeRelease, utils.BusinessCodeDebug}, utils.BusinessCode) {
		return true
	}
	record := new(AiTaskRecordOp)
	record.AiTaskRecordId = aiTaskRecordId
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_AI_ARTICLE_ABSTRACT_LLM_TASK, record)

		utils.FileLog.Info(fmt.Sprintf("将AI任务操作调度入队列 加入缓存 AddAiTaskRecordOpToCache LPush: 记录id：%d", aiTaskRecordId))
		if err != nil {
			fmt.Println("AddAiTaskRecordOpToCache LPush Err:" + err.Error())
		}
		return true
	}
	return false
}