package v1

import (
	"apsClient/conf"
	"apsClient/model"
	"apsClient/model/response"
	_ "apsClient/model/response"
	"apsClient/pkg/contextx"
	"apsClient/pkg/convertx"
	"apsClient/pkg/ecode"
	"apsClient/pkg/logx"
	"apsClient/pkg/plc"
	"apsClient/service"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"time"
)

type TaskApi struct{}

// TaskGet
// @Tags      Task
// @Summary   获取任务
// @Produce   application/json
// @Success   200   {object}  contextx.Response{data=response.TaskData}  "成功"
// @Router    /v1/task/get [get]
func (slf *TaskApi) TaskGet(c *gin.Context) {
	ctx, ok := contextx.NewContext(c, nil)
	if !ok {
		return
	}

	taskData, code := service.NewTaskService().GetTask()
	if code != ecode.OK {
		ctx.Fail(code)
		return
	}
	ctx.OkWithDetailed(taskData)
}

// TaskStart
// @Tags      Task
// @Summary   任务开始
// @Produce   application/json
// @Param     id  path    int true  "工序id"
// @Success   200   {object}  contextx.Response{data=response.ProcessParamsResponse}  "成功"
// @Router    /v1/task/start/{id} [get]
func (slf *TaskApi) TaskStart(c *gin.Context) {
	ctx, ok := contextx.NewContext(c, nil)
	if !ok {
		return
	}
	idx := c.Param("id")
	if idx == "" {
		ctx.Fail(ecode.ParamsErr)
		return
	}
	id := convertx.Atoi(idx)
	procedure, code := service.NewTaskService().GetProcedureById(id)
	if code != ecode.OK {
		ctx.Fail(code)
		return
	}

	if procedure.Status != model.ProcedureStatusUnFinished {
		ctx.FailWithMsg(ecode.ParamsErr, "该工序已结束")
		return
	}

	order, err := service.NewTaskService().GetOrderByWorkOrderId(procedure.WorkOrderID)
	if err != nil {
		ctx.Fail(ecode.UnknownErr)
		return
	}

	params := service.GetProcessModelParams{
		WorkOrder: procedure.WorkOrderID,
		OrderId:   procedure.OrderID,
		Product:   order.ProductName,
		Procedure: procedure.ProceduresInfo.ProcedureName,
		Device:    procedure.ProceduresInfo.DeviceName,
	}

	resp, err := service.ProcessModel{}.GetProcessModel(params)

	if err != nil {
		logx.Errorf("TaskStart Notice GetProcessModel error: %v", err.Error())
		ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
		return
	}
	processParamsArr := make([]response.ProcessParams, 0, len(resp.ParamsMap))
	for k, v := range resp.ParamsMap {
		processParamsArr = append(processParamsArr, response.ProcessParams{
			Key:   k,
			Value: v,
		})
	}
	response := response.ProcessParamsResponse{
		Number: resp.Number,
		Params: processParamsArr,
	}
	logx.Infof("TaskStart Notice GetProcessModel: %+v", resp)
	ctx.OkWithDetailed(response)
}

// TaskFinish
// @Tags      Task
// @Summary   任务结束
// @Produce   application/json
// @Param     id  path    int true  "工序id"
// @Success   200   {object}  contextx.Response{service.GetProcessModel}  "成功"
// @Router    /v1/task/finish/{id} [put]
func (slf *TaskApi) TaskFinish(c *gin.Context) {
	ctx, ok := contextx.NewContext(c, nil)
	if !ok {
		return
	}
	idx := c.Param("id")
	if idx == "" {
		ctx.Fail(ecode.ParamsErr)
		return
	}
	id := convertx.Atoi(idx)
	_, code := service.NewTaskService().GetProcedureById(id)
	if code != ecode.OK {
		ctx.Fail(code)
		return
	}
	err := service.NewTaskService().UpdateProcedureStatus(id, model.ProcedureStatusFinished)
	if err != nil {
		logx.Errorf("UpdateProcedureStatus err: %v", err.Error())
		ctx.Fail(ecode.UnknownErr)
		return
	}
	ctx.Ok()
}

// SendProcessParams
// @Tags      Task
// @Summary   下发工艺参数
// @Produce   application/json
// @Param     id  path    int true  "工序id"
// @Success   200   {object}  contextx.Response{service.GetProcessModel}  "成功"
// @Router    /v1/task/sendProcessParams/{id} [post]
func (slf *TaskApi) SendProcessParams(c *gin.Context) {
	ctx, ok := contextx.NewContext(c, nil)
	if !ok {
		return
	}
	idx := c.Param("id")
	if idx == "" {
		ctx.Fail(ecode.ParamsErr)
		return
	}
	id := convertx.Atoi(idx)
	procedure, code := service.NewTaskService().GetProcedureById(id)
	if code != ecode.OK {
		ctx.Fail(code)
		return
	}
	order, err := service.NewTaskService().GetOrderByWorkOrderId(procedure.WorkOrderID)
	if err != nil {
		ctx.Fail(ecode.UnknownErr)
		return
	}

	params := service.GetProcessModelParams{
		WorkOrder: "",
		OrderId:   procedure.OrderID,
		Product:   order.ProductName,
		Procedure: procedure.ProceduresInfo.ProcedureName,
		Device:    procedure.ProceduresInfo.DeviceID,
	}

	resp, err := service.ProcessModel{}.GetProcessModel(params)
	if err != nil {
		logx.Errorf("SendProcessModel GetProcessModel err: %v", err.Error())
		ctx.Fail(ecode.UnknownErr)
		return
	}

	fmt.Println("----------------开始下发工艺参数-----------------")
	for k, v := range resp.ParamsMap {
		fmt.Println(fmt.Sprintf("%v : %v", k, v))
		time.Sleep(time.Millisecond * 300)
	}
	fmt.Println("----------------下发工艺参数完毕-----------------")

	//err = SendParams(resp.ParamsMap)
	//if err != nil {
	//	logx.Errorf("SendProcessParams: %v", err.Error())
	//	ctx.Fail(ecode.UnknownErr)
	//	return
	//}

	ctx.Ok()
}

func SendParams(paramsMap map[string]interface{}) error {
	plcAddressMap := make(map[string]*int, len(conf.Conf.PLCAddresses))
	for _, item := range conf.Conf.PLCAddresses {
		plcAddressMap[item.FieldName] = &item.Address
	}

	plcConfig, code := service.NewDevicePlcService().GetDevicePlc()
	if code != ecode.OK {
		return errors.New("请先配置PLC")
	}
	conn, err := plc.NewModbusConnection(plcConfig.Address)
	if err != nil {
		return errors.New(fmt.Sprintf("连接plc失败: %v", err.Error()))
	}
	defer conn.Close()

	logx.Info("----------------开始下发工艺参数-----------------")
	for k, v := range paramsMap {
		if plcAddressMap[k] != nil {
			result, err := plc.WriteHoldingRegister(conn, *plcAddressMap[k], v)
			if err != nil {
				logx.Errorf("WriteHoldingRegister err:%v, address: %v, key: %v value: %v", err.Error(), *plcAddressMap[k], k, v)
			} else {
				logx.Infof("WriteHoldingRegister ok: key: %v, value: %v, result: %v", k, v, result)
			}
		}
	}
	logx.Info("----------------下发工艺参数完毕-----------------")
	return nil
}