package utils

import (
	"math"
	"sort"
)

type textUtil struct{}

var TextUtil textUtil

func (a *textUtil) SimilarityBylcs(x, y string) float64 {
	lcsLength := lcs(x, y)
	maxLength := max(len(x), len(y))
	return float64(lcsLength) / float64(maxLength) * 100
}

// lcs 计算两个字符串的最长公共子序列长度
func lcs(a string, b string) int {
	m := len(a)
	n := len(b)
	L := make([][]int, m+1)
	for i := range L {
		L[i] = make([]int, n+1)
	}

	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if a[i-1] == b[j-1] {
				L[i][j] = L[i-1][j-1] + 1
			} else {
				L[i][j] = max(L[i-1][j], L[i][j-1])
			}
		}
	}
	return L[m][n]
}

// 编辑距离 计算相似度百分比
func (A *textUtil) SimilarityBydistance(x, y string) float64 {
	distance := distanceSimilarity(x, y)
	maxLength := max(len(x), len(y))
	if maxLength == 0 {
		return 100.0
	}
	return 100.0 * (1.0 - float64(distance)/float64(maxLength))
}

// 计算两段文本的编辑距离
func distanceSimilarity(a, b string) int {
	// 创建一个二维数组，行数为a的长度加1，列数为b的长度加1
	dp := make([][]int, len(a)+1)
	for i := range dp {
		dp[i] = make([]int, len(b)+1)
	}

	// 初始化第一行和第一列
	for i := range dp {
		dp[i][0] = i
	}
	for j := range dp[0] {
		dp[0][j] = j
	}

	// 填充二维数组
	for i := 1; i <= len(a); i++ {
		for j := 1; j <= len(b); j++ {
			if a[i-1] == b[j-1] {
				dp[i][j] = dp[i-1][j-1] // 字符相同，不需要编辑操作
			} else {
				dp[i][j] = min(dp[i-1][j]+1, // 删除操作
					dp[i][j-1]+1,   // 插入操作
					dp[i-1][j-1]+1) // 替换操作
			}
		}
	}

	return dp[len(a)][len(b)]
}

// max 返回两个整数中的最大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// 辅助函数，用于找到最小值
func min(a, b, c int) int {
	if a < b {
		if a < c {
			return a
		} else {
			return c
		}
	} else {
		if b < c {
			return b
		} else {
			return c
		}
	}
}

// 余弦相似度
// // 使用jieba进行分词
// jieba := gojieba.NewJieba()
// defer jieba.Free()

// x := jieba.Cut(x, true)
// y := jieba.Cut(y, true)
func (a *textUtil) SimilarityBycosine(x, y []string) float64 {
	// 构建词频向量
	wordFreq1 := make(map[string]int)
	wordFreq2 := make(map[string]int)

	for _, word := range x {
		wordFreq1[word]++
	}
	for _, word := range y {
		wordFreq2[word]++
	}

	// 合并所有单词到一个有序列表中
	allWords := make([]string, 0, len(wordFreq1)+len(wordFreq2))
	for word := range wordFreq1 {
		allWords = append(allWords, word)
	}
	for word := range wordFreq2 {
		if _, exists := wordFreq1[word]; !exists {
			allWords = append(allWords, word)
		}
	}
	sort.Strings(allWords) // 确保词汇表是有序的

	// 初始化向量
	vector1 := make([]float64, len(allWords))
	vector2 := make([]float64, len(allWords))

	// 填充向量
	for i, word := range allWords {
		vector1[i] = float64(wordFreq1[word])
		vector2[i] = float64(wordFreq2[word])
	}

	// 计算余弦相似度
	dotProduct := 0.0
	normA := 0.0
	normB := 0.0

	for i := 0; i < len(vector1); i++ {
		dotProduct += vector1[i] * vector2[i]
		normA += vector1[i] * vector1[i]
		normB += vector2[i] * vector2[i]
	}

	normA = math.Sqrt(normA)
	normB = math.Sqrt(normB)

	if normA == 0 || normB == 0 {
		return 0
	}

	return dotProduct / (normA * normB)
}