package controllers

import (
	"basic.com/pubsub/protomsg.git"
	"bytes"
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/satori/go.uuid"
	"image"
	"image/jpeg"
	"io/ioutil"
	"log"
	"mime/multipart"
	"net/http"
	"strings"
	"webserver/extend/code"
	"webserver/extend/esutil"
	"webserver/extend/util"
	"webserver/models"
	"webserver/service"

)

type FileController struct {
}

// weedfs 访问路径
//var picIp = "http://192.168.1.182:6080/"
var picIp = "http://"

var picUrlField = "fileUrl"

//var picUrlField = "fid"
/**上传方法**/
var weedfsUri = "http://192.168.1.182:6333/submit"

//var weedfsUri = "http://192.168.1.182:9500/submit"

// @Summary 依据图片添加底库人员
// @Description  依据图片添加底库返回数据人员
// @Accept  mpfd
// @Produce json
// @Tags dbperson 底库人员
// @Param file formData file true "底库人员图片"
// @Param tableId formData string false "底库id,有id 则加入底库，无则只上传图片"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/dbperson/fileupload [POST]
func (fc FileController) Fileupload(c *gin.Context) {
	//得到上传的文件
	file, header, err := c.Request.FormFile("file") //image这个是uplaodify参数定义中的   'fileObjName':'image'
	tableId := c.Request.FormValue("tableId")
	if err != nil {
		c.String(http.StatusBadRequest, "Bad request")
		return
	}
	//文件的名称
	filename := header.Filename
	fmt.Println(file, err, filename)
	if err != nil {
		log.Fatal(err)
		filename = uuid.NewV4().String()
	}
	// fastdfs
	{
		//fileSuffix := path.Ext(filename)[1:] //获取文件后缀
		//fmt.Println("文件后缀 =", fileSuffix)
		//data, _ := ioutil.ReadAll(file)
		// fastdfs 上传  暂废弃
		//field := fdfsclient.UploadFileByBuffer(data, fileSuffix)
	}
	field, result, err := uploadFileReturnAddr(file, filename, tableId)
	if err != nil {
		if err.Error() == "NotFeatureFindError" {
			util.ResponseFormat(c, code.NotFeatureFindError, filename)
		} else {
			util.ResponseFormat(c, code.ServiceInsideError, err.Error())
		}
		return
	}
	if tableId != "" { //  上传
		if result["success"].(bool) {
			util.ResponseFormat(c, code.Success, result["data"])
		} else {
			util.ResponseFormat(c, code.ServiceInsideError, result["data"])
		}
	} else {
		util.ResponseFormat(c, code.Success, field)
	}
}

// @Description 人员照片上传并获取特征值
// @Router /data/api-v/dbperson/fileUploadTest [POST]
func (controller FileController) UploadPersonTest(c *gin.Context) {
	file, _, err := c.Request.FormFile("file") //image这个是uplaodify参数定义中的   'fileObjName':'image'
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数有误")
		return
	}


	//将上传的图片交人脸检测和人脸提取，获得特征
	fileBytes, _ := ioutil.ReadAll(file)
	faceExtArr, err := getFaceFeaFromSdk(fileBytes)
	if err ==nil && len(faceExtArr) >0 {
		var faceBase64= ""
		for _,r := range faceExtArr {
			faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
			break
		}
		util.ResponseFormat(c,code.Success,faceBase64)
	} else {
		util.ResponseFormat(c,code.ComError,"未提取到人脸")
	}
}

/*// 对上面的编码结果进行base64解码
decodeBytes, err := base64.StdEncoding.DecodeString(encodeString)
if err != nil {
log.Fatalln(err)
}*/

func uploadFileReturnAddr(file multipart.File, filename string, tableId string) (string, map[string]interface{}, error) {

	defer file.Close()
	field := ""
	// weedfs 上传
	fileBytes, err := ioutil.ReadAll(file)
	if err !=nil {
		return "",nil,err
	}
	fileInfo, e := esutil.PostFormData(weedfsUri, filename, "file", fileBytes)
	if e != nil {
		fmt.Println(e.Error())
		return "", nil, e
	} else {
		field = fileInfo[picUrlField].(string) // 文件路径
	}

	if field != "" {
		// 返回特征值  fileInfo["point"] = v.RcFace  fileInfo["feature"] = feat

		/*features := gorun.GetSimpleFaceDetect(picIp+field)  // 特征值     // linux
			if len(features) == 0 {                                               // linux
				return field,nil,errors.New("NotFeatureFindError")  // linux
			}else if len(features) > 1 {                                            // linux
				return field,nil,errors.New("TooManyFeatureFindError")  // linux
			}                                                                  // linux
			feat := features[0]["feature"].([]byte)   // linux
		if len(feat) != 2560 {                                // linux
			return field,nil,errors.New("NotFeatureFindError")

		}    */                     // linux
		if strings.Contains(field,"/"){
			idx := strings.Index(field, "/")
			field = field[idx+1:]
		}
		fmt.Println("field:",field)
		//imgB, _ := ioutil.ReadAll(file)
		//fmt.Println("img.length:",len(imgB))

		//将上传的图片交人脸检测和人脸提取，获得特征
		var faceBase64=""
		faceExtArr, err := getFaceFeaFromSdk(fileBytes)
		if faceExtArr ==nil {
			return "",nil,errors.New("NotFeatureFindError")
		}
		if err ==nil && len(faceExtArr) >0 {
			for _,r := range faceExtArr {
				faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
				break
			}
		}


		dbperson := new(models.Dbtablepersons)
		dbperson.PersonPicUrl = field //  图片路经
		dbperson.TableId = tableId           //
		dbperson.PersonName = filename       // 图片名
		// 演示base64编码

		dbperson.FaceFeature = faceBase64 // 特征值base64 码

		result := addDbPerson(dbperson)
		return field, result, nil
	} else {
		return field, nil, nil
	}
}

func getFaceFeaFromSdk(fileBytes []byte) ([]*protomsg.ResultFaceExtCom,error){
	s := service.NewFaceSdkService(fileBytes)
	i, err := s.ReadFromUploadImg()
	if err !=nil{
		fmt.Println("readFromUploadImg err:",err)
		return nil,err
	}
	bc, err := service.ImgCompress(i)
	if err !=nil {
		fmt.Println("ImgCompress err:",err)
		return nil,err
	}
	s.PushImgMsg(bc)
	s.GetFaceFea()
	if s.Result == nil{
		return nil,errors.New("no fea")
	} else {
		return s.Result,nil
	}
}

/**上传方法**/

// @Summary 批量添加底库人员
// @Description  依据图片批量添加底库人员
// @Accept  mpfd
// @Produce json
// @Tags dbperson 底库人员
// @Param files formData file[] true "多个底库人员图片"
// @Param tableId formData string false "底库id,有id 则加入底库，无则只上传图片"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true,data:{}}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false,data:null}"
// @Router /data/api-v/dbperson/moreFileUpload [POST]
func (fc FileController) MoreFileUpload(c *gin.Context) {
	//得到上传的文件
	//image这个是uplaodify参数定义中的   'fileObjName':'image'
	form, err := c.MultipartForm()
	tableId := c.Request.FormValue("tableId")
	fileHeaders := form.File["files"]
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, err.Error())
		return
	}
	extNames := make([]string, 0)
	isAllFiald := true
	addResult := make(map[string]interface{}, 0)
	details := make([]string, 0)
	for _, head := range fileHeaders {
		//文件的名称
		filename := head.Filename
		file, err := head.Open()
		fmt.Println(file, err, filename)
		if err != nil {
			log.Fatal(err)
		}
		//data, _ := ioutil.ReadAll(file)
		// weedfs 上传
		field, _, err1 := uploadFileReturnAddr(file, filename, tableId)
		extNames = append(extNames, field)
		if isAllFiald && err1 == nil {
			isAllFiald = false
		}
		if err1 != nil {
			if field == "" {
				details = append(details, filename+"上传失败,"+err1.Error())
			} else {
				details = append(details, filename+"加入底库失败,"+err1.Error())
			}
		}
	}
	addResult["isAllFiald"] = isAllFiald
	addResult["fields"] = extNames
	addResult["detail"] = details
	//fields := fdfsclient.UploadFileByBuffer100(bytess, extNames)     //  fastdfs 上传
	if !isAllFiald {
		util.ResponseFormat(c, code.Success, addResult)
	} else {
		util.ResponseFormat(c, code.ServiceInsideError, err.Error())
	}
}

type EsPersonSave struct {
	FaceFeature string `json:"faceFeature"`
	TableId string `json:"tableId"`
	Id string `json:"id"`
	PersonPicUrl string `json:"personPicUrl"`
	IdCard string `json:"idCard"`
}

// @Summary 上传图片 并切图
// @Description  上传图片 并切图
// @Accept  mpfd
// @Produce json
// @Tags dbperson 底库人员
// @Param file formData file true "底库人员图片"
// @Param tableId formData string false "底库id,有id 则加入底库，无则只上传图片"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true, data:""}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false, data:""}"
// @Router /data/api-v/es/ImageUploadReturnPics [POST]
func (fc FileController) ImageUploadReturnPics(c *gin.Context) {
	//得到上传的文件
	file, header, err := c.Request.FormFile("file") //image这个是uplaodify参数定义中的   'fileObjName':'image'
	if err != nil {
		log.Fatal(err)
		util.ResponseFormat(c, code.RequestParamError, err.Error())
		return
	}
	//文件的名称
	filename := header.Filename
	defer file.Close()
	field := ""

	// weedfs 上传
	uploadData := make([]byte, header.Size)
	i, err2 := file.ReadAt(uploadData, 0)
	if err2 != nil {
		fmt.Println("上传返回i:", i)
		util.ResponseFormat(c, code.UploadFileError, err2.Error())
		return
	}
	{
		uri := weedfsUri
		fileInfo, e := esutil.PostFormBufferData(uri, filename, "file", uploadData)
		if e != nil {
			fmt.Println(e.Error())
			util.ResponseFormat(c, code.UploadFileError, e.Error())
			return // 上传失败
		} else {
			field = fileInfo[picUrlField].(string) // 文件路径
		}
	}
	// fileInfo["point"] = v.RcFace   // 返回特征值
	//	fileInfo["feature"] = feat
	//features := gorun.GetSimpleFaceDetect(picIp + "/" + field) // 特征值  只在linux 下

	result := make(map[string]interface{}, 0)
	result["uploadImage"] = picIp + field
	smUrl := make([]string, 0)
	//for _, feature := range features {         // linux
	// 获取图片
	//point := feature["point"].(gosdk.CRECT)    // linux
	buffer := bytes.NewBuffer(uploadData)
	m, _, _ := image.Decode(buffer) // 图片文件解码
	rgbImg := m.(*image.YCbCr)
	//subImg := rgbImg.SubImage(image.Rect(int(point.Left),int(point.Bottom),int(point.Right),int(point.Top))).(*image.YCbCr) //图片裁剪x0 y0 x1 y1  linux
	subImg := rgbImg.SubImage(image.Rect(30, 130, 170, 20)).(*image.YCbCr) //图片裁剪x0 y0 x1 y1                           windows
	emptyBuff := bytes.NewBuffer(nil)                                      //开辟一个新的空buff
	jpeg.Encode(emptyBuff, subImg, nil)                                    //img写入到buff
	bytes := emptyBuff.Bytes()
	fileInfo, e := esutil.PostFormBufferData(weedfsUri, filename, "file", bytes)
	if e != nil {
		fmt.Println(e.Error())
		util.ResponseFormat(c, code.UploadFileError, e.Error())
		return // 上传失败
		smUrl = append(smUrl, "一组获取失败")
	} else {
		field = fileInfo[picUrlField].(string) // 文件路径
		smUrl = append(smUrl, picIp+field)
	}
	//}                                    // linux
	result["smImage"] = smUrl
	util.ResponseFormat(c, code.Success, result)
}

/**下载方法**/
func Filedown(c *gin.Context) {
	//暂时没有提供方法

}