package controller

import (
	"dypid/db"
	"dypid/global"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
)

func ListTokenHandler(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"result": db.ListToken()})
}

func CreateTokenHandler(c *gin.Context) {
	//解析输入数据
	input := struct {
		Token       string `form:"token" binding:"required"`
		DedupObject string `form:"dedup_object" binding:"required"`
		DataFormat  string `form:"data_format" binding:"required"`
		Notes       string `form:"notes"`
	}{}
	if err := c.ShouldBindQuery(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "参数不能为空 " + err.Error()})
		return
	}
	//检查Token是否存在
	if db.CheckToken(input.Token) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "创建Token失败，Token已经存在"})
		return
	}

	//创建Token
	err := db.CreateToken(input.Token, input.DedupObject, input.DataFormat, input.Notes)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	//返回
	c.JSON(http.StatusOK, gin.H{"result": "ok"})
}

func UpdateTokenHandler(c *gin.Context) {
	input := struct {
		Token       string `form:"token" binding:"required"`
		DedupObject string `form:"dedup_object" binding:"required"`
		DataFormat  string `form:"data_format" binding:"required"`
		Notes       string `form:"notes"`
	}{}
	if err := c.ShouldBindQuery(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "参数不能为空 " + err.Error()})
		return
	}
	//检查Token是否存在
	if !db.CheckToken(input.Token) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "更改失败，Token不存在"})
		return
	}

	err := db.UpdateToken(input.Token, input.DedupObject, input.DataFormat, input.Notes)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"result": "ok"})
}

func DeleteTokenHandler(c *gin.Context) {
	input := struct {
		Token string `form:"token" binding:"required"`
	}{}
	if err := c.ShouldBindQuery(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "参数不能为空 " + err.Error()})
		return
	}
	//检查Token是否存在
	if !db.CheckToken(input.Token) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "删除Token失败，Token不存在"})
		return
	}

	err := db.DeleteToken(input.Token)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"result": "ok"})
}

func GetTokenInfoHandler(c *gin.Context) {
	input := struct {
		Token string `form:"token" binding:"required"`
	}{}
	if err := c.ShouldBindQuery(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Token不能为空"})
		return
	}
	//检查Token是否存在
	if !db.CheckToken(input.Token) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "获取信息失败，Token不存在"})
		return
	}

	dedupObject, err := db.GetDedupObject(input.Token)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取去重对象失败 " + err.Error()})
		return
	}
	dataFormat, err := db.GetDataFormat(input.Token)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取数据格式失败 " + err.Error()})
		return
	}

	output := struct {
		Token            string `json:"token"`
		DedupObject      string `json:"dedup_object"`
		DataFormat       string `json:"data_format"`
		DedupItemsNumber int64  `json:"dedup_items_number"`
		CacheListNumber  int64  `json:"cache_list_number"`
	}{}
	output.Token = input.Token
	output.DedupObject = dedupObject
	output.DataFormat = dataFormat
	output.DedupItemsNumber = global.RDB.CFInfo(global.RCtx, "dedup:"+input.Token+":"+dedupObject).Val().NumItemsInserted
	output.CacheListNumber = global.RDB.LLen(global.RCtx, "list:"+input.Token).Val()

	c.JSON(http.StatusOK, gin.H{"result": output})
}

func DeleteTokenInfoHandler(c *gin.Context) {
	//解析输入数据
	input := struct {
		Token      string `form:"token" binding:"required"`
		DedupBF    string `form:"dedup_bf"`
		CacheList  string `form:"cache_list"`
		BothNumber string `form:"both_number"`
	}{}
	if err := c.ShouldBindQuery(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Token不能为空"})
		return
	}
	//检查Token是否存在
	if !db.CheckToken(input.Token) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "删除Token失败，Token不存在"})
		return
	}

	//检查token是否存在
	_, err := db.GetDedupObject(input.Token)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Token不存在" + err.Error()})
		return
	}
	dedupObject, err := db.GetDedupObject(input.Token)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	//删除去重对象
	switch input.DedupBF {
	case "":
	case "all":
		keys := global.RDB.Keys(global.RCtx, "dedup:"+input.Token+":*").Val()
		global.RDB.Del(global.RCtx, keys...)
		global.RDB.Del(global.RCtx, "delete-list:"+input.Token)
	default:
		i, err := strconv.Atoi(input.DedupBF)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "dedup_bf设置错误 " + err.Error()})
			return
		}
		result := global.RDB.LRange(global.RCtx, "delete-list:"+input.Token, int64(-i), -1).Val()
		_, err = global.RDB.TxPipelined(global.RCtx, func(pipe redis.Pipeliner) error {
			for _, s := range result {
				pipe.CFDel(global.RCtx, "dedup:"+input.Token+":"+dedupObject, s)
			}
			return nil
		})
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
			return
		}
		global.RDB.LTrim(global.RCtx, "delete-list:"+input.Token, 0, int64(-i-1))
	}

	//删除原始数据
	switch input.CacheList {
	case "":
	case "all":
		global.RDB.Del(global.RCtx, "list:"+input.Token)
	default:
		i, err := strconv.Atoi(input.CacheList)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "cache_list设置错误 " + err.Error()})
			return
		}

		global.RDB.LTrim(global.RCtx, "list:"+input.Token, 0, int64(-i-1))
	}

	//删除去重参考值和原始数据
	switch input.BothNumber {
	case "":
	default:
		i, err := strconv.Atoi(input.BothNumber)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "both_number设置错误 " + err.Error()})
			return
		}

		result := global.RDB.LRange(global.RCtx, "delete-list:"+input.Token, int64(-i), -1).Val()
		_, err = global.RDB.TxPipelined(global.RCtx, func(pipe redis.Pipeliner) error {
			for _, s := range result {
				pipe.CFDel(global.RCtx, "dedup:"+input.Token+":"+dedupObject, s)
			}
			pipe.LTrim(global.RCtx, "delete-list:"+input.Token, 0, int64(-i-1))
			pipe.LTrim(global.RCtx, "list:"+input.Token, 0, int64(-i-1))
			return nil
		})
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
			return
		}
	}

	//输出信息
	c.JSON(http.StatusOK, gin.H{"result": "ok"})
}