package controllers

import (
	"encoding/json"
	"fmt"
	"gitee.com/aywc_1/aywc_judge/src/appinit"
	"gitee.com/aywc_1/aywc_judge/src/configuration"
	"gitee.com/aywc_1/aywc_judge/src/lib"
	"gitee.com/aywc_1/aywc_judge/src/models"
	"gitee.com/aywc_1/aywc_judge/src/services"
	"gitee.com/aywc_1/aywc_judge/src/utils"
	"github.com/gin-gonic/gin"
	"github.com/shenyisyn/goft-gin/goft"
	log "github.com/sirupsen/logrus"
	"github.com/streadway/amqp"
	"io"
	"os"
)

type DeviceWarmMQController struct {
	DeviceWarmService *services.DeviceWarmService `inject:"-"`
	SysConfig         *goft.SysConfig             `inject:"-"`
}

func NewDeviceWarmMQController() *DeviceWarmMQController {
	return &DeviceWarmMQController{}
}

func (this *DeviceWarmMQController) Name() string {
	return "DeviceWarmMQController"
}

func (this *DeviceWarmMQController) DeviceWarmMQInit(ctx *gin.Context) goft.Json {
	err := deviceWarmMQInit(appinit.GetConn())
	if err != nil {
		log.Error(err.Error())
		panic(err.Error())
	}
	return gin.H{"result": "success"}
}

var exd = configuration.GetYamlValue([]string{"config", "mq", "devicewarm", "exchange"}, 0, "root").(string)
var keyd = configuration.GetYamlValue([]string{"config", "mq", "devicewarm", "key"}, 0, "root").(string)
var qd = configuration.GetYamlValue([]string{"config", "mq", "devicewarm", "queue"}, 0, "root").(string)

func deviceWarmMQInit(MQConn *amqp.Connection) error {
	exp := configuration.GetYamlValue([]string{"config", "mq", "processpicture", "exchange"}, 0, "root").(string)
	keyp := configuration.GetYamlValue([]string{"config", "mq", "processpicture", "key"}, 0, "root").(string)
	qp := configuration.GetYamlValue([]string{"config", "mq", "processpicture", "queue"}, 0, "root").(string)
	expr := configuration.GetYamlValue([]string{"config", "mq", "processpictureresult", "exchange"}, 0, "root").(string)
	keypr := configuration.GetYamlValue([]string{"config", "mq", "processpictureresult", "key"}, 0, "root").(string)
	qpr := configuration.GetYamlValue([]string{"config", "mq", "processpictureresult", "queue"}, 0, "root").(string)
	mq := lib.GetMQ()
	if mq == nil {
		log.Error("mq init error")
		return fmt.Errorf("mq init error")
	}
	defer mq.Channel.Close()
	err := mq.Channel.ExchangeDeclare(exd, "direct", true, false, false, false, nil)
	if err != nil {
		log.Errorf("Exchange_DeviceWarm error ,err:%s\n", err.Error())
		return fmt.Errorf("Exchange_DeviceWarm error ,err:%s\n", err.Error())
	}
	err = mq.DecQueueAndBind(qd, keyd, exd)
	if err != nil {
		log.Errorf("dlx Bind error ,err:%s\n", err.Error())
		return fmt.Errorf("dlx Bind error ,err:%s\n", err.Error())
	}
	//处理图片
	err = mq.Channel.ExchangeDeclare(exp, "direct", true, false, false, false, nil)
	if err != nil {
		log.Errorf("Exchange_ProcessPicture error ,err:%s\n", err.Error())
		return fmt.Errorf("Exchange_ProcessPicture error ,err:%s\n", err.Error())
	}
	err = mq.DecQueueAndBind(qp, keyp, exp)
	if err != nil {
		log.Errorf("dlx Bind error ,err:%s\n", err.Error())
		return fmt.Errorf("dlx Bind error ,err:%s\n", err.Error())
	}
	//处理结果
	err = mq.Channel.ExchangeDeclare(expr, "direct", true, false, false, false, nil)
	if err != nil {
		log.Errorf("Exchange_ProcessPictureResult error ,err:%s\n", err.Error())
		return fmt.Errorf("Exchange_ProcessPictureResult error ,err:%s\n", err.Error())
	}
	err = mq.DecQueueAndBind(qpr, keypr, expr)
	if err != nil {
		log.Errorf("dlx Bind error ,err:%s\n", err.Error())
		return fmt.Errorf("dlx Bind error ,err:%s\n", err.Error())
	}
	return nil
}

func (this *DeviceWarmMQController) DeviceWarmUpload(ctx *gin.Context) goft.Json {
	fileId, err := utils.GetID() // 生成主键ID 生成规则 yyyymmdd+
	if err != nil {
		log.Errorf("Failed to snowflake GetID,err:%s\n", err.Error())
		panic(fmt.Sprintf("Failed to snowflake GetID,err:%s\n", err.Error()))
	}
	//https://my.oschina.net/u/3625745/blog/3055823
	file, header, err := ctx.Request.FormFile("file")
	if err != nil {
		log.Errorf("Failed to get data,err:%s\n", err.Error())
		panic(fmt.Sprintf("Failed to get data,err:%s\n", err.Error()))
	}
	defer file.Close()
	value := ctx.Request.MultipartForm.Value
	deviceId := ""
	//deviceName:=""
	if _, ok := value["device_id"]; ok {
		if str := value["device_id"][0]; len(str) > 50 {
			deviceId = str[0:50]
		} else {
			deviceId = str
		}
	} else {
		panic("param device_id is not found ")
	}

	/*if _, ok := value["device_name"];ok{
		if str:=value["device_name"][0];len(str)>255{
			deviceName=str[0:255]
		}else{
			deviceName=str
		}
	}else{
		panic("param device_name is not found ")
	}*/
	//fileMeta:=models.FileMetaModel{
	//	FileName:header.Filename,
	//	Location:"D:/device_upload/"+fileId+"_"+header.Filename,
	//	UploadAt: time.Now().Format("2006-01-02 15:00:00"),
	//}
	idFk := ""
	if _, ok := value["id_fk"]; ok {
		if str := value["id_fk"][0]; len(str) > 50 {
			idFk = str[0:50]
		} else {
			idFk = str
		}
	} else {
		idFk = ""
	}

	deviceWarmModel := models.DeviceWarmModel{
		Id: fileId,
		// DeviceName:deviceName,
		DeviceId:       deviceId,
		UploadFileName: header.Filename,
		CreateTime:     utils.GetNowTimeUTC8(),
		IdFk:           idFk,
	}
	uploadPath := configuration.GetYamlValue([]string{"config", "upload_path"}, 0, "/mydata/go/upload/").(string)
	filePath := uploadPath + deviceWarmModel.Id + "_" + deviceWarmModel.UploadFileName
	log.Info(filePath)
	newFile, err := os.Create(filePath)
	if err != nil {
		log.Errorf("Failed to create file,err:%s\n", err.Error())
		panic(fmt.Sprintf("Failed to create file,err:%s\n", err.Error()))
	}
	defer newFile.Close()
	deviceWarmModel.UploadFileSize, err = io.Copy(newFile, file)
	if err != nil {
		log.Errorf("Failed to save data into file,err:%s\n", err.Error())
		panic(fmt.Sprintf("Failed to save data into file,err:%s\n", err.Error()))
	}
	v, _ := json.Marshal(deviceWarmModel)

	mq := lib.GetMQ()
	log.Debug(string(v))
	err = mq.SendMessage(keyd, exd, string(v))
	if err != nil {
		log.Errorf("Failed to send data into mq,err:%s\n", err.Error())
		panic(fmt.Sprintf("Failed to send data into mq,err:%s\n", err.Error()))
	}
	return gin.H{"result": "success", "code": 200}
}

func (this *DeviceWarmMQController) Build(goft *goft.Goft) {
	goft.Handle("POST", "/IntelligentRecognition/uploadgraph", this.DeviceWarmUpload).
		Handle("GET", "/deviceWarmMQInit", this.DeviceWarmMQInit)
}