package production

import (
	"path"
	"strings"

	"shylinux.com/x/ice"
	"shylinux.com/x/icebergs/base/aaa"
	"shylinux.com/x/icebergs/base/ctx"
	"shylinux.com/x/icebergs/base/mdb"
	"shylinux.com/x/icebergs/base/nfs"
	"shylinux.com/x/icebergs/base/web"
	kit "shylinux.com/x/toolkits"

	"shylinux.com/x/operation/src/operation"
	"shylinux.com/x/operation/src/production/model"
)

type Table struct {
	operation.Table
	remove     string `name:"remove" role:"worker"`
	reject     string `name:"reject" role:"leader"`
	approve    string `name:"approve" role:"leader"`
	process    string `name:"process" role:"worker"`
	submit     string `name:"submit link" role:"worker"`
	finish     string `name:"finish" role:"leader"`
	reback     string `name:"reback" role:"leader"`
	cancel     string `name:"cancel" role:"leader"`
	trash      string `name:"trash" role:"leader"`
	payfor     string `name:"payfor price* title* content" role:"leader"`
	discuss    string `name:"discuss meet_type* title* content link* date* time*" role:"leader"`
	list       string `name:"list story_uid uid auto" role:"void"`
	issueList  string `name:"issueList" role:"worker"`
	designList string `name:"designList" role:"worker"`
	taskList   string `name:"taskList" role:"worker"`
	caseList   string `name:"caseList" role:"worker"`
	meetList   string `name:"meetList" role:"worker"`
	dealList   string `name:"dealList" role:"worker"`
	preview    string `name:"preview" role:"worker"`
	program    string `name:"program" role:"worker"`
}

func (s Table) Inputs(m *ice.Message, arg ...string) {
	switch arg[0] {
	case model.USER_STORY_ROLE:
		s.InputsListRole(m, UserStoryRoleList, arg...)
	case model.STORY_TYPE:
		s.InputsList(m, StoryTypeList, arg...)
	case model.PLAN_UID:
		s.InputsUID(m, arg, Plan{}, m.OptionSimple(model.STORY_UID)...)
	case model.ISSUE_UID:
		s.InputsUID(m, arg, Issue{}, m.OptionSimple(model.STORY_UID)...)
	case model.ISSUE_TYPE:
		s.InputsList(m, IssueTypeList, arg...)
	case model.TASK_UID:
		s.InputsUID(m, arg, Task{}, m.OptionSimple(model.STORY_UID)...)
	case model.MEET_TYPE:
		s.InputsList(m, MeetTypeList, arg...)
	case model.LEVEL:
		s.InputsList(m, LevelList, arg...)
	case nfs.PATH:
		m.Option(ice.MSG_USERROLE, aaa.TECH)
		m.Cmdy(web.SPACE, m.Option(web.SPACE), nfs.DIR, nfs.SRC, nfs.PATH)
	case ctx.INDEX:
		msg := m.Spawn()
		s.Table.Inputs(msg, arg...)
		msg.Table(func(value ice.Maps) {
			if strings.HasSuffix(value[arg[0]], ".portal") {
				m.Push(arg[0], value[arg[0]])
			}
		})
	default:
		switch m.Option(ctx.ACTION) {
		case "discuss":
			switch arg[0] {
			case "date":
				for i := 0; i < 5; i++ {
					m.Push(arg[0], strings.Split(m.Time(kit.Format("%dh", i*24)), " ")[0])
				}
			case "time":
				for i := 38; i < 48; i++ {
					m.Push(arg[0], kit.Format("%02d:%s", i/2, kit.Select("30", "00", i%2 == 0)))
				}
			}
		default:
			s.Table.Inputs(m, arg...)
		}
	}
}
func (s Table) RewriteAppend(m *ice.Message, arg ...string) *ice.Message {
	m.RewriteAppend(func(value, key string, index int) string {
		switch key {
		case model.USER_STORY_ROLE:
			value = UserStoryRole(kit.Int(value)).String()
		case model.STORY_TYPE:
			value = StoryType(kit.Int(value)).String()
		case model.PLAN_STATUS:
			value = PlanStatus(kit.Int(value)).String()
		case model.ISSUE_TYPE:
			value = IssueType(kit.Int(value)).String()
		case model.ISSUE_STATUS, model.DESIGN_STATUS, model.TASK_STATUS, model.CASE_STATUS, model.STATUS:
			value = IssueStatus(kit.Int(value)).String()
		case model.MEET_TYPE:
			value = MeetType(kit.Int(value)).String()
		case model.LEVEL:
			value = Level(kit.Int(value)).String()
		}
		return value
	})
	return s.Table.RewriteAppend(m)
}
func (s Table) PushIssueButton(m *ice.Message, value ice.Maps, user_uid string, arg ...ice.Any) {
	button := []ice.Any{}
	defer func() { m.PushButton(button...) }()
	isCreator, isLeader, isWorker := s.IsCreator(m), s.IsLeader(m), s.IsWorker(m)
	switch IssueStatus(kit.Int(value[model.STATUS])) {
	case IssueCreate:
		if isCreator {
			button = append(button, s.Discuss, s.Payfor)
		}
		if isCreator {
			button = append(button, s.Approve, s.Reject)
		}
		if user_uid == value[model.USER_UID] {
			button = append(button, s.Modify, s.Remove)
		}
	case IssueRejected:
		if isLeader {
			button = append(button, s.Trash)
		}
	case IssueApproved:
		if user_uid == value[model.USER_UID] {
			button = append(button, s.Process)
		}
	case IssueProcess:
		if isCreator {
			button = append(button, s.Discuss, s.Payfor)
		}
		if user_uid == value[model.USER_UID] {
			button = append(button, s.Submit)
		}
		// button = append(button, s.Remove)
	case IssueSubmit:
		if isWorker {
			button = append(button, s.Preview)
		}
		if isCreator {
			button = append(button, s.Discuss, s.Payfor)
		}
		if isCreator {
			button = append(button, s.Finish, s.Reback, s.Cancel)
		}
	case IssueFinish:
		if isWorker {
			button = append(button, s.Preview)
		}
		if PlanStatus(kit.Int(value[model.PLAN_STATUS])) != PlanFinish {
			if isCreator {
				button = append(button, s.Discuss, s.Payfor)
			}
		}
		if isWorker {
			button = append(button, arg...)
		}
		kit.If(m.FieldsIsDetail(), func() { s.DoneMessage(m) })
	case IssueCancel:
		if isLeader {
			button = append(button, s.Trash)
		}
	}
}
func (s Table) PushTaskButton(m *ice.Message, value ice.Maps, user_uid string, arg ...ice.Any) {
	button := []ice.Any{}
	isWorker := s.IsWorker(m)
	// isCreator, isLeader, isWorker := s.IsCreator(m), s.IsLeader(m), s.IsWorker(m)
	// _ = isLeader
	switch IssueStatus(kit.Int(value[model.STATUS])) {
	case IssueCreate:
		if user_uid == value[model.USER_UID] {
			button = append(button, s.Process, s.Modify, s.Remove)
		}
	case IssueProcess:
		if isWorker {
			button = append(button, arg...)
		}
		if user_uid == value[model.USER_UID] {
			button = append(button, s.Finish)
		}
	case IssueFinish:
		if isWorker {
			button = append(button, arg...)
		}
		kit.If(m.FieldsIsDetail(), func() { s.DoneMessage(m) })
	}
	m.PushButton(button...)
}
func (s Table) SelectJoinPlan(m *ice.Message, arg ...string) {
	s.SelectJoin(m, Plan{}, model.TITLE, model.STATUS)
}
func (s Table) StatusPrice(m *ice.Message, arg ...string) {
	if m.Length() > 0 && len(arg) < 2 {
		msg := m.Spawn()
		s.Fields(msg, "sum(price) AS price")
		s.Select(msg, model.STORY_UID, arg[0]).Table(func(value ice.Maps) {
			m.Echo(model.PRICE).Echo(": ").Echo(kit.Format(kit.Int(value[model.PRICE]) / 100)).Echo(" 元")
		})
	}
}
func (s Table) StatusCount(m *ice.Message, arg ...string) {
	if m.Length() > 0 && len(arg) < 2 {
		msg := m.Spawn()
		s.Fields(msg, "status, count(*) AS count").Groups(msg, model.STATUS).Orders(msg, model.STATUS)
		s.Select(msg, model.STORY_UID, arg[0]).Table(func(value ice.Maps) {
			switch status := kit.Int(value[model.STATUS]); m.CommandKey() {
			case "plan":
				m.Echo(PlanStatus(status).String()).Echo(": ")
			case "issue", "design", "task", "case":
				m.Echo(IssueStatus(status).String()).Echo(": ")
			}
			m.Echo(value[model.COUNT]).Echo("\n")
		})
	}
}
func (s Table) Reject(m *ice.Message, arg ...string) {
	s.changeStatus(m, IssueCreate, IssueRejected)
}
func (s Table) Approve(m *ice.Message, arg ...string) {
	s.changeStatus(m, IssueCreate, IssueApproved)
}
func (s Table) Process(m *ice.Message, arg ...string) {
	s.changeStatus(m, IssueApproved, IssueProcess)
}
func (s Table) Submit(m *ice.Message, arg ...string) {
	s.ChangeStatus(m, int(IssueProcess), int(IssueSubmit), arg...)
}
func (s Table) Finish(m *ice.Message, arg ...string) {
	s.changeStatus(m, IssueSubmit, IssueFinish)
}
func (s Table) Reback(m *ice.Message, arg ...string) {
	s.ChangeStatus(m, int(IssueSubmit), int(IssueProcess))
}
func (s Table) Cancel(m *ice.Message, arg ...string) {
	s.ChangeStatus(m, int(IssueSubmit), int(IssueCancel))
}
func (s Table) Trash(m *ice.Message, arg ...string) {
	if s.IsLeader(m) {
		s.Delete(m, m.OptionSimple(model.UID, model.STORY_UID)...)
	}
}
func (s Table) Program(m *ice.Message, arg ...string) {
	p := path.Base(m.Option(nfs.PATH))
	m.ProcessOpen(kit.MergeURL(web.S(m.Option(web.SPACE))+web.C(web.VIMER), nfs.PATH, nfs.SRC, nfs.FILE, path.Join(p, "portal.go")))
}
func (s Table) Preview(m *ice.Message, arg ...string) {
	m.ProcessOpen(m.OptionDefault(model.LINK, web.S(m.Option(web.SPACE))+web.C(m.Option(ctx.INDEX))))
}
func (s Table) Payfor(m *ice.Message, arg ...string) {
	s.issueOtherCreate(m, deal{}, arg...)
}
func (s Issue) Payfor(m *ice.Message, arg ...string) {
	s.commonOtherCreate(m, deal{}, arg...)
}
func (s Table) Discuss(m *ice.Message, arg ...string) {
	s.issueOtherCreate(m, meet{}, arg...)
}
func (s Issue) Discuss(m *ice.Message, arg ...string) {
	s.commonOtherCreate(m, meet{}, arg...)
}
func (s Table) issueOtherCreate(m *ice.Message, target ice.Any, arg ...string) {
	s.OtherCreate(m, target, kit.Simple(m.OptionSimple(model.ISSUE_UID), arg)...)
}
func (s Table) commonOtherCreate(m *ice.Message, target ice.Any, arg ...string) {
	s.OtherCreate(m, target, kit.Simple(m.CommandKey()+"_uid", m.Option(model.UID), arg)...)
}
func (s Table) OtherCreate(m *ice.Message, target ice.Any, arg ...string) {
	if m.ActionKeyIsIn(s.Discuss, s.Payfor) {
		msg := s.Select(m, model.UID, m.Option(model.UID))
		arg = append(arg, model.FROM_USER_UID, m.Option(model.USER_UID), model.TO_USER_UID, msg.Append(model.USER_UID))
	}
	kit.If(m.CommandKey() != "plan", func() { arg = append(arg, m.OptionSimple(model.PLAN_UID)...) })
	m.Cmdy(target, s.Create, arg)
	kit.If(!m.IsErr(), func() { m.ProcessField(target, []string{m.Option(model.STORY_UID), m.Result()}) })
}
func (s Table) OtherList(m *ice.Message, target ice.Any, arg ...string) *ice.Message {
	m.Cmdy(target, s.Select, m.OptionSimple(model.STORY_UID), m.CommandKey()+"_uid", m.Option(model.UID)).Option("_command", ice.GetTypeKey(target))
	if m.ActionKeyIsIn(s.MeetList, s.DealList) {
		if s.IsLeader(m) {
			m.RenameAppend(model.TO_USER_UID, model.USER_UID)
		} else {
			m.RenameAppend(model.FROM_USER_UID, model.USER_UID)
		}
	}
	s.SelectJoinUser(m)
	return m
}
func (s Table) otherListButton(m *ice.Message, arg ...string) {
	m.Table(func(value ice.Maps) {
		switch IssueStatus(kit.Int(value[model.STATUS])) {
		case IssueSubmit, IssueFinish:
			if value[web.LINK] != "" {
				m.PushButton(s.Preview)
				break
			}
			fallthrough
		default:
			m.PushButton()
		}
	})
}
func (s Table) IssueList(m *ice.Message, arg ...string) {
	s.OtherList(m, Issue{}).Display("issue.js")
	s.otherListButton(m)
}
func (s Table) DesignList(m *ice.Message, arg ...string) {
	s.OtherList(m, Design{}).Display("design.js")
	s.otherListButton(m)
}
func (s Table) TaskList(m *ice.Message, arg ...string) {
	s.OtherList(m, Task{}).Display("task.js")
	m.RenameAppend(model.STATUS, model.TASK_STATUS)
	m.PushAction(s.Program)
}
func (s Table) CaseList(m *ice.Message, arg ...string) {
	s.OtherList(m, Case{}).Display("case.js")
	m.RenameAppend(model.STATUS, model.CASE_STATUS)
	m.PushAction(s.Preview)
}
func (s Table) MeetList(m *ice.Message, arg ...string) {
	s.OtherList(m, meet{}).Display("meet.js")
	m.PushAction(s.Preview)
}
func (s Table) DealList(m *ice.Message, arg ...string) {
	s.OtherList(m, deal{}).Display("deal.js")
}

func (s Table) finishCheck(m *ice.Message, target ice.Any, name string, arg ...string) bool {
	count := m.Cmd(target, s.Select, m.CommandKey()+"_uid = ? AND status != ? AND status != ? AND status != ?", m.Option(model.UID), IssueRejected, IssueFinish, IssueCancel).Length()
	if m.WarnNotValid(count > 0, kit.Format("还有 %v 个未完成的%s", count, name)) {
		return true
	}
	return false
}
func (s Table) changeStatus(m *ice.Message, from, to IssueStatus) {
	s.ChangeStatus(m, int(from), int(to), m.ActionKey()+"_time", m.Time())
}
func (s Table) ChangeStatus(m *ice.Message, from, to int, arg ...string) {
	if !s.IsLeader(m) {
		msg := s.Select(m.Spawn(), m.OptionSimple(model.STORY_UID, model.UID)...)
		if m.WarnNotRight(msg.Append(model.USER_UID) != m.Option(model.USER_UID)) {
			return
		}
	}
	s.Table.ChangeStatus(m, m.Option(model.STORY_UID), m.Option(model.UID), from, to, arg...)
	s.DashboardUpdate(m)
}
func (s Table) addCount(m *ice.Message, target ice.Any) Table {
	UID := s.Keys(target, model.UID)
	if m.IsErr() || m.Option(UID) == "" {
		return s
	}
	m.Cmd(target, s.AddCount, m.CommandKey()+"_count", kit.Select("-1", "1", m.ActionKey() == mdb.CREATE), m.Option(UID))
	return s
}
func (s Table) planCount(m *ice.Message) Table  { return s.addCount(m, Plan{}) }
func (s Table) issueCount(m *ice.Message) Table { return s.addCount(m, Issue{}) }
func (s Table) taskCount(m *ice.Message) Table  { return s.addCount(m, Task{}) }

type Tables struct{ Table }

func (s Tables) BeforeMigrate(m *ice.Message, arg ...string) {}