package ul

import (
	"bytes"
	"encoding/json"
	"fmt"
	log "github.com/donnie4w/go-logger/logger"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"io/ioutil"
	qu "jygit.jydev.jianyu360.cn/data_processing/common_utils"
	"net/http"
	"net/url"
	"strings"
	"time"
)

func InitGlobalVar() {
	qu.ReadConfig(&SysConfig) //加载配置文件
	initMgo()
	initOther()
	initPCD()
}
func InitToolVar() {
	qu.ReadConfig("./tool.json", &ToolConfig) //加载配置文件
	if len(ToolConfig) == 0 || ToolConfig == nil {
		log.Fatal("缺少tool.json文件")
	}
	initToolMgo()
	initToolOther()
	initPCD()
	InitToolRules()
}

// 其它属性
func initOther() {
	//glm-4-air glm-4-flash
	FlashModel = qu.ObjToString(SysConfig["flash_model"])
	ModelType = qu.ObjToString(SysConfig["model_type"])
	MaxUdp = qu.IntAllDef(SysConfig["udp_max"], 10000)
	MaxLen = qu.IntAllDef(SysConfig["len_max"], 20000)
	MaxByte = qu.IntAllDef(SysConfig["byte_max"], 50000)
}

// 其它属性
func initToolOther() {
	//glm-4-air glm-4-flash
	FlashModel = qu.ObjToString(ToolConfig["flash_model"])
	ModelType = qu.ObjToString(ToolConfig["model_type"])
	MaxUdp = qu.IntAllDef(ToolConfig["udp_max"], 10000)
	MaxLen = qu.IntAllDef(ToolConfig["len_max"], 20000)
	MaxByte = qu.IntAllDef(ToolConfig["byte_max"], 50000)
}

// 初始化mgo
func initMgo() {
	Reading = qu.IntAll(SysConfig["reading"])
	if Reading == 0 {
		Reading = 500
	}
	Bid_Name, Ext_Name = qu.ObjToString(SysConfig["bid_name"]), qu.ObjToString(SysConfig["ext_name"])
	//源数据
	b_cfg := *qu.ObjToMap(SysConfig["b_mgo"])
	b_local := b_cfg["local"].(bool)
	b_addr := qu.ObjToString(b_cfg["addr"])
	if b_local {
		b_addr = qu.ObjToString(b_cfg["l_addr"])
	}
	BidMgo = &MongodbSim{
		MongodbAddr: b_addr,
		DbName:      qu.ObjToString(b_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(b_cfg["username"]),
		Password:    qu.ObjToString(b_cfg["password"]),
	}
	if b_local {
		BidMgo.InitPoolDirect()
	} else {
		BidMgo.InitPool()
	}

	//源数据
	s_cfg := *qu.ObjToMap(SysConfig["s_mgo"])
	s_local := s_cfg["local"].(bool)
	s_addr := qu.ObjToString(s_cfg["addr"])
	if s_local {
		s_addr = qu.ObjToString(s_cfg["l_addr"])
	}
	SourceMgo = &MongodbSim{
		MongodbAddr: s_addr,
		DbName:      qu.ObjToString(s_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(s_cfg["username"]),
		Password:    qu.ObjToString(s_cfg["password"]),
	}
	if s_local {
		SourceMgo.InitPoolDirect()
	} else {
		SourceMgo.InitPool()
	}

	//企业数据
	qy_cfg := *qu.ObjToMap(SysConfig["qy_mgo"])
	qy_local := qy_cfg["local"].(bool)
	qy_addr := qu.ObjToString(qy_cfg["addr"])
	if qy_local {
		qy_addr = qu.ObjToString(qy_cfg["l_addr"])
	}
	QyxyMgo = &MongodbSim{
		MongodbAddr: qy_addr,
		DbName:      qu.ObjToString(qy_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(qy_cfg["username"]),
		Password:    qu.ObjToString(qy_cfg["password"]),
	}
	if qy_local {
		QyxyMgo.InitPoolDirect()
	} else {
		QyxyMgo.InitPool()
	}

	//企业数据
	py_cfg := *qu.ObjToMap(SysConfig["py_mgo"])
	py_local := py_cfg["local"].(bool)
	py_addr := qu.ObjToString(py_cfg["addr"])
	if py_local {
		py_addr = qu.ObjToString(py_cfg["l_addr"])
	}
	PyMgo = &MongodbSim{
		MongodbAddr: py_addr,
		DbName:      qu.ObjToString(py_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(py_cfg["username"]),
		Password:    qu.ObjToString(py_cfg["password"]),
	}
	if py_local {
		PyMgo.InitPoolDirect()
	} else {
		PyMgo.InitPool()
	}
}

// 初始化mgo
func initToolMgo() {
	Reading, Ext_Name = qu.IntAll(ToolConfig["reading"]), qu.ObjToString(ToolConfig["ext_name"])
	if Reading == 0 {
		Reading = 500
	}
	//源数据
	b_cfg := *qu.ObjToMap(ToolConfig["b_mgo"])
	b_local := b_cfg["local"].(bool)
	b_addr := qu.ObjToString(b_cfg["addr"])
	if b_local {
		b_addr = qu.ObjToString(b_cfg["l_addr"])
	}
	BidMgo = &MongodbSim{
		MongodbAddr: b_addr,
		DbName:      qu.ObjToString(b_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(b_cfg["username"]),
		Password:    qu.ObjToString(b_cfg["password"]),
	}
	if b_local {
		BidMgo.InitPoolDirect()
	} else {
		BidMgo.InitPool()
	}

	//源数据
	s_cfg := *qu.ObjToMap(ToolConfig["s_mgo"])
	s_local := s_cfg["local"].(bool)
	s_addr := qu.ObjToString(s_cfg["addr"])
	if s_local {
		s_addr = qu.ObjToString(s_cfg["l_addr"])
	}
	SourceMgo = &MongodbSim{
		MongodbAddr: s_addr,
		DbName:      qu.ObjToString(s_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(s_cfg["username"]),
		Password:    qu.ObjToString(s_cfg["password"]),
	}
	if s_local {
		SourceMgo.InitPoolDirect()
	} else {
		SourceMgo.InitPool()
	}

	//企业数据
	qy_cfg := *qu.ObjToMap(ToolConfig["qy_mgo"])
	qy_local := qy_cfg["local"].(bool)
	qy_addr := qu.ObjToString(qy_cfg["addr"])
	if qy_local {
		qy_addr = qu.ObjToString(qy_cfg["l_addr"])
	}
	QyxyMgo = &MongodbSim{
		MongodbAddr: qy_addr,
		DbName:      qu.ObjToString(qy_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(qy_cfg["username"]),
		Password:    qu.ObjToString(qy_cfg["password"]),
	}
	if qy_local {
		QyxyMgo.InitPoolDirect()
	} else {
		QyxyMgo.InitPool()
	}
}

// 标准化省市区···
func initPCD() {
	S_ProvinceDict = make(map[string][]S_Province, 0)
	S_CityDict = make(map[string][]S_City, 0)
	S_DistrictDict = make(map[string][]S_District, 0)
	q := map[string]interface{}{
		"town_code": map[string]interface{}{
			"$exists": 0,
		},
	}
	dataArr, _ := QyxyMgo.Find("address_jy_2022", q, nil, nil)
	for _, tmp := range dataArr {
		district_code := qu.IntAll(tmp["district_code"])
		city_code := qu.IntAll(tmp["city_code"])
		if district_code > 0 {
			province := qu.ObjToString(tmp["province"])
			city := qu.ObjToString(tmp["city"])
			district := qu.ObjToString(tmp["district"])
			data := S_District{province, city, district}
			if S_DistrictDict[district] == nil {
				S_DistrictDict[district] = []S_District{data}
			} else {
				arr := S_DistrictDict[district]
				arr = append(arr, data)
				S_DistrictDict[district] = arr
			}
		} else {
			if city_code > 0 {
				province := qu.ObjToString(tmp["province"])
				city := qu.ObjToString(tmp["city"])
				data := S_City{province, city}
				if S_CityDict[city] == nil {
					S_CityDict[city] = []S_City{data}
				} else {
					arr := S_CityDict[city]
					arr = append(arr, data)
					S_CityDict[city] = arr
				}
			} else {
				province := qu.ObjToString(tmp["province"])
				data := S_Province{province}
				if S_ProvinceDict[province] == nil {
					S_ProvinceDict[province] = []S_Province{data}
				} else {
					arr := S_ProvinceDict[province]
					arr = append(arr, data)
					S_ProvinceDict[province] = arr
				}
			}
		}
	}
	log.Debug(fmt.Sprintf("城市配置加载完毕...省~%d 市~%d 区~%d", len(S_ProvinceDict), len(S_CityDict), len(S_DistrictDict)))
}

// 加载规则...
func InitToolRules() {
	ReplensihRules = []map[string]interface{}{}
	dataArr, _ := BidMgo.Find("bidding_bc", map[string]interface{}{}, nil, nil)
	for _, v := range dataArr {
		if qu.IntAll(v["isopen"]) == 1 {
			ReplensihRules = append(ReplensihRules, v)
		}
	}
	log.Debug("补充校验规则加载完毕···", len(ReplensihRules))
}

func IsMarkInterfaceMap(t interface{}) []map[string]interface{} {
	p_list := []map[string]interface{}{}
	if list_3, ok_3 := t.([]map[string]interface{}); ok_3 {
		p_list = list_3
		return p_list
	}

	if yl_list_1, ok_1 := t.(primitive.A); ok_1 {
		p_list = qu.ObjArrToMapArr(yl_list_1)
	} else {
		if yl_list_2, ok_2 := t.([]interface{}); ok_2 {
			p_list = qu.ObjArrToMapArr(yl_list_2)
		}
	}
	return p_list
}

func PostMarkDownText(html string) string {
	url := "http://172.17.162.35:18811/md"
	if IsLocal {
		url = "http://172.17.0.19:8888/md"
	}
	// 创建请求数据
	jsonData, err := json.Marshal(map[string]interface{}{"html": html})
	if err != nil {
		return ""
	}
	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return ""
	}
	// 设置请求头
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	client.Timeout = 60 * time.Second
	resp, err := client.Do(req)
	if err != nil {
		return ""
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return ""
	}
	info := map[string]interface{}{}
	err = json.Unmarshal(body, &info)
	if err != nil {
		return ""
	}
	return qu.ObjToString(info["result"])
}

func PostPurchasingList(data map[string]interface{}) map[string]interface{} {
	url := "http://172.17.162.35:18787/"
	if IsLocal {
		url = "http://172.17.0.153:18787/"
	}
	jsonData, err := json.Marshal(data)
	if err != nil {
		return map[string]interface{}{}
	}
	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return map[string]interface{}{}
	}
	// 设置请求头
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	client.Timeout = 180 * time.Second
	resp, err := client.Do(req)
	if err != nil {
		return map[string]interface{}{}
	}
	defer resp.Body.Close()
	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return map[string]interface{}{}
	}
	info := map[string]interface{}{}
	err = json.Unmarshal(body, &info)
	if err != nil {
		return map[string]interface{}{}
	}
	return info
}

func PostDetailContentHtmlText(bucket_id string, object_name string) string {
	//api_url := "http://172.17.162.27:18011/ossservice/biddetail"
	api_url := "https://www.jianyu360.cn/ossservice/biddetail"
	data := url.Values{"bucket_id": {bucket_id}, "object_name": {object_name}}
	req, _ := http.NewRequest("POST", api_url, strings.NewReader(data.Encode()))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	client := &http.Client{}
	client.Timeout = 5 * time.Second
	resp, _ := client.Do(req)
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		return ""
	}
	//读取响应体
	body, _ := ioutil.ReadAll(resp.Body)
	str := string(body)
	return str
}