package esutil

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"mime/multipart"
	"net/http"
	"strings"
	"time"

	"github.com/pkg/errors"
)

func GetEsDataReq(url string, parama string, isSource bool) map[string]interface{} {
	//fmt.Println("es 查询请求路径" + url) //  配置信息 获取
	var dat map[string]interface{}
	req, err := http.NewRequest("POST", url, strings.NewReader(parama))
	req.Header.Add("Content-Type", "application/json")
	timeout := time.Duration(10 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return dat
	}
	defer resp.Body.Close()
	dec := json.NewDecoder(resp.Body)
	if err := dec.Decode(&dat); err == io.EOF {
		fmt.Println(err.Error())
		return dat
	} else if err != nil {
		fmt.Println(err.Error())
		return dat
	}
	// 是否需要 解析 es 返回的 source
	if isSource {
		dat = dat["hits"].(map[string]interface{})
		var data = make(map[string]interface{}, 2)
		data["total"] = dat["total"]
		sources := []interface{}{}
		for _, value := range dat["hits"].([]interface{}) {
			source := value.(map[string]interface{})["_source"].(map[string]interface{})
			//source["id"] = source["id"]
			/*sdkType := source["sdkType"]
			if sdkType != nil {
				sdk, _ := strconv.Atoi(sdkType.(string))
				source["sdkType"] = sdkTypeToValue(sdk)
			}*/
			sources = append(sources, source)
		}
		data["datalist"] = sources
		return data
	} else {
		return dat
	}

}

//sdk类型
/*func sdkTypeToValue(i int) string {
	value := []string{"人脸", "车辆", "人体", "入侵", "拥挤", "靠右行", "人员异常", "个体静止"}
	return value[i-1]
}*/

func PutEsDataReq(url string, parama string) (map[string]interface{}, error) {
	//fmt.Println("es 查询请求路径" + url) //  配置信息 获取
	req, err := http.NewRequest("PUT", url, strings.NewReader(parama))
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	req.Header.Add("Content-Type", "application/json")
	timeout := time.Duration(5 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	defer resp.Body.Close()
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	var dat map[string]interface{}
	dec := json.NewDecoder(resp.Body)
	if err := dec.Decode(&dat); err == io.EOF {
		fmt.Println(err.Error())
		return nil, err
	} else if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	return dat, nil
}

func PostFormData(uri string, filename, paramName string, fileBytes []byte) (maps map[string]interface{}, err0 error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	_, err := writer.CreateFormFile(paramName, filename)
	if err != nil {
		return nil, err
	}
	boundary := writer.Boundary()
	close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
	fmt.Println("PostFormData.fileLen:", len(fileBytes))
	file := bytes.NewBuffer(fileBytes)
	request_reader := io.MultiReader(body, file, close_buf)

	request, err := http.NewRequest("POST", uri, request_reader)
	request.Header.Add("Content-Type", writer.FormDataContentType())
	timeout := time.Duration(5 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(request)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("panic的内容%v\n", r)
			msg := "上传图片服务器异常"
			if _, ok := r.(error); ok {
				msg = r.(error).Error()
				fmt.Println("panic--recover()得到的是error类型")
			}
			if _, ok := r.(string); ok {
				msg = r.(string)
				fmt.Println("panic--recover()得到的是string类型")
			}
			err0 = errors.New(msg)
		}
	}()
	defer resp.Body.Close()
	body = &bytes.Buffer{}
	_, err = body.ReadFrom(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(resp.StatusCode)
	//fmt.Println(body)
	//decoder := json.NewDecoder(strings.NewReader(body.String()))
	decoder := make(map[string]interface{})
	if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
		return nil, err
	}
	return decoder, nil
}

func PostFormBufferData(uri string, filename, paramName string, fileData []byte) (maps map[string]interface{}, err0 error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	_, err := writer.CreateFormFile(paramName, filename)
	if err != nil {
		return nil, err
	}
	boundary := writer.Boundary()
	//close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
	close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
	file := bytes.NewBuffer(fileData)
	request_reader := io.MultiReader(body, file, close_buf)
	//_, err = io.Copy(part, file)
	//writer.WriteField(key, val)
	request, err := http.NewRequest("POST", uri, request_reader)
	request.Header.Add("Content-Type", writer.FormDataContentType())
	timeout := time.Duration(5 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(request)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("panic的内容%v\n", r)
			msg := "上传图片服务器异常"
			if _, ok := r.(error); ok {
				msg = r.(error).Error()
				fmt.Println("panic--recover()得到的是error类型")
			}
			if _, ok := r.(string); ok {
				msg = r.(string)
				fmt.Println("panic--recover()得到的是string类型")
			}
			err0 = errors.New(msg)
		}
	}()
	defer resp.Body.Close()
	{
		body := &bytes.Buffer{}
		_, err := body.ReadFrom(resp.Body)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(resp.StatusCode)
		//fmt.Println(resp.Header)
		fmt.Println(body)
		//decoder := json.NewDecoder(strings.NewReader(body.String()))
		decoder := make(map[string]interface{})
		if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
			return nil, err
		}
		return decoder, nil
	}
}

func GetEsDataInfo(url string, isSource bool) map[string]interface{} {

	fmt.Println("es GET 查询请求路径" + url) //  配置信息 获取
	req, err := http.NewRequest("GET", url, strings.NewReader(""))
	req.Header.Add("Content-Type", "application/json")
	timeout := time.Duration(5 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	defer resp.Body.Close()
	if err != nil {
		fmt.Println(err)
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
	}
	//jsonStr := string(body)
	//fmt.Println("jsonStr", jsonStr)
	var dat map[string]interface{}
	if err := json.Unmarshal(body, &dat); err == nil {
		fmt.Println("token", dat["token"])
	} else {
		fmt.Println("json str to struct error")
	}
	// 是否需要 解析 es 返回的 source
	if isSource {
		source := make(map[string]interface{})
		if dat["_source"] != nil {
			source = dat["_source"].(map[string]interface{})
		}
		source["id"] = dat["_id"]
		return source
	} else {
		return dat
	}
}

//解析http
func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
	timeout := time.Duration(10 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
	request.Header.Set("Content-type", "application/json")

	if err != nil {
		fmt.Println("build request fail !")
		return nil, err
	}

	resp, err := client.Do(request)
	if err != nil {
		fmt.Println("request error: ", err)
		return nil, err
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	return body, nil
}

//解析json
func Sourcelist(buf []byte) (sources []map[string]interface{}, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["hits"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	for _, in := range middle["hits"].([]interface{}) {
		tmpbuf, ok := in.(map[string]interface{})
		if !ok {
			fmt.Println("change to source error!")
			continue
		}
		source, ok := tmpbuf["_source"].(map[string]interface{})
		if !ok {
			fmt.Println("change _source error!")
			continue
		}
		sources = append(sources, source)
	}
	return sources, nil
}

func HttpGet(str string) []byte {
	resp, err := http.Get(str)
	if err != nil {
		// handle error
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		// handle error
	}
	return body
}

func ResponseData(tokenRes map[string]interface{}) map[string]interface{} {
	tmpAllDate := make(map[string]interface{})
	tmpDate := make(map[string][]interface{})
	tmpAllDate["total"] = tokenRes["total"]
	data := tokenRes["datalist"]
	for _, masterInfoValues := range data.([]interface{}) {
		masterInfo := masterInfoValues.(map[string]interface{})
		sources := make(map[string]interface{}, 0)
		activateInfo := make(map[string]interface{})
		if masterInfo["linkTagInfo"] != nil {
			linkTagInfo := masterInfo["linkTagInfo"].([]interface{})
			delete(masterInfo, "linkTagInfo")
			if len(linkTagInfo) > 0 {
				slaveList := make([]interface{}, 0)
				slaveList = append(slaveList, masterInfo)
				slaveList = append(slaveList, linkTagInfo...)
				for i, j := 0, len(slaveList)-1; i < j; i, j = i+1, j-1 {
					slaveList[i], slaveList[j] = slaveList[j], slaveList[i]
				}
				sources["list"] = slaveList
				activateInfo = slaveList[0].(map[string]interface{})
			} else {
				sources["list"] = []interface{}{
					masterInfo,
				}
				activateInfo = masterInfo
			}
		} else {
			if _, ok := masterInfo["linkTagInfo"]; ok {
				delete(masterInfo, "linkTagInfo")
			}
			sources["list"] = []interface{}{
				masterInfo,
			}
			activateInfo = masterInfo

		}

		sources["activeObject"] = activateInfo

		tmpDate["datalist"] = append(tmpDate["datalist"], sources)
	}
	tmpAllDate["datalist"] = tmpDate["datalist"]
	return tmpAllDate
}