package customChartesing

import (
	"appPlatform/api/version1/customerform"
	"appPlatform/overall/publicmethod"
	"fmt"
	"strconv"
	"strings"
	"time"
)

/*
*
@ 作者: 秦东
@ 时间: 2025-07-21 09:50:02
@ 功能: 雷达图
*/
func (c *ChartInfo) radarChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {

	for _, v := range c.XAxis {
		fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
		switch v.Type {
		case 3:
			snedMap = c.RadarTimeDataAnaly(v, c.YAxis, val, chartType)
		default:
			snedMap = c.RadarDataAnaly(v, c.YAxis, val, chartType, untis)
		}
	}
	return
}
func (c *ChartInfo) RadarTimeDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string) (charData RadarInfo) {
	tayTime := time.Now().Unix()
	searchTime := c.JieXiSearchTime()
	fmt.Printf("时间集---1-->%v\n\n", searchTime)
	switch x.TimeType {
	case "year":
		tayTimeing := int(time.Now().Year())
		var timeList []string
		// for i := 0; i <= tayTimeing; i++ {
		timeList = append(timeList, fmt.Sprintf("%v", tayTimeing))
		// }
		if len(searchTime) > 0 {
			timeList = searchTime
		}
		var jiSuanVal []RadarTimeInfo

		fmt.Printf("时间集----->%v\n\n", timeList)
		// for _, v := range y {
		// charData.Legend = append(charData.Legend, v.OldTitle)
		var newVal []map[string]interface{}
		for _, tv := range timeList {

			startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", tv))
			endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", tv))
			if yVal, isOk := val.([]map[string]interface{}); isOk {
				for _, mv := range yVal {
					if xVal, isOk := mv[x.Field]; isOk {
						var begTime int64
						var eldTime int64
						pageTime, _ := publicmethod.StringToInt64(xVal)
						if publicmethod.GetIntLength(pageTime) >= 13 {
							begTime = startTime * 1000
							eldTime = endTime * 1000
						}
						if begTime <= pageTime && pageTime <= eldTime {
							// fmt.Printf("维度--3---》%v---》%v---》%v\n\n", tv, begTime <= pageTime, pageTime <= eldTime)
							newVal = append(newVal, mv)
						}
					}
				}
			}
			var timeData RadarTimeInfo
			timeData.XName = tv
			timeData.DataVal = newVal
			jiSuanVal = append(jiSuanVal, timeData)
			// fmt.Printf("维度--1---》%v---》%v\n\n", tv, len(newVal))
		}
		// jsonVal, _ := json.Marshal(jiSuanVal)
		// fmt.Printf("维度-----》%v\n\n", string(jsonVal))
		charData.ParsingData(jiSuanVal, y)
	case "month":
		var timeList []string
		yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
		tayTimeing := int(time.Now().Month())
		for i := 1; i <= tayTimeing; i++ {
			timeList = append(timeList, fmt.Sprintf("%v-%v", yearVal, i))
		}
		if len(searchTime) > 0 {
			timeList = searchTime
		}
		var jiSuanVal []RadarTimeInfo
		// for _, v := range y {
		// charData.Legend = append(charData.Legend, v.OldTitle)
		var newVal []map[string]interface{}
		for _, tv := range timeList {
			startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", tv))
			nyAry := strings.Split(tv, "-")
			year, _ := strconv.Atoi(nyAry[0])
			mon, _ := strconv.Atoi(nyAry[len(nyAry)-1])
			endTime := publicmethod.GetDaysInMonth(year, mon)
			fmt.Printf("维度--1---》%v---》%v---》%v\n\n", startTime, mon, endTime)
			// endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v- 23:59:59", tv))
			if yVal, isOk := val.([]map[string]interface{}); isOk {
				for _, mv := range yVal {
					if xVal, isOk := mv[x.Field]; isOk {
						var begTime int64
						var eldTime int64
						pageTime, _ := publicmethod.StringToInt64(xVal)
						if publicmethod.GetIntLength(pageTime) >= 13 {
							begTime = startTime * 1000
							eldTime = endTime.AllTime * 1000
						}
						if begTime <= pageTime && pageTime <= eldTime {
							// fmt.Printf("维度--3---》%v---》%v---》%v\n\n", tv, begTime <= pageTime, pageTime <= eldTime)
							newVal = append(newVal, mv)
						}
					}
				}
			}
			var timeData RadarTimeInfo
			timeData.XName = tv
			timeData.DataVal = newVal
			jiSuanVal = append(jiSuanVal, timeData)
			// fmt.Printf("维度--1---》%v---》%v\n\n", tv, len(newVal))
		}
		// jsonVal, _ := json.Marshal(jiSuanVal)
		// fmt.Printf("维度-----》%v\n\n", string(jsonVal))
		charData.ParsingData(jiSuanVal, y)
		// }y
	case "day":
		tayTimeing := int(time.Now().Day())
		yearVal := publicmethod.UnixTimeToDay(tayTime, 15)
		var timeList []string
		for i := 1; i <= tayTimeing; i++ {
			timeList = append(timeList, fmt.Sprintf("%v-%v", yearVal, i))
		}
		if len(searchTime) > 0 {
			timeList = searchTime
		}
		var jiSuanVal []RadarTimeInfo
		// for _, v := range y {
		// charData.Legend = append(charData.Legend, v.OldTitle)
		var newVal []map[string]interface{}
		for _, tv := range timeList {
			startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", tv))
			endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", tv))
			if yVal, isOk := val.([]map[string]interface{}); isOk {
				for _, mv := range yVal {
					if xVal, isOk := mv[x.Field]; isOk {
						var begTime int64
						var eldTime int64
						pageTime, _ := publicmethod.StringToInt64(xVal)
						if publicmethod.GetIntLength(pageTime) >= 13 {
							begTime = startTime * 1000
							eldTime = endTime * 1000
						}
						if begTime <= pageTime && pageTime <= eldTime {
							fmt.Printf("维度--3---》%v---》%v---》%v\n\n", tv, begTime <= pageTime, pageTime <= eldTime)
							newVal = append(newVal, mv)
						}
					}
				}
			}
			var timeData RadarTimeInfo
			timeData.XName = tv
			timeData.DataVal = newVal
			jiSuanVal = append(jiSuanVal, timeData)
			fmt.Printf("维度--1---》%v---》%v\n\n", tv, len(newVal))
		}
		// jsonVal, _ := json.Marshal(jiSuanVal)
		// fmt.Printf("维度-----》%v\n\n", string(jsonVal))
		charData.ParsingData(jiSuanVal, y)
		// }y
	// case "hour":
	// case "minute":
	// case "second":
	// case "ymdhms":
	default:
		yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
		yearValInt, _ := strconv.Atoi(yearVal)
		tayTime := int(time.Now().Month())
		var jiSuanVal []RadarTimeInfo
		for i := 1; i <= tayTime; i++ {
			createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
			if i < 10 {
				createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
			}
			startTime := publicmethod.DateToTimeStampOld(createTime)
			endTime := publicmethod.GetDaysInMonth(yearValInt, i)
			var newVal []map[string]interface{}
			if yVal, isOk := val.([]map[string]interface{}); isOk {
				for _, mv := range yVal {
					if xVal, isOk := mv[x.Field]; isOk {
						pageTime, _ := publicmethod.StringToInt64(xVal)
						if publicmethod.GetIntLength(pageTime) >= 13 {
							startTime = startTime * 1000
							endTime.AllTime = endTime.AllTime * 1000
						}
						if startTime <= pageTime && pageTime <= endTime.AllTime {
							newVal = append(newVal, mv)
						}
					}
				}
			}
			var timeData RadarTimeInfo
			timeData.XName = fmt.Sprintf("%v年%v月", yearVal, i)
			timeData.DataVal = newVal
			jiSuanVal = append(jiSuanVal, timeData)
		}
		charData.ParsingData(jiSuanVal, y)
	}
	return
}

func (r *RadarInfo) ParsingNewData(timeVal []RadarTimeInfo, y YAxisInfo) {
	switch y.Method {
	case 2:
		r.AverageValueesTime(y, timeVal, y.Format)
	case 3:
		r.StatisticalQuantityesTime(y, timeVal, y.Format)
	case 4:
		r.RemoveDuplicateCountssTime(y, timeVal, y.Format)
	case 5:
		r.maxDataesTime(y, timeVal, y.Format)
	case 6:
		r.minDataesTime(y, timeVal, y.Format)
	default:
		r.sumDataesTime(y, timeVal, y.Format)
	}
}

/*
*
@ 作者: 秦东
@ 时间: 2025-07-23 11:33:29
@ 功能: 解析时间模式下的数据
*/
func (r *RadarInfo) ParsingData(timeVal []RadarTimeInfo, y []YAxisInfo) {

	for _, v := range y { //量化指标
		if !publicmethod.IsInTrue[string](v.OldTitle, r.Legend) {
			r.Legend = append(r.Legend, v.OldTitle)
		}

		switch v.Method {
		case 2:
			r.AverageValueesTime(v, timeVal, v.Format)
		case 3:
			r.StatisticalQuantityesTime(v, timeVal, v.Format)
		case 4:
			r.RemoveDuplicateCountssTime(v, timeVal, v.Format)
		case 5:
			r.maxDataesTime(v, timeVal, v.Format)
		case 6:
			r.minDataesTime(v, timeVal, v.Format)
		default:
			r.sumDataesTime(v, timeVal, v.Format)
		}
	}

}

// 平均值
func (r *RadarInfo) AverageValueesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal float64
		jibuqi := 1
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {
					sumVal = sumVal + minVal
					jibuqi++
				}
			}
		}
		var jieguo interface{}
		if sumVal > 0 {
			sumValAvg := sumVal / float64(jibuqi)
			jieguo := publicmethod.DataChuli(sumValAvg, format)
			serData.Value = append(serData.Value, jieguo)
		} else {
			serData.Value = append(serData.Value, 0)
		}

		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= sumVal {
						r.Indicator[ri].Max = sumVal
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

// 计数
func (r *RadarInfo) StatisticalQuantityesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal []float64
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {

					sumVal = append(sumVal, minVal)

				}
			}
		}
		jieguo := float64(len(sumVal))
		serData.Value = append(serData.Value, jieguo)
		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= jieguo {
						r.Indicator[ri].Max = sumVal
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

// 去重计数
func (r *RadarInfo) RemoveDuplicateCountssTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal []float64
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {
					if !publicmethod.IsInTrue[float64](minVal, sumVal) {
						sumVal = append(sumVal, minVal)
					}
				}
			}
		}
		jieguo := float64(len(sumVal))
		serData.Value = append(serData.Value, jieguo)
		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= jieguo {
						r.Indicator[ri].Max = sumVal
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

// 最大值
func (r *RadarInfo) maxDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal float64
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {
					if sumVal <= minVal {
						sumVal = minVal
					}
				}
			}
		}
		jieguo := publicmethod.DataChuli(sumVal, format)
		serData.Value = append(serData.Value, jieguo)
		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= sumVal {
						r.Indicator[ri].Max = sumVal
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

// 最小值
func (r *RadarInfo) minDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal float64
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {
					if sumVal >= minVal {
						sumVal = minVal
					}
				}
			}
		}
		jieguo := publicmethod.DataChuli(sumVal, format)
		serData.Value = append(serData.Value, jieguo)
		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= sumVal {
						r.Indicator[ri].Max = sumVal
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

// 求和
func (r *RadarInfo) sumDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle
	for _, v := range timeVal {
		var sumVal float64
		for _, tv := range v.DataVal {
			if vVal, isOk := tv[y.Field]; isOk {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
				if err == nil {
					sumVal = sumVal + minVal
				}
			}
		}
		jieguo := publicmethod.DataChuli(sumVal, format)
		serData.Value = append(serData.Value, jieguo)
		isWrite := true
		for ri, rv := range r.Indicator {
			if rv.Name == v.XName {
				minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
				if err == nil {
					isWrite = false
					if minVal <= sumVal {

						r.Indicator[ri].Max = sumVal + TianJiaCanshu(sumVal)
					}
				}
			}
		}
		if isWrite {
			var newIndic IndicatorInfo
			newIndic.Name = publicmethod.TypeToInterface(v.XName)
			newIndic.Max = jieguo
			r.Indicator = append(r.Indicator, newIndic)
		}
	}
	r.DataList = append(r.DataList, serData)
}

func TianJiaCanshu(val float64) float64 {
	if val > 100000 {
		return 100000
	} else if val > 10000 {
		return 10000
	} else if val > 1000 {
		return 1000
	} else if val > 100 {
		return 100
	} else {
		return 10
	}
	return 0
}

// 普通字段
func (c *ChartInfo) RadarDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData RadarInfo) {
	var timeList []string //根据维度分组
	if yVal, isOk := val.([]map[string]interface{}); isOk {

		for _, mv := range yVal {
			if xVal, isOk := mv[x.Field]; isOk {
				// fmt.Printf("人员--->%v\n\n", xVal)
				pageTime := publicmethod.TypeToInterface(xVal)
				if !publicmethod.IsInTrue[string](pageTime, timeList) {
					timeList = append(timeList, pageTime)
				}
			}
		}
	}
	//纬度信息
	var weiDu []PicChartInfo
	for _, v := range timeList {
		pickName := DimensionToChinaName(x.Field, v, untis)
		// charData.AnalyRadarData(x.Field, v, y, pickName, val)
		var weiduInfo PicChartInfo
		weiduInfo.Name = v
		weiduInfo.Value = pickName
		weiDu = append(weiDu, weiduInfo)
	}
	charData.AnalyRadarData(x.Field, weiDu, y, val)
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 11:22:34
@ 功能: 解析雷达数据
#xField			x轴设定
w

		# y    Y轴设定
		# val  查询到的值
		#chartType	图标类型
	 1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
	 当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (b *RadarInfo) AnalyRadarData(xField string, x []PicChartInfo, y []YAxisInfo, val interface{}) {
	for _, v := range y {
		b.Legend = append(b.Legend, v.OldTitle)
		switch v.Method {
		case 2:
			b.AverageValuees(v, xField, x, val, v.Format)
		case 3:
			b.StatisticalQuantityes(v, xField, x, val, v.Format)
		case 4:
			b.RemoveDuplicateCountss(v, xField, x, val, v.Format)
		case 5:
			b.maxDataes(v, xField, x, val, v.Format)
		case 6:
			b.minDataes(v, xField, x, val, v.Format)
		default:
			b.sumDataes(v, xField, x, val, v.Format)
		}
	}
}

// 平均值
func (b *RadarInfo) AverageValuees(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal float64
			jibuqi := 1
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								sumVal = sumVal + minVal
								jibuqi++
							}
						}
					}
				}
			}
			if jibuqi > 0 {
				sumValAvg := sumVal / float64(jibuqi)
				jieguo := publicmethod.DataChuli(sumValAvg, format)
				serData.Value = append(serData.Value, jieguo)
				b.WeiDuMaxVal(v.Value, jieguo)
			} else {
				jieguo := 0
				serData.Value = append(serData.Value, jieguo)
				b.WeiDuMaxVal(v.Value, jieguo)
			}

		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}
	b.DataList = append(b.DataList, serData)
}

// 计数
func (b *RadarInfo) StatisticalQuantityes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal []float64
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								sumVal = append(sumVal, minVal)
							}
						}
					}
				}
			}
			jieguo := len(sumVal)
			serData.Value = append(serData.Value, jieguo)
			b.WeiDuMaxVal(v.Value, jieguo)
		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}
	b.DataList = append(b.DataList, serData)
}

// 去重计数
func (b *RadarInfo) RemoveDuplicateCountss(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal []float64
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								if !publicmethod.IsInTrue[float64](minVal, sumVal) {
									sumVal = append(sumVal, minVal)
								}
							}
						}
					}
				}
			}
			jieguo := len(sumVal)
			serData.Value = append(serData.Value, jieguo)
			b.WeiDuMaxVal(v.Value, jieguo)
		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}
	b.DataList = append(b.DataList, serData)
}

// 最大值
func (b *RadarInfo) maxDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal float64 = 0
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								if sumVal <= minVal {
									sumVal = minVal
								}
							}
						}
					}
				}
			}
			jieguo := publicmethod.DataChuli(sumVal, format)
			serData.Value = append(serData.Value, jieguo)
			b.WeiDuMaxVal(v.Value, jieguo)
		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}
	b.DataList = append(b.DataList, serData)
}

// 最小值
func (b *RadarInfo) minDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal float64 = 0
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								if sumVal >= minVal {
									sumVal = minVal
								}
							}
						}
					}
				}
			}
			jieguo := publicmethod.DataChuli(sumVal, format)
			serData.Value = append(serData.Value, jieguo)
			b.WeiDuMaxVal(v.Value, jieguo)
		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}
	b.DataList = append(b.DataList, serData)
}

// 求和
func (b *RadarInfo) sumDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
	var serData DataInfo
	serData.Name = y.OldTitle

	for _, v := range x {
		if yVal, isOk := val.([]map[string]interface{}); isOk {
			var sumVal float64
			for _, mv := range yVal {
				if xVal, isOk := mv[xField]; isOk {
					xValStr := publicmethod.TypeToInterface(xVal)
					if xValStr == v.Name {
						if yval, isOk := mv[y.Field]; isOk {
							minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
							if err == nil {
								sumVal = sumVal + minVal
							}
						}
					}
				}
			}
			jieguo := publicmethod.DataChuli(sumVal, format)
			serData.Value = append(serData.Value, jieguo)
			b.WeiDuMaxVal(v.Value, jieguo)
		} else {
			b.WeiDuMaxVal(v.Value, 0)
		}
	}

	// if yVal, isOk := val.([]map[string]interface{}); isOk {
	// 	for _, xv := range yVal {
	// 		var sumVal float64
	// 		for _, v := range x {
	// 			if vVal, isOk := xv[xField]; isOk {
	// 				if v.Name == publicmethod.TypeToInterface(vVal) {
	// 					if yVal, isOk := xv[y.Field]; isOk {
	// 						minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
	// 						if err == nil {
	// 							sumVal = sumVal + minVal
	// 						}
	// 					}
	// 				}
	// 			}
	// 		}
	// 		serData.Value = append(serData.Value, sumVal)
	// 	}
	// } else {
	// 	for i := 0; i < len(x); i++ {
	// 		serData.Value = append(serData.Value, 0)
	// 	}

	// }

	b.DataList = append(b.DataList, serData)
}

// 组装纬度最大值
func (b *RadarInfo) WeiDuMaxVal(name, val interface{}) {
	isNew := true
	for i, v := range b.Indicator {
		if v.Name == name {
			isNew = false
			valFloat, _ := strconv.ParseFloat(publicmethod.TypeToInterface(val), 64)
			indFloat, _ := strconv.ParseFloat(publicmethod.TypeToInterface(v.Max), 64)
			if valFloat >= indFloat {
				b.Indicator[i].Max = valFloat + 10
			}
		}
	}
	if isNew {
		var newIndic IndicatorInfo
		newIndic.Name = publicmethod.TypeToInterface(name)
		newIndic.Max = val
		b.Indicator = append(b.Indicator, newIndic)
	}
}