package base_from_yongyi

import (
	"eta/eta_data_analysis/models"
	"eta/eta_data_analysis/utils"
	"fmt"
	"github.com/tealeg/xlsx"
	"strconv"
	"strings"
	"time"
)

var YongyiWeeklySheetMap5 map[string]*models.YongyiSheet
var YongyiWeeklySheetMap6 map[string]*models.YongyiSheet
var YongyiWeeklySheetMap9 map[string]*models.YongyiSheet

func init() {
	YongyiWeeklySheetMap5 = map[string]*models.YongyiSheet{
		"周度-50公斤二元母猪价格":    {"50公斤二元母猪价格", "周度-50公斤二元母猪价格", "周度", "元/头"},
		"周度-规模场15公斤仔猪出栏价":  {"规模场15公斤仔猪出栏价", "周度-规模场15公斤仔猪出栏价", "周度", "元/头"},
		"周度-宰后结算价":         {"宰后结算价", "周度-宰后结算价", "周度", "元/公斤"},
		"周度-冻品库存":          {"冻品库存", "周度-冻品库存", "周度", "%"},
		"周度-猪肉价（前三等级白条均价）": {"前三等级白条均价", "周度-猪肉价（前三等级白条均价）", "周度", "元/公斤"},
	}
	YongyiWeeklySheetMap6 = map[string]*models.YongyiSheet{
		"周度-冻品库存多样本": {"冻品库存多样本", "周度-冻品库存多样本", "周度", "%"},
		"月度出栏完成率":    {"出栏完成率", "月度出栏完成率", "旬度", "%"},
	}
	YongyiWeeklySheetMap9 = map[string]*models.YongyiSheet{
		"月度-小猪存栏（2020年5月新增）": {"50kg以下小猪存栏量", "月度-小猪存栏（2020年5月新增）", "月度", "头"},
		"月度-中猪存栏（2020年5月新增）": {"中猪存栏量", "月度-中猪存栏（2020年5月新增）", "月度", "头"},
		"月度-大猪存栏（2020年5月新增）": {"大猪存栏量", "月度-大猪存栏（2020年5月新增）", "月度", "头"},
	}
}

type ExcelDateRecordFirst struct {
	Date time.Time `xlsx:"0"`
}

type ExcelDateRecord struct {
	Date time.Time `xlsx:"1"`
}

// HandleYongyiExcelWeekly1 周度-商品猪出栏价
func HandleYongyiExcelWeekly1(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "周度-商品猪出栏价"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "周度"
	unit := "元/公斤"
	namePrefix := "商品猪出栏价"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	provinceMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 { // 首行，表示时间
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if k > 1 && text != "" {
					// 检查单元格是否为合并单元格
					if cell.HMerge > 0 {
						for j := 1; j <= cell.HMerge; j++ {
							areaMap[k+j] = text
						}
					}
					if cell.VMerge > 0 {
						provinceMap[k] = text
					}
					areaMap[k] = text
				}
			}
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					continue
				} else if k == 1 {
					tmpRow := row
					r := &ExcelDateRecord{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok1 := areaMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的区域，第%d行，第%d列", i, k)
					return
				}
				province, ok2 := provinceMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s/%s", namePrefix, area, province)
				provincePingyin := utils.GetFullPingYin(province)
				areaPingin := utils.GetFirstPingYin(area)
				fullIndexNamePingyin := namePrefixPingin + areaPingin + provincePingyin

				if province == "全  国1" || province == "全  国2" || province == "全国1" || province == "全国2" {
					province = strings.ReplaceAll(province, " ", "")
					fullIndexName = fmt.Sprintf("%s/%s", namePrefix, province)
					fullIndexNamePingyin = namePrefixPingin + provincePingyin
				}

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("indexItem%s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly2 周度-体重
func HandleYongyiExcelWeekly2(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "周度-体重"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "周度"
	unit := "公斤"
	namePrefix := "商品猪出栏体重"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	provinceMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 { // 首行，表示时间
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if k > 2 && text != "" {
					// 检查单元格是否为合并单元格
					if cell.HMerge > 0 {
						for j := 1; j <= cell.HMerge; j++ {
							areaMap[k+j] = text
						}
					}
					if cell.VMerge > 0 {
						provinceMap[k] = text
					}
					areaMap[k] = text
				}
			}
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			name := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					continue
				} else if k == 1 {
					tmpRow := row
					r := &ExcelDateRecord{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else if k == 2 {
					name = text
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok1 := areaMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的区域，第%d行，第%d列", i, k)
					return
				}
				province, ok2 := provinceMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s/%s/%s", namePrefix, area, province, name)
				provincePingyin := utils.GetFullPingYin(province)
				areaPingin := utils.GetFirstPingYin(area)
				namePingin := utils.GetFirstPingYin(name)
				fullIndexNamePingyin := namePrefixPingin + areaPingin + provincePingyin + namePingin

				if province == "全  国1" || province == "全  国2" || province == "全国1" || province == "全国2" {
					province = strings.ReplaceAll(province, " ", "")
					fullIndexName = fmt.Sprintf("%s/%s/%s", namePrefix, province, name)
					fullIndexNamePingyin = namePrefixPingin + provincePingyin + namePingin
				}
				if name == "90kg以下" || name == "150kg以上" {
					unit = "%"
				}
				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("indexItem%s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly3 周度-屠宰厂宰前活猪重
func HandleYongyiExcelWeekly3(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "周度-屠宰厂宰前活猪重"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "周度"
	unit := "公斤"
	namePrefix := "商品猪宰前活猪重"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	provinceMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i < 2 {
			continue
		}
		if i == 2 { // 首行，表示时间
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if k > 2 && text != "" {
					// 检查单元格是否为合并单元格
					if cell.VMerge > 0 {
						provinceMap[k] = text
					}
				}
			}
		} else if i == 3 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					continue
				} else if k == 1 {
					tmpRow := row
					r := &ExcelDateRecord{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else if k == 2 {
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				province, ok2 := provinceMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if province == "较上周" {
					continue
				} else if province == "全国平均" {
					province = "全国"
				}
				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, province)
				provincePingyin := utils.GetFullPingYin(province)
				fullIndexNamePingyin := namePrefixPingin + provincePingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("indexItem%s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly4 周度-各体重段价差
func HandleYongyiExcelWeekly4(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "周度-各体重段价差"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "周度"
	unit := "元/斤"
	namePrefixPingin := "yyzx"

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	provinceMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 {
			continue
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			name := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					continue
				} else if k == 1 {
					tmpRow := row
					r := &ExcelDateRecord{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else if k == 2 {
					name = text
					if name == "标猪" {
						name += "价格"
					} else {
						name += "猪价格"
					}
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				province, ok2 := provinceMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if name != "标猪价格" && name != "150kg猪价格" && name != "175kg猪价格" && name != "200kg猪价格" {
					continue
				}

				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", name, province)
				provincePingyin := utils.GetFullPingYin(province)
				namePingin := utils.GetFirstPingYin(name)
				fullIndexNamePingyin := namePrefixPingin + namePingin + provincePingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly5 周度-50公斤二元母猪价格
func HandleYongyiExcelWeekly5(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	info, ok := YongyiWeeklySheetMap5[sheet.Name]
	if !ok {
		return
	}
	classifyName := info.ClassifyName
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := info.Frequency
	unit := info.Unit
	namePrefix := info.NamePrefix
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)
	/*classifyName := "周度-50公斤二元母猪价格"
	frequency := "周度"
	unit := "元/头"
	namePrefix := "50公斤二元母猪价格"
	namePrefixPingin := "yyzx50gjeymzjg"*/

	/*	classifyName := "周度-规模场15公斤仔猪出栏价"
		frequency := "周度"
		unit := "元/头"
		namePrefix := "规模场15公斤仔猪出栏价"
		namePrefixPingin := "yyzxgmc15gjzzclj"*/

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	provinceMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 {
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if k > 1 && text != "" {
					if cell.VMerge > 0 {
						provinceMap[k] = text
					}
				}
			}
			continue
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					continue
				} else if k == 1 {
					tmpRow := row
					r := &ExcelDateRecord{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				province, ok2 := provinceMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if province == "全  国1" || province == "全  国2" || province == "全国1" || province == "全国2" {
					province = strings.ReplaceAll(province, " ", "")
				}
				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, province)
				provincePingyin := utils.GetFullPingYin(province)
				fullIndexNamePingyin := namePrefixPingin + provincePingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly6 周度-冻品库存多样本
func HandleYongyiExcelWeekly6(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	info, ok := YongyiWeeklySheetMap6[sheet.Name]
	if !ok {
		return
	}
	classifyName := info.ClassifyName
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := info.Frequency
	unit := info.Unit
	namePrefix := info.NamePrefix
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)
	/*classifyName := "周度-冻品库存多样本"
	frequency := "周度"
	unit := "%"
	namePrefix := "冻品库存多样本"
	namePrefixPingin := "yyzxdpkcdyb"*/

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 {
			continue
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					areaMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					tmpRow := row
					r := &ExcelDateRecordFirst{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					date = r.Date.Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok2 := areaMap[k]
				if !ok2 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				fmt.Printf("当前第%d行第%d列, 当前省份%s \n", i, k, area)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, area)
				areaPingyin := utils.GetFirstPingYin(area)
				if sheet.Name == "月度出栏完成率" {
					areaPingyin = utils.GetFullPingYin(area)
				}
				fullIndexNamePingyin := namePrefixPingin + areaPingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly7 月度计划出栏量
func HandleYongyiExcelWeekly7(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "月度计划出栏量"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "月度"
	unit := "%"
	namePrefix := "月度计划出栏量环比"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	provinceMap := make(map[int]string)
	firstMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 {
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					firstMap[k] = text
				}
			}
			continue
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					provinceMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					tmpRow := row
					r := &ExcelDateRecordFirst{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					// 查询当月的最后一天
					monthDate := r.Date.Format(utils.FormatYearMonthDate)
					firstDayStr := monthDate + "-01"
					tmpT, _ := time.ParseInLocation(utils.FormatDate, firstDayStr, time.Local)
					date = tmpT.AddDate(0, 1, -1).Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				province, ok1 := provinceMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if province == "本月计划较上月实际销售" {
					continue
				}
				fmt.Printf("当前第%d行第%d列, 当前省份: %s \n", i, k, province)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, province)
				provincePingyin := utils.GetFullPingYin(province)
				fullIndexNamePingyin := namePrefixPingin + provincePingyin

				if province == "数量" {
					first, ok2 := firstMap[k]
					if !ok2 {
						continue
					}
					fullIndexName = first
					firstPingyin := utils.GetFirstPingYin(first)
					fullIndexNamePingyin = "yyzx" + firstPingyin
					unit = "万头"
				}

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s\n", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly8 月度-能繁母猪存栏（2020年2月新增）
func HandleYongyiExcelWeekly8(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "月度-能繁母猪存栏（2020年2月新增）"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "月度"
	unit := "头"
	namePrefix := "能繁母猪存栏量"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i <= 2 {
			continue
		} else if i == 3 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					areaMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					tmpRow := row
					r := &ExcelDateRecordFirst{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					// 查询当月的最后一天
					monthDate := r.Date.Format(utils.FormatYearMonthDate)
					firstDayStr := monthDate + "-01"
					tmpT, _ := time.ParseInLocation(utils.FormatDate, firstDayStr, time.Local)
					date = tmpT.AddDate(0, 1, -1).Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok1 := areaMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if area == "环比" || area == "日期" || area == "同比" {
					continue
				}
				fmt.Printf("当前第%d行第%d列, 当前省份: %s \n", i, k, area)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, area)
				areaPingyin := utils.GetFirstPingYin(area)
				fullIndexNamePingyin := namePrefixPingin + areaPingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s\n", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly9 月度-小猪存栏（2020年5月新增）
func HandleYongyiExcelWeekly9(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	info, ok := YongyiWeeklySheetMap9[sheet.Name]
	if !ok {
		return
	}
	classifyName := info.ClassifyName
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := info.Frequency
	unit := info.Unit
	namePrefix := info.NamePrefix
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i <= 1 {
			continue
		} else if i == 2 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					areaMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					tmpRow := row
					r := &ExcelDateRecordFirst{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					// 查询当月的最后一天
					monthDate := r.Date.Format(utils.FormatYearMonthDate)
					firstDayStr := monthDate + "-01"
					tmpT, _ := time.ParseInLocation(utils.FormatDate, firstDayStr, time.Local)
					date = tmpT.AddDate(0, 1, -1).Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok1 := areaMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if area == "环比" || area == "日期" || area == "同比" {
					continue
				}
				fmt.Printf("当前第%d行第%d列, 当前省份: %s \n", i, k, area)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, area)
				areaPingyin := utils.GetFirstPingYin(area)
				fullIndexNamePingyin := namePrefixPingin + areaPingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s\n", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}

// HandleYongyiExcelWeekly10 月度-商品猪出栏量
func HandleYongyiExcelWeekly10(sheet *xlsx.Sheet) (indexList []*models.YongyiExcelIndex, err error) {
	classifyName := "月度-商品猪出栏量"
	classifyMap := getClassifySortMap()
	classifySort, _ := classifyMap[classifyName]
	frequency := "月度"
	unit := "头"
	namePrefix := "商品猪出栏量"
	namePrefixPingin := "yyzx" + utils.GetFirstPingYin(namePrefix)

	// 遍历行读取
	indexList = make([]*models.YongyiExcelIndex, 0)
	areaMap := make(map[int]string)
	maxRow := sheet.MaxRow
	sort := 0
	fmt.Println("最大行")
	fmt.Println(maxRow)
	// 指标名称
	indexMap := make(map[string]*models.YongyiExcelIndex)
	for i := 0; i < maxRow; i++ {
		fmt.Printf("当前第%d行 \n", i)
		if i == 0 {
			continue
		} else if i == 1 { //表示表头
			// 处理 index指标表
			row := sheet.Row(i)
			cells := row.Cells
			for k, cell := range cells {
				text := cell.String()
				if text != "" {
					areaMap[k] = text
				}
			}
		} else { //数据列
			row := sheet.Row(i)
			cells := row.Cells
			date := ""
			for k, cell := range cells {
				fmt.Printf("当前第%d列 \n", k)
				text := cell.String()
				if k == 0 {
					tmpRow := row
					r := &ExcelDateRecordFirst{}
					if e := tmpRow.ReadStruct(r); e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 读取行，时间列失败 Err:%s", sheet.Name, i, k, e))
						continue
					}
					// 查询当月的最后一天
					monthDate := r.Date.Format(utils.FormatYearMonthDate)
					firstDayStr := monthDate + "-01"
					tmpT, _ := time.ParseInLocation(utils.FormatDate, firstDayStr, time.Local)
					date = tmpT.AddDate(0, 1, -1).Format(utils.FormatDate)
					fmt.Println(date)
					continue
				} else {
					// 判断出不是字符的，则过滤
					if text == "" {
						continue
					}
					if strings.Contains(text, "%") {
						text = strings.Replace(text, "%", "", 1)
					}
					_, e := strconv.ParseFloat(text, 64)
					if e != nil {
						utils.FileLog.Info(fmt.Sprintf("sheet：%s 第%d行, 第%d列 strconv.ParseFloat Err:%s", sheet.Name, i, k, e))
						continue
					}
				}

				area, ok1 := areaMap[k]
				if !ok1 {
					err = fmt.Errorf("找不到对应的列名，第%d行，第%d列", i, k)
					return
				}
				if area == "环比" || area == "日期" || area == "同比" || area == "较非瘟前" {
					continue
				}
				fmt.Printf("当前第%d行第%d列, 当前省份: %s \n", i, k, area)
				// 处理指标名称
				fullIndexName := fmt.Sprintf("%s/%s", namePrefix, area)
				areaPingyin := utils.GetFirstPingYin(area)
				fullIndexNamePingyin := namePrefixPingin + areaPingyin

				indexItem, okIndex := indexMap[fullIndexName]
				if !okIndex {
					// 新增指标
					indexItem = new(models.YongyiExcelIndex)
					indexItem.IndexName = fullIndexName
					indexItem.ClassifyName = classifyName
					indexItem.ClassifySort = classifySort
					indexItem.IndexCode = fullIndexNamePingyin
					indexItem.Frequency = frequency
					indexItem.Sort = sort
					indexItem.Unit = unit
					indexItem.ExcelDataMap = make(map[string]string)
					sort++
				}
				fmt.Printf("IndexCode: %s\n", indexItem.IndexCode)

				indexItem.ExcelDataMap[date] = text
				indexMap[fullIndexName] = indexItem
				continue
			}
		}
	}
	for _, v := range indexMap {
		indexList = append(indexList, v)
	}
	return
}
