package converse

import (
	"encoding/json"
	"log"
	"strconv"
	"strings"
	"time"

	// "github.com/astaxie/beego"
	"github.com/gorilla/websocket"

	arrangeService "dashoo.cn/genepoint_srv/business/arrangeService"
	. "dashoo.cn/genepoint_srv/business/converseService"
	"dashoo.cn/utils"
)

type ConverseController struct {
	// beego.Controller
}

//建立会话
func (this *ConverseController) GetConnection(c *websocket.Conn) {
	log.Println("建立会话")
	svc := GetConverseService(utils.DBE)
	utc := time.Now().UTC().Format(time.RFC3339)
	req := svc.GetSessionSetupRequest(utc)

	msg, _ := json.Marshal(req)
	log.Printf("session_setup: %s", msg)

	this.SendMessage(req, c)
}

// 查询样本库系统，进行接口任务处理
func (this *ConverseController) SearchDatabase() map[string]*RequestEntity {
	log.Println("组装请求数据报文开始---")
	svc := GetConverseService(utils.DBE)
	asvc := arrangeService.GetArrangeService(utils.DBE)
	tasks := svc.ScanNewTaskDetail()
	// tasks := svc.GetNewTaskBasic()
	var reqMap = make(map[string]*RequestEntity)

	//依次处理每一条新任务信息
	for _, value := range tasks {
		var time int64 = time.Now().Unix()

		// add by 徐春林 如果是 库内整理任务, 需要关联新的表查询数据
		var user string
		if value.Task_type == 9 {
			user = asvc.GetOperUser(value.Task_id)
		} else {
			user = svc.GetOperUser(value.Task_id)
		}
		taskid := value.Task_id + "@" + strconv.FormatInt(time, 10)
		//	log.Println("taskid:", taskid)

		//如果没有任务实体, 则创建新任务实体
		if _, ok := reqMap[value.Task_id]; !ok {
			entity := svc.GenerateRequestEntity(value.Task_type /*value.Task_id*/, taskid,user)
			reqMap[value.Task_id] = entity
		}
		//处理任务详细
		svc.HandleTaskDetail(value.Task_type, reqMap[value.Task_id], &value)


	}
	for _, v := range reqMap {
		//log.Println("****************************")
		m, _ := json.Marshal(v)
		log.Println("组装报文成功",string(m))
	}
	//log.Println("组装请求数据报文：",reqMap)
	return reqMap
}

// 发送消息给接口服务
func (this *ConverseController) SendMessage(req *RequestEntity, conn *websocket.Conn) {
	err := conn.WriteJSON(&req)
	if err != nil {
		log.Println("write err:", err)
	}
}

// 根据子任务结果修改状态，子任务中有一个失败，则整个申请单为失败状态
func (this *ConverseController) StatusModifyWithDetail(task_id string,res ResponseEntity ) error {
	svc := GetConverseService(utils.DBE)
	err := svc.StatusModifyWithDetail(task_id,res)
	if err != nil {
		return err
	}
	return nil
}

// 修改任务状态码
func (this *ConverseController) StatusModify(statusCode int, task_id string,reqType string) error {
	svc := GetConverseService(utils.DBE)
	asvc := arrangeService.GetArrangeService(utils.DBE)
	//修改任务表任务状态
	err := svc.TaskStatusModify(statusCode, task_id)
	if err != nil {
		return err
	}

	if reqType == "moving" {
		err = asvc.ArrangeMainStatusModify(statusCode, task_id)
		if err != nil {
			return err
		}
		if statusCode != SUCCESS && statusCode != FAILED {
			err = asvc.ArrangeDetailStatusModify(statusCode, task_id)
			if err != nil {
				return err
			}
		}
	} else {
		//修改出入库任务状态
		err = svc.SampleApplyStatusModify(statusCode, task_id)
		if err != nil {
			return err
		}

		// 2020/12/18 卢传敏新增，修复多条报文返回的问题，同时处理 任务中样本的状态和任务状态不一致的问题
		// 根据任务报文返回的执行状态 修改出入库单中的 样本的任务状态
		// 状态码不为成功/失败（成功/失败状态会根据响应报文单独处理状态更改），则批量更新样本申请表状态
		if statusCode != SUCCESS && statusCode != FAILED {
			err = svc.SampleApplyDetailStatusModify(statusCode, task_id)
			if err != nil {
				return err
			}
		}
	}

	//if statusCode == SUCCESS || statusCode == REJECT {
	//	svc.SampleApplyDetailStatusBatchModify(statusCode,task_id)
	//}

	return nil
}

//修改部分执行成功样本状态
//func (this *ConverseController)SamplePartsStatusModify(res ResponseEntity){
//	svc :=  GetConverseService(utils.DBE)
//	svc.SampleApplyDetailStatusPartsModify(res)
//}

//修改全部执行成功或失败样本状态
//func (this *ConverseController)SampleAllStatusModify(res ResponseEntity, statusCode int){
//	svc := GetConverseService(utils.DBE)
//	if statusCode == SUCCESS {
//		svc.ModifySampleALLSuccessStatus(res)
//	}else if statusCode == FAILED {
//		svc.ModifySampleALLFailedStatus(res)
//	}else if statusCode == REJECT {
//		svc.ModifySampleAllRejectStatus(res)
//	}
//}

// 处理基点接口返回的信息
func (this *ConverseController) HandleMessage(n int, message []byte) {
	var res ResponseEntity
	json.Unmarshal(message, &res)

	resp := res.Response
	result := res.Result
	taskId := strings.Split(res.Data.Task_id, "@")[0]
	isEnd := res.Data.Is_end
	taskType := res.Data.Type

	//调试临时用, 把设备信息打印忽略
	//if resp != "report_data" {
	//	log.Println("res:",&res)
	//}
	//response := res.Response

	//处理设备状态数据
	/*if response == "report_data" {
		converseService.RecordDeviceData(res.Data.List)
	}*/

	var err error
	//如果正常响应且任务执行成功则修改任务状态为成功
	if result == 200 {
		if taskType == "end" || taskType == "abnormal_end" {
			log.Println(">>>>>>>>>>任务[" + taskId + "]结束(" + taskType + ")处理(是否全部结束：" + utils.ToStr(isEnd) + ")>>>>>>>>>>")

			//若非正常结束，保存异常信息
			if taskType == "abnormal_end" {
				this.SaveExcepMsg(res, taskId, resp)
			}
			// add by 徐春林 库内整理任务需要单独处理
			if resp == "moving"{
				asvc := arrangeService.GetArrangeService(utils.DBE)
				err = asvc.UpdateArrangeRes(taskId,resp,message)
			} else {
				//处理任务下申请
				svc := GetConverseService(utils.DBE)
				svc.ModifySampleStatusByApplyMainInfo(taskId, resp, res)

				// 所有入库单下子任务已完成，根据样本申请状态（有一个不为成功则更新为失败状态）更新申请单，任务状态
				if isEnd {
					err = this.StatusModifyWithDetail(taskId,res)
				}
			}

			//this.SampleAllStatusModify(res,SUCCESS)
		} else if taskType == "task_activate" {
			log.Println(">>>>>>>>>>任务[" + taskId + "]激活>>>>>>>>>>")
			if res.Data.Status == 3 {
				err = this.StatusModify(REJECT, taskId,resp)
			} else {
				err = this.StatusModify(ACTIVE, taskId, resp)
			}
		} else if taskType == "accept" {
			log.Println(">>>>>>>>>>任务[" + taskId + "]接受>>>>>>>>>>")
			err = this.StatusModify(ACCEPT, taskId, resp)
		} else if taskType == "running" {
			log.Println(">>>>>>>>>>任务[" + taskId + "]执行中>>>>>>>>>>")
			err = this.StatusModify(RUNNING, taskId, resp)
		}
	} else if result == 300 && taskType == "reject" {
		log.Println("----------任务[" + taskId + "]任务拒绝----------")
		//保存异常信息
		this.SaveExcepMsg(res, taskId, resp)
		err = this.StatusModify(REJECT, taskId, resp)
		// 判断如果为盒操作, 需要将 盒解锁, 重新执行时再上锁
		if resp == "rack_storing" || resp == "rack_retrieving" {
			err = this.UpdateBoxIsLocked(taskId)
		}
	}

	if err != nil {
		log.Println(err)
	}
}
func (this *ConverseController) UpdateBoxIsLocked(taskId string) error{
	svc := GetConverseService(utils.DBE)
	err := svc.UpdateBoxIsLocked(taskId)
	if err != nil {
		return err
	}
	return nil
}

//保存异常信息
func (this *ConverseController) SaveExcepMsg(res ResponseEntity, taskId ,reqType string) {
	svc := GetConverseService(utils.DBE)
	//causeByte,_ := json.Marshal(res.Data.Causes)
	//causeMsg := string(causeByte)
	causeMsg := svc.HandleCauses(res.Data.Causes)
	exceptMsg := svc.HandleExceptions(res.Data.Exceptions)
	//abnormalByte,_ := json.Marshal(res.Data.Abnormal_data)
	//abnormalMsg := string(abnormalByte)
	asvc := arrangeService.GetArrangeService(utils.DBE)

	var totalMsg string
	if causeMsg != "" && exceptMsg == "" {
		totalMsg = causeMsg
	} else if causeMsg == "" && exceptMsg != "" {
		totalMsg = exceptMsg
	} else if causeMsg != "" && exceptMsg == "" {
		totalMsg = causeMsg + "\\r\\n\\r\\n" + exceptMsg
	}

	if totalMsg != "" {
		svc.SaveTaskExcepMsg(totalMsg, taskId)
		// add by 徐春林 库内整理错误信息保存
		if reqType == "moving" {
			asvc.SaveArrangeExcepMsg(totalMsg, taskId)
		} else {
			svc.SaveSampleExcepMsg(totalMsg, taskId)
		}
	} else {
		//任务再次执行成功时,删除已有的异常信息
		svc.SaveTaskExcepMsg(" ", taskId)
		// add by 徐春林 库内整理错误信息保存
		if reqType == "moving" {
			asvc.SaveArrangeExcepMsg(" ", taskId)
		} else {
			svc.SaveSampleExcepMsg(" ", taskId)
		}
	}
}

//清理已完成任务信息
func (this *ConverseController) DeleteAccomplishedTask() error {
	where := "statuscode = '" + strconv.Itoa(SUCCESS) + "'"
	svc := GetConverseService(utils.DBE)
	err := svc.DeleteEntityBytbl(TABLE_TAST, where)
	log.Println("===============清除任务信息===============")
	if err != nil {
		log.Println(err)
		return err
	}
	return nil
}