package hc_common

import (
	"time"
)

//转运任务
type AgvTask struct {
	Uid          string    `json:"uid,omitempty"`
	Name         string    `json:"task_name,omitempty"`     //任务名称
	Code         string    `json:"task_code,omitempty"`     //任务编码
	MaterialCode string    `json:"material_code,omitempty"` //物料编码
	Res          Res       `json:"Res,omitempty"`           //执行该任务的资源
	Stat         TaskType  `json:"stat,omitempty"`          //任务状态
	StatMsg      string    `json:"stat_msg,omitempty"`      //任务改变状态的说明
	EarlyTime    time.Time `json:"early_time,omitempty"`    //最早开始时间
	LatestTime   time.Time `json:"latest_time,omitempty"`   //最晚结束时间
	StartTime    time.Time `json:"start_time,omitempty"`    //实际开工时间
	EndTime      time.Time `json:"end_time,omitempty"`      //实际完工时间
	SubTask      []ITask    `json:"sub_task,omitempty"`      //任务链中的下一个任务
	FromPoint    []Res     `json:"from_point,omitempty"`    //任务开始点资源(可以从几个点取货)
	ToPoint      []Res     `json:"to_point,omitempty"`      //任务结束点资源(可以送往几个点)

	//PreTask                 *Task     `json:"pre_task,omitempty"`      //前置任务
	//NextTask                *Task     `json:"sub_task,omitempty"`      //后置任务
	Planed                  bool     `json:"planed,omitempty"`    //已经计算过
	TimePath                timeNode `json:"time_node,omitempty"` //计算后占用对应资源的时间点集合
	DType                   []string `json:"dgraph.type,omitempty"`
	beforeCancelTaskHandler BeforeCancelTaskHandler
	afterCancelHandler      AfterCancelTaskHandler
	beforeActivateHandler   BeforeActivateTaskHandler
	beforeStatChangeHandler BeforeStatChangeHandler
	afterStatChangeHandler  AfterStatChangeHandler
	overHandler             OverHandler
}

func NewAgvTask(n string, mc string, res Res, fromPoint []Res, toPoint []Res) AgvTask {
	agv := AgvTask{
		Name:                    n,
		Code:                    "",
		MaterialCode:            mc,
		Res:                     res,
		Stat:                    0,
		StatMsg:                 "",
		EarlyTime:               time.Time{},
		LatestTime:              time.Time{},
		StartTime:               time.Time{},
		EndTime:                 time.Time{},
		DType:                   []string{"AgvTask"},
		SubTask:                 nil,
		Planed:                  false,
		TimePath:                timeNode{},
		FromPoint: fromPoint,
		ToPoint:   toPoint,
	}

	return agv
}
//
//
////激活函数
//func (t AgvTask) Activate() error {
//	return nil
//}
//
////取消任务
//func (t AgvTask) Cancel(b bool) error {
//	err := t.beforeCancelTaskHandler()
//	if !b && err != nil {
//		return errors.New("取消任务，处理前置任务出错")
//	}
//	t.Stat = Task_stat_cancel
//	e := t.afterCancelHandler()
//	if e != nil {
//		return errors.New("任务已取消，但执行后续函数出错")
//	}
//	return nil
//}
//
////改变任务的状态
////Stat： 需要改变的状态
//func (t AgvTask) NextStat(stat TaskType) error {
//	switch stat {
//	case Task_stat_draft:
//		if t.Stat == Task_stat_over {
//			return errors.New("已完成的任务不能重启")
//		}
//		t.Stat = stat
//	case Task_stat_actived:
//		if t.Stat == Task_stat_over {
//			return errors.New("已完成的任务不能重启")
//		}
//		t.Stat = stat
//	case Task_stat_run:
//		if t.Stat == Task_stat_over {
//			return errors.New("已完成的任务不能重启")
//		}
//		t.Stat = stat
//	case Task_stat_cancel:
//		if t.Stat == Task_stat_over {
//			return errors.New("已完成的任务不能重启")
//		}
//		t.Stat = stat
//	case Task_stat_over:
//		t.Stat = stat
//	default:
//		return errors.New("未知的任务状态类型")
//	}
//
//	return nil
//}
//
////设置 任务取消前 触发函数
//func (t AgvTask) SetBeforeCancelHandler(f BeforeCancelTaskHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.beforeCancelTaskHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the afterCancelTaskHandler must be a function")
//	}
//	t.beforeCancelTaskHandler = f
//	return nil
//}
//
////设置 任务取消后 触发函数
//func (t AgvTask) SetAfterCancelHandler(f AfterCancelTaskHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.afterCancelHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the afterCancelTaskHandler must be a function")
//	}
//	t.afterCancelHandler = f
//	return nil
//}
//
////设置 任务激活前的 处理函数
//func (t AgvTask) SetBeforeActivateHandler(f BeforeActivateTaskHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.beforeActivateHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the beforeActivateTaskHandler must be a function")
//	}
//	t.beforeActivateHandler = f
//	return nil
//}
//
////设置 任务状态修改前的 处理函数
//func (t AgvTask) SetBeforeStatChange(f BeforeStatChangeHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.beforeStatChangeHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the beforeStatChangeHandler must be a function")
//	}
//	t.beforeStatChangeHandler = f
//	return nil
//}
//
////设置 任务的状态改变后的处理行数
//func (t AgvTask) SetAfterStatChange(f AfterStatChangeHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.afterStatChangeHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the afterStatChangeHandler must be a function")
//	}
//	t.afterStatChangeHandler = f
//	return nil
//}
//
////设置 任务完成后的 处理函数
//func (t AgvTask) SetOverHandler(f OverHandler) error {
//	if f == nil || reflect.TypeOf(f).Kind() != reflect.Func {
//		t.overHandler = func() error {
//			return nil
//		}
//		return errors.New("the type of the overHandler must be a function")
//	}
//	t.overHandler = f
//	return nil
//}
//func (t AgvTask) SetSubTask(iTask ITask) error {
//	if t.SubTask == nil || len(t.SubTask) == 0 {
//		t.SubTask = []ITask{iTask}
//		return nil
//	}else{
//		t.SubTask = append(t.SubTask,iTask)
//	}
//	return errors.New("不是期望的任务类型")
//}
//func (t AgvTask) SetType(s string) error {
//	if t.DType == nil || len(t.DType) == 0 {
//		t.DType = []string{s}
//	}else{
//		t.DType = append(t.DType, s)
//	}
//	return nil
//}
//
//func (t AgvTask) SetPlan(startTime time.Time, endTime time.Time) error {
//	if startTime.Before(endTime) {
//		t.Planed = true
//		t.EarlyTime = startTime
//		t.LatestTime = endTime
//	}
//	return nil
//}
//func (t AgvTask) ForStat() TaskType {
//	return t.Stat
//}
//func (t AgvTask) ForRunTime() int64 {
//	return int64(time.Now().Sub(t.StartTime).Minutes())
//}
//
//func (t AgvTask) ForIsPlan() bool {
//	return t.Planed
//}
//
//
////计划执行持续时间,秒
//func (t AgvTask) DurationPlanMinutes() int64 {
//	if t.Planed {
//		return int64(t.LatestTime.Sub(t.EarlyTime).Seconds())
//	}
//	return -1
//}
//
////执行的真实持续时间，秒
//func (t AgvTask) DurationDoMinutes() int64 {
//	if t.Planed && t.Stat == Task_stat_over {
//		return int64(t.EndTime.Sub(t.StartTime).Minutes())
//	}
//	return -1
//}
//
////任务类型
//func (t AgvTask) TypeOf() string {
//	return ""
//}