package yuehaoxitong

import (
	"shylinux.com/x/ice"
	"shylinux.com/x/icebergs/base/mdb"
	kit "shylinux.com/x/toolkits"

	"shylinux.com/x/community/src/yuehaoxitong/model"
)

type Schedule struct {
	Table
	userQueue userQueue
	queue     queue
	reception reception
	volume    Volume
	models    string `data:"schedule"`
	plan      string `name:"plan begin_time@date end_time@date"`
}

func (s Schedule) Create(m *ice.Message, arg ...string) {
	defer m.ToastProcess("约号中...")("约号成功")
	s.Transaction(m, func() {
		msg := m.Cmd(s.volume, s.SelectForUpdate, model.UID, m.Option(model.VOLUME_UID))
		if m.Warn(kit.Int(msg.Append(model.COUNT)) >= kit.Int(msg.Append(model.AMOUNT)), "本服务已约满") {
			return
		}
		s.addCount(m, mdb.COUNT, "1")
		s.Table.Create(m, arg...)
	})
	s.SendMessage(m, m.Option(model.USER_UID), m.Option(model.USER_UID))
	s.sendTemplate(m, "约号成功", m.Result())
	Portal{}.DashboardUpdate(m)
	m.ProcessRefresh()
}
func (s Schedule) Call(m *ice.Message, arg ...string) {
	defer m.ToastProcess("叫号中...")("叫号成功")
	user_uid := m.Option(model.USER_UID)
	s.Orders(m, model.TAKE_TIME).Limit(m, 1)
	if m.Option(model.RECEPTION_UID) != "" {
		s.SelectByStatus(m, kit.Simple(m.Option(model.QUEUE_UID), kit.Format(ScheduleTake), m.OptionSimple(model.RECEPTION_UID))...).PushAction(s.Expire, s.Finish)
	} else {
		s.SelectByStatus(m, m.Option(model.QUEUE_UID), kit.Format(ScheduleTake)).PushAction(s.Expire, s.Finish)
	}
	if m.Length() == 0 {
		m.ProcessRewrite(model.UID, "")
		return
	}
	s.changeStatus(m, ScheduleTake, ScheduleCall, model.CALL_UID, user_uid)
	s.SendMessage(m, user_uid, m.Append(model.USER_UID))
	s.sendTemplate(m, "服务已叫号", m.Append(model.UID))
	m.ProcessRewrite(model.UID, m.Append(model.UID))
}
func (s Schedule) List(m *ice.Message, arg ...string) *ice.Message {
	role := UserQueueRole(s.UserPlaceRole(m))
	s.Tables(m, s.volume).FieldsWithCreatedAT(m, s, model.SCHEDULE_STATUS, model.BEGIN_TIME, model.END_TIME,
		model.CANCEL_TIME, model.TAKE_TIME, model.CALL_TIME, model.EXPIRE_TIME, model.FINISH_TIME,
		s.Key(s, model.RECEPTION_UID), model.VOLUME_UID, s.Key(s, model.CALL_UID), model.USER_UID)
	if role == UserQueueCreator || role == UserQueueLeader {
		if len(arg) == 1 {
			s.Select(m, s.Key(s, model.QUEUE_UID), arg[0])
		} else if len(arg) == 2 {
			s.SelectDetail(m, s.Key(s, model.QUEUE_UID), arg[0], s.Key(s, model.UID), arg[1])
		}
		m.Table(func(value ice.Maps) {
			switch ScheduleStatus(kit.Int(value[model.SCHEDULE_STATUS])) {
			case SchedulePlan:
				m.PushButton(s.Cancel, s.Take)
			case ScheduleCall:
				m.PushButton(s.Expire, s.Finish)
			default:
				m.PushButton()
			}
		})
	} else if role == UserQueueWorker {
		if len(arg) == 1 {
			s.Select(m, s.Key(s, model.QUEUE_UID), arg[0], model.CALL_UID, m.Option(model.USER_UID))
		} else if len(arg) == 2 {
			s.SelectDetail(m, s.Key(s, model.QUEUE_UID), arg[0], model.CALL_UID, m.Option(model.USER_UID), s.Key(s, model.UID), arg[1])
		}
		m.Table(func(value ice.Maps) {
			switch ScheduleStatus(kit.Int(value[model.SCHEDULE_STATUS])) {
			case ScheduleCall:
				m.PushButton(s.Expire, s.Finish)
			default:
				m.PushButton()
			}
		})
	} else {
		if len(arg) == 1 {
			s.Select(m, s.Key(s, model.QUEUE_UID), arg[0], model.USER_UID, m.Option(model.USER_UID))
		} else if len(arg) == 2 {
			s.SelectDetail(m, s.Key(s, model.QUEUE_UID), arg[0], model.USER_UID, m.Option(model.USER_UID), s.Key(s, model.UID), arg[1])
		}
		m.Table(func(value ice.Maps) {
			switch ScheduleStatus(kit.Int(value[model.SCHEDULE_STATUS])) {
			case SchedulePlan:
				m.PushButton(s.Cancel, s.Take)
			default:
				m.PushButton()
			}
		})
	}
	if len(arg) == 2 {
		status := ScheduleStatus(kit.Int(m.Append(model.SCHEDULE_STATUS)))
		if status == ScheduleExpire || status == ScheduleFinish {
			s.DoneMessage(m)
		}
	}
	s.SelectJoin(m, s.reception)
	s.SelectJoinUser(m)
	m.Action().Display("")
	return m
}
func (s Schedule) SelectByStatus(m *ice.Message, arg ...string) *ice.Message {
	order := m.Option(mdb.ORDER)
	s.Tables(m, s.volume).FieldsWithCreatedAT(m, s, model.SCHEDULE_STATUS, model.BEGIN_TIME, model.END_TIME,
		model.CANCEL_TIME, model.TAKE_TIME, model.CALL_TIME, model.EXPIRE_TIME, model.FINISH_TIME,
		s.Key(s, model.RECEPTION_UID), model.VOLUME_UID, s.Key(s, model.CALL_UID), model.USER_UID)
	kit.If(order, func() { s.Orders(m, order) })
	s.Select(m, kit.Simple(s.Key(s, model.QUEUE_UID), arg[0], model.STATUS, arg[1], arg[2:])...)
	s.SelectJoin(m, s.reception)
	s.SelectJoinUser(m)
	m.Action().Display("")
	return m
}
func (s Schedule) Cancel(m *ice.Message, arg ...string) {
	defer m.ToastProcess("取消中...")("取消成功")
	args := m.OptionSimple(model.USER_UID, model.UID)
	if m.WarnNotFound(s.Select(m, args...).Length() == 0) {
		return
	}
	s.Transaction(m, func() {
		s.addCount(m, mdb.COUNT, "-1")
		s.changeStatus(m, SchedulePlan, ScheduleCancel)
	})
	m.ProcessRefresh()
}
func (s Schedule) Take(m *ice.Message, arg ...string) {
	defer m.ToastProcess("取号中...")("取号成功")
	args := m.OptionSimple(model.USER_UID, model.UID)
	if m.WarnNotFound(s.Select(m, args...).Length() == 0) {
		return
	}
	s.changeStatus(m, SchedulePlan, ScheduleTake)
	m.ProcessRefresh()
	Portal{}.DashboardUpdate(m)
}
func (s Schedule) Expire(m *ice.Message, arg ...string) {
	defer m.ToastProcess("过号中...")("过号成功")
	args := kit.Simple(model.CALL_UID, m.Option(model.USER_UID), m.OptionSimple(model.UID))
	if m.WarnNotFound(s.Select(m, args...).Length() == 0) {
		return
	}
	s.Transaction(m, func() {
		s.addCount(m, "", "1")
		s.changeStatus(m, ScheduleCall, ScheduleExpire)
	})
	s.Select(m.FieldsSetDetail(), args...)
	s.sendTemplate(m, "服务已过号")
}
func (s Schedule) Finish(m *ice.Message, arg ...string) {
	defer m.ToastProcess("完成中...")("完成成功")
	args := kit.Simple(model.CALL_UID, m.Option(model.USER_UID), m.OptionSimple(model.UID))
	if m.WarnNotFound(s.Select(m, args...).Length() == 0) {
		return
	}
	s.Transaction(m, func() {
		s.addCount(m, "", "1")
		s.changeStatus(m, ScheduleCall, ScheduleFinish)
	})
	s.Select(m.FieldsSetDetail(), args...)
	s.sendTemplate(m, "服务已完成")
	Portal{}.DashboardUpdate(m)
}

func init() { ice.TeamCtxCmd(Schedule{}) }

func (s Schedule) addCount(m *ice.Message, key, count string) {
	m.Cmd(s.volume, s.AddCount, kit.Select(m.ActionKey(), key), count, m.Option(model.VOLUME_UID))
}
func (s Schedule) changeStatus(m *ice.Message, from, to ScheduleStatus, arg ...string) *ice.Message {
	key := m.ActionKey() + "_time"
	s.Table.ChangeStatus(m, m.Option(model.UID), int(from), int(to), append(arg, key, m.Time())...)
	return m
}
func (s Schedule) sendTemplate(m *ice.Message, title string, arg ...string) *ice.Message {
	reception := m.Cmd(s.reception, s.Select, model.UID, m.Option(model.RECEPTION_UID))
	s.Table.SendTemplate(m, "", m.Append(model.USER_UID), kit.JoinWord(title, reception.Append(model.NAME)),
		kit.JoinWord(m.Option(model.CITY_NAME), m.Option(model.STREET_NAME), m.Option(model.PLACE_NAME)), kit.Select("", arg, 0), m.Option(model.QUEUE_UID))
	return m
}

type ScheduleStatus int

const (
	SchedulePlan ScheduleStatus = iota
	ScheduleCancel
	ScheduleTake
	ScheduleCall
	ScheduleExpire
	ScheduleFinish
)

var ScheduleStatusList = map[ScheduleStatus]string{
	SchedulePlan:   "plan",
	ScheduleCancel: "cancel",
	ScheduleTake:   "take",
	ScheduleCall:   "call",
	ScheduleExpire: "expire",
	ScheduleFinish: "finish",
}

func (s ScheduleStatus) String() string { return ScheduleStatusList[s] }