package server

import (
	"context"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/quick"
	"gitlab.com/Timfa/bluegit/internal/store"
)

type quickBase struct {
	Labels       []string
	Assignees    []string
	Milestone    string
	Due          string
	Confidential bool
}

type quickResult struct {
	Body         string
	LabelIDs     []int64
	AssigneeIDs  []int64
	MilestoneID  int64
	Due          string
	Confidential bool
	Labels       bool
	Assignees    bool
	Meta         bool
}

func (q quickResult) touched() bool {
	return q.Labels || q.Assignees || q.Meta
}

// foldQuick haalt quick actions uit de tekst als de gebruiker ze mag uitvoeren.
// Een regel zonder recht blijft staan. Een onbekend label of een onbekende
// gebruiker is een fout en er wordt nog niets opgeslagen.
func (s *Server) foldQuick(ctx context.Context, repo store.Repo, body string, canTriage, creating bool, base quickBase) (quickResult, error) {
	labels := append([]string{}, base.Labels...)
	assignees := append([]string{}, base.Assignees...)
	mile := base.Milestone
	due := base.Due
	conf := base.Confidential
	var kept []string
	var touchL, touchA, touchM bool
	for _, p := range quick.Scan(body) {
		if p.Cmd == nil || !allowQuick(p.Cmd.Kind, canTriage, creating) {
			kept = append(kept, p.Text)
			continue
		}
		switch p.Cmd.Kind {
		case "label":
			touchL = true
			for _, name := range p.Cmd.Names {
				if !hasName(labels, name) {
					labels = append(labels, name)
				}
			}
		case "unlabel":
			touchL = true
			labels = dropNames(labels, p.Cmd.Names)
		case "assign":
			touchA = true
			for _, name := range p.Cmd.Names {
				if !hasFold(assignees, name) {
					assignees = append(assignees, name)
				}
			}
		case "unassign":
			touchA = true
			assignees = dropFold(assignees, p.Cmd.Names)
		case "milestone":
			touchM = true
			mile = p.Cmd.Names[0]
		case "due":
			touchM = true
			due = p.Cmd.Due
		case "confidential":
			touchM = true
			conf = true
		}
	}
	res := quickResult{Body: strings.Join(kept, "\n"), Due: due, Confidential: conf, Labels: touchL, Assignees: touchA, Meta: touchM}
	if touchL {
		ids, err := s.resolveLabels(ctx, repo.ID, labels)
		if err != nil {
			return quickResult{}, err
		}
		res.LabelIDs = ids
	}
	if touchA {
		ids, err := s.resolveAssignees(ctx, repo, assignees)
		if err != nil {
			return quickResult{}, err
		}
		res.AssigneeIDs = ids
	}
	if touchM {
		id, err := s.resolveMilestone(ctx, repo.ID, mile)
		if err != nil {
			return quickResult{}, err
		}
		if err := store.ValidDue(due); err != nil {
			return quickResult{}, err
		}
		res.MilestoneID = id
	}
	return res, nil
}

func (s *Server) persistQuick(ctx context.Context, repo store.Repo, issueID int64, res quickResult) error {
	if res.Labels {
		if err := s.Store.SetIssueLabels(ctx, repo.ID, issueID, res.LabelIDs); err != nil {
			return err
		}
	}
	if res.Assignees {
		if err := s.Store.SetIssueAssignees(ctx, repo.ID, issueID, res.AssigneeIDs); err != nil {
			return err
		}
	}
	if res.Meta {
		if err := s.Store.SetIssueMeta(ctx, repo.ID, issueID, res.MilestoneID, res.Confidential, res.Due); err != nil {
			return err
		}
	}
	return nil
}

func allowQuick(kind string, canTriage, creating bool) bool {
	if canTriage {
		return true
	}
	return creating && kind == "confidential"
}

func hasName(list []string, name string) bool {
	for _, item := range list {
		if item == name {
			return true
		}
	}
	return false
}

func hasFold(list []string, name string) bool {
	for _, item := range list {
		if strings.EqualFold(item, name) {
			return true
		}
	}
	return false
}

func dropNames(list, gone []string) []string {
	dead := map[string]bool{}
	for _, name := range gone {
		dead[name] = true
	}
	var out []string
	for _, name := range list {
		if !dead[name] {
			out = append(out, name)
		}
	}
	return out
}

func dropFold(list, gone []string) []string {
	var out []string
	for _, name := range list {
		if !hasFold(gone, name) {
			out = append(out, name)
		}
	}
	return out
}

func quickFromIssue(iss store.Issue) quickBase {
	return quickBase{
		Labels: labelNames(iss.Labels), Assignees: append([]string{}, iss.Assignees...),
		Milestone: iss.Milestone, Due: iss.DueOn, Confidential: iss.Confidential,
	}
}
