package clear

import (
	qu "qfw/util"
	"regexp"
	"strings"
)

var SpecialSymbols map[string]interface{}
var SymmetricMap map[string]string
var AsyReg, AllReg, MesReg *regexp.Regexp
var SymField map[string]interface{} //对称符号过滤字段
var AsyField map[string]interface{} //特殊符号过滤字段
var MesField map[string]interface{} //乱码过滤字段
func init() {
	qu.ReadConfig("./specialsymbols.json", &SpecialSymbols)
	//对称符号
	tmp1 := SpecialSymbols["symmetric"].(map[string]interface{})
	SymField = tmp1["field"].(map[string]interface{})
	symmetricArr := tmp1["symbol"].([]interface{})
	SymmetricMap = make(map[string]string)
	allSymbol := ""
	for _, val := range symmetricArr { //SymmetricMap
		tmpArr := qu.ObjArrToStringArr(val.([]interface{}))
		s1 := strings.Replace(tmpArr[0], "\\", "", -1)
		s2 := strings.Replace(tmpArr[1], "\\", "", -1)
		allSymbol = tmpArr[0] + tmpArr[1] + allSymbol
		SymmetricMap[s2] = s1
	}
	allSymbol = "[" + allSymbol + "]"
	AllReg = regexp.MustCompile(allSymbol)
	//特殊符号
	tmp2 := SpecialSymbols["asymmetric"].(map[string]interface{})
	AsyField = tmp2["field"].(map[string]interface{})
	asymmetricArr := qu.ObjArrToStringArr(tmp2["symbol"].([]interface{}))
	asymmetric := ""
	for _, val := range asymmetricArr {
		asymmetric = asymmetric + val
	}
	if asymmetric != "" {
		asymmetric = "[" + asymmetric + "]"
		AsyReg = regexp.MustCompile(asymmetric)
	}
	//乱码
	tmp3 := SpecialSymbols["messycode"].(map[string]interface{})
	MesField = tmp3["field"].(map[string]interface{})
	messycodeArr := qu.ObjArrToStringArr(tmp3["symbol"].([]interface{}))
	messycodeStr := ""
	for _, v := range messycodeArr {
		messycodeStr = messycodeStr + v
	}
	if messycodeStr != "" {
		messycodeStr = "[" + messycodeStr + "]"
	}
	MesReg = regexp.MustCompile(messycodeStr)
}

//去除首尾空格、换行、回车
func RemoveHeadAndEndSpace(text string) string {
	defer qu.Catch()
	if len(text) > 0 {
		tmp := cutSpace.ReplaceAllString(strings.Replace(text, "　", " ", -1), "")
		text = replaceSymbol(tmp, spaces)
	}
	return text
}

func RemoveHeadAndEndSymmetricCode(val string) string {
	defer qu.Catch()
	text := []rune(val)
	if len(text) > 0 {
		for i := 1; i <= 2; i++ { //循环处理两次
			if len(text) > 0 {
				//text = RemoveStart(i, text)
				text = AnotherRemoveStart(text)
			}
		}
	}
	return string(text)
}

func RemoveStart(i int, text []rune) []rune {
	defer qu.Catch()
	if len(text) > 0 {
		pairedIndex := make(map[int]int)
		symbolIndex := make(map[string][]int) //记录符号和当前索引位置
		surplusMax := -1                      //记录多余的反符号最大值
		positiveMax := -1                     //记录多余的正符号最大值
		removeLength := 0
		length := len(text)
		for index, t := range text {
			now := AllReg.FindString(string(t))
			if len(now) > 0 { //匹配到符号
				if index == 0 {
					lock.Lock()
					fdSymbol := SymmetricMap[now]
					lock.Unlock()
					if fdSymbol != "" { //去除第一个反符号
						text = text[1:len(text)]
					} else if len(now) > 0 { //第一个是正符号，记录索引位置
						tmpArr := []int{index}
						symbolIndex[now] = tmpArr
					}
				} else {
					lock.Lock()
					fdSymbol := SymmetricMap[now]
					lock.Unlock()
					if fdSymbol != "" { //反向符号，找出对称的正向符号
						tmp := symbolIndex[fdSymbol]
						if len(tmp) == 0 { //多出来的反向符号,记录最大值
							if index > surplusMax {
								surplusMax = index
							}
						} else {
							nowIndex := tmp[len(tmp)-1]              //索引位置
							symbolIndex[fdSymbol] = tmp[:len(tmp)-1] //匹配索引位置后，删除之前的记录
							if len(symbolIndex[fdSymbol]) == 0 {
								delete(symbolIndex, fdSymbol)
							}
							//将成对的符号的index记录，
							if index == length-1 {
								pairedIndex[index] = nowIndex
							}
							pairedIndex[nowIndex] = index
						}
					} else { //正向符号,加入symbolIndex记录索引
						tmpArr := []int{}
						if len(symbolIndex[now]) > 0 { //有该符号的索引位置
							tmpArr = symbolIndex[now]
							tmpArr = append(tmpArr, index)
						} else { //没有该符号的索引位置
							tmpArr = []int{index}
						}
						symbolIndex[now] = tmpArr
					}
				}
			}
		}
		if i == 1 || i == 3 { //第一次清理首尾符号
			if len(symbolIndex) != 0 { //多余的正符号索引位置
				for _, arr := range symbolIndex {
					for j, l := range arr {
						if j == 0 && l == 0 {
							text = text[1:] //删除text开头的正向符号
							removeLength = 1
						}
					}
				}
			}
			firstOpposite := pairedIndex[0]
			if firstOpposite != 0 {
				text = text[firstOpposite+1:]
				removeLength = firstOpposite + 1
			}
			lastOpposite := pairedIndex[length-1]
			if lastOpposite > 0 { //有对称的正向符号,删除其中间内容
				text = text[:lastOpposite-removeLength]
			} else if surplusMax == length-1 { //没有对称，只删除最后一个反符号
				text = text[:length-1-removeLength]
			}
		}
		if i == 2 { //第二次清理多余的符号
			if len(symbolIndex) != 0 { //多余的正符号索引位置
				for _, arr := range symbolIndex {
					for _, l := range arr {
						if positiveMax < l {
							positiveMax = l
						}
					}
				}
			}
			//有多余反向符号，删除之前部分 surplusMax所有多余反向符号的最大索引
			if surplusMax != -1 && surplusMax < positiveMax {
				text = text[surplusMax+1:]
				//多余正符号删除之后部分（优先删除反符号之前部分）//发发发发发发发发[发)发发发发发发发发发发发发
				if positiveMax != -1 && surplusMax < positiveMax {
					text = text[:positiveMax-surplusMax-1]
				}
			} else if surplusMax != -1 && surplusMax > positiveMax {
				text = text[surplusMax+1:]
			}
		}
	}
	return text
}

//乱码
func RemoveMessycode(text string) string {
	defer qu.Catch()
	if len(text) > 0 {
		text = MesReg.ReplaceAllString(text, "")
	}
	return text
}

//特殊符号
func RemoveAsymmetric(text string) string {
	defer qu.Catch()
	if len(text) > 0 {
		textRune := []rune(text)
		first := string(textRune[0])
		last := string(textRune[len(textRune)-1])
		if AsyReg.MatchString(first) {
			textRune = textRune[1:]
		}
		if len(textRune) > 0 && AsyReg.MatchString(last) && len(text) > 0 {
			textRune = textRune[:len(textRune)-1]
		}
		text = string(textRune)
	}
	return text
}

func OtherClean(field, text string) string {
	text = RemoveHeadAndEndSpace(text) //去除首尾空格
	if AsyField[field] != nil {
		text = RemoveAsymmetric(text) //特殊符号
	}
	if SymField[field] != nil { //对称符号
		text = RemoveHeadAndEndSymmetricCode(text)
	}
	if MesField[field] != nil { //乱码
		text = RemoveMessycode(text)
	}
	text = RemoveHeadAndEndSpace(text) //去除首尾空格
	return text
}

func AnotherRemoveStart(text []rune) []rune {
	defer qu.Catch()
	if len(text) > 0 {
		pairedIndex := make(map[int]int)
		symbolIndex := make(map[string][]int) //记录符号和当前索引位置
		surplusMax := -1                      //记录多余的反符号最大值
		positiveMax := -1                     //记录多余的正符号最大值
		removeLength := 0
		nb := 0
		length := len(text)
		for index, t := range text {
			now := AllReg.FindString(string(t))
			if len(now) > 0 { //匹配到符号
				if index == 0 {
					lock.Lock()
					fdSymbol := SymmetricMap[now]
					lock.Unlock()
					if fdSymbol != "" { //去除第一个反符号
						text = text[1:len(text)]
					} else if len(now) > 0 { //第一个是正符号，记录索引位置
						tmpArr := []int{index}
						symbolIndex[now] = tmpArr
					}
				} else {
					lock.Lock()
					fdSymbol := SymmetricMap[now]
					lock.Unlock()
					if fdSymbol != "" { //反向符号，找出对称的正向符号
						tmp := symbolIndex[fdSymbol]
						if len(tmp) == 0 { //多出来的反向符号,记录最大值
							if index > surplusMax {
								surplusMax = index
							}
						} else {
							nowIndex := tmp[len(tmp)-1]              //索引位置
							symbolIndex[fdSymbol] = tmp[:len(tmp)-1] //匹配索引位置后，删除之前的记录
							if len(symbolIndex[fdSymbol]) == 0 {
								delete(symbolIndex, fdSymbol)
							}
							//将成对的符号的index记录，
							if index == length-1 {
								pairedIndex[index] = nowIndex
							}
							pairedIndex[nowIndex] = index
						}
					} else { //正向符号,加入symbolIndex记录索引
						tmpArr := []int{}
						if len(symbolIndex[now]) > 0 { //有该符号的索引位置
							tmpArr = symbolIndex[now]
							tmpArr = append(tmpArr, index)
						} else { //没有该符号的索引位置
							tmpArr = []int{index}
						}
						symbolIndex[now] = tmpArr
					}
				}
			}
		}
		if len(symbolIndex) != 0 { //多余的正符号索引位置
			for _, arr := range symbolIndex {
				for j, l := range arr {
					if j == 0 && l == 0 {
						text = text[1:] //删除text开头的正向符号
						removeLength = 1
						nb = nb + 1
					}
					if positiveMax < l { //记录最大正向索引
						positiveMax = l
					}
				}
			}
		}
		firstOpposite := pairedIndex[0]
		if firstOpposite != 0 { //第一个正符号对应反符号的位置
			text = text[firstOpposite+1:]
			removeLength = firstOpposite + 1
			nb = nb + removeLength
		}
		lastOpposite := pairedIndex[length-1] //最后一个符号
		if lastOpposite > 0 {                 //有对称的正向符号,删除其中间内容
			//na = length - lastOpposite
			text = text[:lastOpposite-removeLength]
		} else if surplusMax == length-1 { //没有对称，只删除最后一个反符号
			text = text[:length-1-removeLength]
			//na = na + 1
		}
		//有多余反向符号，删除之前部分 surplusMax所有多余反向符号的最大索引
		if surplusMax != -1 && surplusMax > firstOpposite && surplusMax < length-1 {
			if (lastOpposite > 0 && surplusMax < lastOpposite) || (lastOpposite == 0) { //发发发发发发}发(发发发发发发)
				text = text[surplusMax-nb+1:]
				nb = surplusMax + 1
			}
		}
		//多余正符号删除之后部分（优先删除反符号之前部分）//（发发{发发）发发发发发发发发发发发发发发发（发{发）
		if positiveMax != -1 && positiveMax != 0 && positiveMax > surplusMax && positiveMax > firstOpposite { ////发发发发发发]发发{
			if (lastOpposite > 0 && positiveMax < lastOpposite) || (lastOpposite == 0) { //发发发发发发发发{发发发发发（发发）
				text = text[:positiveMax-nb]
			}
		}
	}
	return text
}
