package main

import (
	"fmt"
	"github.com/xuri/excelize/v2"
	"math/big"
	"reflect"
	"sort"
	"strconv"
	"strings"
)

//isGreaterThanHalf 是否大于一半
func isGreaterThanHalf(x interface{}) bool {
	switch v := x.(type) {
	case string:
		f, err := strconv.ParseFloat(v, 64)
		if err != nil {
			return false
		}
		return f > 0.5
	case float64:
		return v > 0.5
	case int:
		return float64(v) > 0.5
	case int64:
		return float64(v) > 0.5
	default:
		return false
	}
}

func IntAll(num interface{}) int {
	return IntAllDef(num, 0)
}
func IntAllDef(num interface{}, defaultNum int) int {
	if i, ok := num.(int); ok {
		return int(i)
	} else if i0, ok0 := num.(int32); ok0 {
		return int(i0)
	} else if i1, ok1 := num.(float64); ok1 {
		return int(i1)
	} else if i2, ok2 := num.(int64); ok2 {
		return int(i2)
	} else if i3, ok3 := num.(float32); ok3 {
		return int(i3)
	} else if i4, ok4 := num.(string); ok4 {
		in, _ := strconv.Atoi(i4)
		return int(in)
	} else if i5, ok5 := num.(int16); ok5 {
		return int(i5)
	} else if i6, ok6 := num.(int8); ok6 {
		return int(i6)
	} else if i7, ok7 := num.(*big.Int); ok7 {
		in, _ := strconv.Atoi(fmt.Sprint(i7))
		return int(in)
	} else if i8, ok8 := num.(*big.Float); ok8 {
		in, _ := strconv.Atoi(fmt.Sprint(i8))
		return int(in)
	} else {
		return defaultNum
	}
}

func Int64All(num interface{}) int64 {
	if i, ok := num.(int64); ok {
		return int64(i)
	} else if i0, ok0 := num.(int32); ok0 {
		return int64(i0)
	} else if i1, ok1 := num.(float64); ok1 {
		return int64(i1)
	} else if i2, ok2 := num.(int); ok2 {
		return int64(i2)
	} else if i3, ok3 := num.(float32); ok3 {
		return int64(i3)
	} else if i4, ok4 := num.(string); ok4 {
		i64, _ := strconv.ParseInt(i4, 10, 64)
		//in, _ := strconv.Atoi(i4)
		return i64
	} else if i5, ok5 := num.(int16); ok5 {
		return int64(i5)
	} else if i6, ok6 := num.(int8); ok6 {
		return int64(i6)
	} else if i7, ok7 := num.(*big.Int); ok7 {
		in, _ := strconv.ParseInt(fmt.Sprint(i7), 10, 64)
		return int64(in)
	} else if i8, ok8 := num.(*big.Float); ok8 {
		in, _ := strconv.ParseInt(fmt.Sprint(i8), 10, 64)
		return int64(in)
	} else {
		return 0
	}
}

func Float64All(num interface{}) float64 {
	if i, ok := num.(float64); ok {
		return float64(i)
	} else if i0, ok0 := num.(int32); ok0 {
		return float64(i0)
	} else if i1, ok1 := num.(int64); ok1 {
		return float64(i1)
	} else if i2, ok2 := num.(int); ok2 {
		return float64(i2)
	} else if i3, ok3 := num.(float32); ok3 {
		return float64(i3)
	} else if i4, ok4 := num.(string); ok4 {
		in, _ := strconv.ParseFloat(i4, 64)
		return in
	} else if i5, ok5 := num.(int16); ok5 {
		return float64(i5)
	} else if i6, ok6 := num.(int8); ok6 {
		return float64(i6)
	} else if i6, ok6 := num.(uint); ok6 {
		return float64(i6)
	} else if i6, ok6 := num.(uint8); ok6 {
		return float64(i6)
	} else if i6, ok6 := num.(uint16); ok6 {
		return float64(i6)
	} else if i6, ok6 := num.(uint32); ok6 {
		return float64(i6)
	} else if i6, ok6 := num.(uint64); ok6 {
		return float64(i6)
	} else if i7, ok7 := num.(*big.Float); ok7 {
		in, _ := strconv.ParseFloat(fmt.Sprint(i7), 64)
		return float64(in)
	} else if i8, ok8 := num.(*big.Int); ok8 {
		in, _ := strconv.ParseFloat(fmt.Sprint(i8), 64)
		return float64(in)
	} else {
		return 0
	}
}

func ObjToString(old interface{}) string {
	if nil == old {
		return ""
	} else {
		r, _ := old.(string)
		return r
	}
}

//DeduplicateByField 去重 []map 中，field 相同的数据
func DeduplicateByField(maps []map[string]interface{}, field string) []map[string]interface{} {
	result := []map[string]interface{}{}
	cache := make(map[string]bool)

	for _, m := range maps {
		if name, ok := m[field].(string); ok {
			if !cache[name] {
				result = append(result, m)
				cache[name] = true
			}
		}
	}
	return result
}

//IsInStringArray 判断数组中是否存在字符串
func IsInStringArray(str string, arr []string) bool {
	// 先对字符串数组进行排序
	sort.Strings(arr)
	// 使用二分查找算法查找字符串
	pos := sort.SearchStrings(arr, str)
	// 如果找到了则返回 true，否则返回 false
	return pos < len(arr) && arr[pos] == str
}

func isInMapArray(data map[string]interface{}, arr []map[string]interface{}) bool {
	for _, item := range arr {
		if reflect.DeepEqual(item, data) {
			return true
		}
	}
	return false
}

//traverseDataInvest 处理投资下级数据
func traverseDataInvest(xlsx *excelize.File, data []map[string]interface{}, level int) {
	if len(data) <= 0 {
		return
	}
	if level > GF.Env.Invesl {
		return
	}
	//var currentLine int
	Sheet := fmt.Sprintf("投资下级%v", level)
	preSheet := fmt.Sprintf("投资下级%v", level-1)

	currentLine := lineMap[Sheet]
	preLine := lineMap[preSheet]

	for k, v := range data {
		inves := getInvests(v["company_id"].(string))
		invest := dealInves(inves)
		if len(invest) <= 0 {
			return
		}

		if len(invest) > 0 {
			fmt.Println("开始投资公司下级", level, v["company_name"])
			_, currentLine = setInvest(xlsx, invest, ObjToString(v["company_name"]), Sheet, currentLine)
			lineMap[Sheet] = currentLine
			linkCell := fmt.Sprintf("B%d", preLine-len(data)+1+k)
			linkAddr := fmt.Sprintf("%s!C%d", Sheet, currentLine-len(invest)+1)
			link := map[string]string{
				"sheet": preSheet,
				"cell":  linkCell,
				"addr":  linkAddr,
				"value": "下级",
			}
			links = append(links, link)
			//
			AlinkAddr := fmt.Sprintf("%s!C%d", preSheet, preLine-len(data)+1+k)
			for t := currentLine - len(invest) + 1; t <= currentLine; t++ {
				AlinkCell := fmt.Sprintf("A%d", t)
				Alink := map[string]string{
					"sheet": Sheet,
					"cell":  AlinkCell,
					"addr":  AlinkAddr,
					"value": "上级",
				}
				links = append(links, Alink)
			}

			traverseDataInvest(xlsx, invest, level+1)
		}
	}
}

//traverseDataSub 处理分支机构下级数据
func traverseDataSub(xlsx *excelize.File, data []map[string]interface{}, level int) {
	if len(data) <= 0 {
		return
	}
	if level > GF.Env.Subl {
		return
	}

	Sheet := fmt.Sprintf("分支下级%v", level)
	preSheet := fmt.Sprintf("分支下级%v", level-1)
	currentLine := lineMap[Sheet]
	preline := lineMap[preSheet]

	for k, v := range data {
		if v["branch_company_id"] == nil {
			continue
		}
		fmt.Println("开始 分支机构 下级 ", level, v["branch_name"])

		subs := getSubCompany(v["branch_company_id"].(string))
		subData := dealSubs(subs)
		if len(subData) <= 0 {
			return
		}

		if len(subData) > 0 {
			fmt.Println("开始分支下级", level, v["company_name"])
			_, currentLine = setSubCompany(xlsx, data, v["branch_name"].(string), Sheet, currentLine)

			linkCell := fmt.Sprintf("B%d", preline-len(data)+1+k)
			linkAddr := fmt.Sprintf("%s!C%d", Sheet, currentLine-len(subData)+1)
			link := map[string]string{
				"sheet": preSheet,
				"cell":  linkCell,
				"addr":  linkAddr,
				"value": "下级",
			}
			links = append(links, link)
			AlinkAddr := fmt.Sprintf("%s!C%d", preSheet, preline-len(data)+1+k)
			for t := currentLine - len(subData) + 1; t <= currentLine; t++ {
				AlinkCell := fmt.Sprintf("A%d", t)
				Alink := map[string]string{
					"sheet": Sheet,
					"cell":  AlinkCell,
					"addr":  AlinkAddr,
					"value": "上级",
				}
				links = append(links, Alink)
			}

			traverseDataSub(xlsx, subData, level+1)
		}
	}

}

func dealLast(xlsx *excelize.File) {
	fmt.Println("22222222222222222222222222")
	xlsx.NewSheet("最后数据")
	var line int
	line++
	xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", line), &[]interface{}{"L0", "name", "L2", "控股比例", "登记状态", "统一信用代码", "省", "市", "区"})

	for _, v := range L0names {
		oldData := LastData[v]
		newData := lastRes[v]
		if len(newData) >= len(oldData) {
			for k, data := range newData {
				newda, _ := data.([]interface{})
				if k+1 <= len(oldData) {
					oldda, _ := oldData[k].([]interface{})
					line++
					xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", line), &[]interface{}{newda[0], newda[1], oldda[1], newda[2], newda[3], newda[4], newda[5], newda[6], newda[7]})
				} else {
					line++
					xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", line), &[]interface{}{newda[0], newda[1], "", newda[2], newda[3], newda[4], newda[5], newda[6], newda[7]})
				}
			}

		} else {
			for k, data := range oldData {
				oldda, _ := data.([]interface{})
				if k+1 <= len(newData) {
					newda, _ := newData[k].([]interface{})
					line++
					xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", line), &[]interface{}{oldda[0], newda[1], oldda[1], newda[2], newda[3], newda[4], newda[5], newda[6], newda[7]})

				} else {
					line++
					xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", line), &[]interface{}{oldda[0], "", oldda[1]})

				}
			}
		}
	}

	//for k, v := range final {
	//	err := xlsx.SetSheetRow("最后数据", fmt.Sprintf("A%v", k+1), &v)
	//	if err != nil {
	//		fmt.Println(err)
	//	}
	//}

	fmt.Println("最后数据 sheet 结束")
}

//traverInvestP 投资上级
func traverInvestP(xlsx *excelize.File, data []map[string]interface{}, level int) {
	if len(data) <= 0 {
		return
	}

	if level == GF.Env.Pinvesl {
		for _, v := range data {
			if v["stock_type"] == "自然人股东" || v["stock_type"] == "外国（地区）企业" && (v["company_area"] == "" || v["company_area"] == nil) || strings.HasSuffix(v["stock_name"].(string), "国务院") || strings.HasSuffix(v["stock_name"].(string), "国资委") || strings.HasSuffix(v["stock_name"].(string), "国有资产监督管理委员会") || strings.Contains(v["stock_name"].(string), "财政厅") || v["is_break"] == true {
				continue
			}
			tmp := []interface{}{L0, v["stock_name"]}
			if !IsContained(tmp, lastRes[L0]) {
				lastRes[L0] = append(lastRes[L0], tmp)
			}
		}
		return
	}

	Sheet := fmt.Sprintf("投资上级%v", level)      //投资上级2
	preSheet := fmt.Sprintf("投资上级%v", level-1) //投资上级1

	currentLine := lineMap[Sheet]
	preLine := lineMap[preSheet]

	for k, v := range data {
		fmt.Println("开始投资公司上级 ---------------", level, v["company_name"].(string))
		pinves := getParentsByPartner(v["stock_name_id"].(string))
		datas, isbreak := dealPinves(pinves, level)
		if len(datas) == 0 {
			return
		}

		_, currentLine = setInvestP(xlsx, datas, v["company_name"].(string), Sheet, currentLine)
		lineMap[Sheet] = currentLine
		linkCell := fmt.Sprintf("B%d", preLine-len(data)+k+1)
		linkAddr := fmt.Sprintf("%s!C%d", Sheet, currentLine-len(datas)+1)
		link := map[string]string{
			"sheet": preSheet,
			"cell":  linkCell,
			"addr":  linkAddr,
			"value": "上级",
		}
		links = append(links, link)

		AlinkAddr2 := fmt.Sprintf("%s!A%d", preSheet, preLine-len(data)+k+1)
		for t := currentLine - len(datas) + 1; t <= currentLine; t++ {
			AlinkCell2 := fmt.Sprintf("A%d", t)
			Alink2 := map[string]string{
				"sheet": Sheet,
				"cell":  AlinkCell2,
				"addr":  AlinkAddr2,
				"value": "下级",
			}
			links = append(links, Alink2)
		}

		if v["stock_name"] == nil {
			continue
		}
		if v["stock_type"] == "自然人股东" {
			continue
		}

		if v["stock_type"] == "自然人股东" || v["stock_type"] == "外国（地区）企业" && (v["company_area"] == "" || v["company_area"] == nil) || strings.HasSuffix(v["stock_name"].(string), "国务院") || strings.HasSuffix(v["stock_name"].(string), "国资委") || strings.HasSuffix(v["stock_name"].(string), "国有资产监督管理委员会") || strings.Contains(v["stock_name"].(string), "财政厅") || v["is_break"] == true {
			continue
		}

		if level+1 <= GF.Env.Pinvesl {
			if isbreak {
				continue
			} else {
				traverInvestP(xlsx, datas, level+1)
			}
		}

	}

}

//traverSubP 分支上级
func traverSubP(xlsx *excelize.File, data []map[string]interface{}, level int) {
	if len(data) <= 0 {
		return
	}

	if level > GF.Env.Psubl {
		return
	}

	Sheet := fmt.Sprintf("分支上级%v", level)      //投资上级2
	preSheet := fmt.Sprintf("分支上级%v", level-1) //投资上级1

	currentLine := lineMap[Sheet]
	preLine := lineMap[preSheet]
	for k, v := range data {
		if v["company_id"] == nil {
			continue
		}
		if v["company_name"] == nil {
			fmt.Println("2222333333")
		}
		fmt.Println("开始分支上级 ---------------", level, v["branch_name"].(string))

		datas := getParentsByBranch(v["company_id"].(string))
		res := dealPsubs(datas)
		if len(res) == 0 {
			continue
		}

		_, currentLine = setSubP(xlsx, res, v["company_name"].(string), Sheet, currentLine)
		lineMap[Sheet] = currentLine
		linkCell := fmt.Sprintf("B%d", preLine-len(data)+k+1)
		linkAddr := fmt.Sprintf("%s!C%d", Sheet, currentLine-len(res)+1)
		link := map[string]string{
			"sheet": preSheet,
			"cell":  linkCell,
			"addr":  linkAddr,
			"value": "上级",
		}
		links = append(links, link)

		AlinkAddr2 := fmt.Sprintf("%s!A%d", preSheet, preLine+k+1)
		for t := currentLine - len(res) + 1; t < currentLine; t++ {
			AlinkCell2 := fmt.Sprintf("A%d", t)
			Alink2 := map[string]string{
				"sheet": Sheet,
				"cell":  AlinkCell2,
				"addr":  AlinkAddr2,
				"value": "下级",
			}
			links = append(links, Alink2)
		}

		//
		if v["company_id"] == nil || v["company_name"] == nil {
			continue
		}

		if strings.HasSuffix(v["company_name"].(string), "国务院") || strings.HasSuffix(v["company_name"].(string), "国资委") || strings.HasSuffix(v["company_name"].(string), "国有资产监督管理委员会") {
			continue
		}

		if level+1 < GF.Env.Psubl {
			traverSubP(xlsx, res, level+1)
		}
	}

}

//IsContained 判断一个切片是否存在 另外一个切片数组中
func IsContained(target []interface{}, container []interface{}) bool {
	for _, v := range container {
		if reflect.DeepEqual(v, target) {
			return true
		}
	}
	return false
}