HarborForge.Cli/internal/commands/milestone.go

package commands

import (
	"bytes"
	"encoding/json"
	"fmt"
	"strings"

	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/client"
	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/config"
	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/output"
)

// milestoneResponse matches the backend MilestoneResponse schema.
type milestoneResponse struct {
	ID          int     `json:"id"`
	Code        string  `json:"code"`
	Title       string  `json:"title"`
	Description *string `json:"description"`
	Status      string  `json:"status"`
	DueDate     *string `json:"due_date"`
	ProjectCode string  `json:"project_code"`
	CreatedAt   string  `json:"created_at"`
}

// milestoneProgressResponse matches the backend progress response.
type milestoneProgressResponse struct {
	Code       string  `json:"code"`
	Title      string  `json:"title"`
	Status     string  `json:"status"`
	TotalTasks int     `json:"total_tasks"`
	DoneTasks  int     `json:"done_tasks"`
	Progress   float64 `json:"progress"`
}

// milestoneProject extracts the project code from a milestone code
// (e.g. "PFIXTU:00001" -> "PFIXTU"); milestones are nested under their
// project in the API (/projects/{project}/milestones/{code}).
func milestoneProject(code string) string {
	if i := strings.IndexByte(code, ':'); i >= 0 {
		return code[:i]
	}
	return code
}

// toMilestoneDateTime anchors a bare YYYY-MM-DD due date to a datetime, since
// the backend's due_date field requires a full datetime.
func toMilestoneDateTime(d string) string {
	if len(d) == 10 {
		return d + "T00:00:00Z"
	}
	return d
}

// RunMilestoneList implements `hf milestone list --project <project-code>`.
func RunMilestoneList(args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

	query, project := "", ""
	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--project":
			if i+1 >= len(args) {
				output.Error("--project requires a value")
			}
			i++
			project = args[i]
		case "--status":
			if i+1 >= len(args) {
				output.Error("--status requires a value")
			}
			i++
			query = appendQuery(query, "status", args[i])
		case "--order-by":
			if i+1 >= len(args) {
				output.Error("--order-by requires a value")
			}
			i++
			query = appendQuery(query, "order_by", args[i])
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	if project == "" {
		output.Error("--project is required (milestones are listed per project)")
	}
	c := client.New(cfg.BaseURL, token)
	path := "/projects/" + project + "/milestones"
	if query != "" {
		path += "?" + query
	}
	data, err := c.Get(path)
	if err != nil {
		output.Errorf("failed to list milestones: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var milestones []milestoneResponse
	if err := json.Unmarshal(data, &milestones); err != nil {
		output.Errorf("cannot parse milestone list: %v", err)
	}

	headers := []string{"CODE", "TITLE", "STATUS", "DUE DATE", "PROJECT"}
	var rows [][]string
	for _, m := range milestones {
		due := ""
		if m.DueDate != nil {
			due = *m.DueDate
		}
		rows = append(rows, []string{m.Code, m.Title, m.Status, due, m.ProjectCode})
	}
	output.PrintTable(headers, rows)
}

// RunMilestoneGet implements `hf milestone get <milestone-code>`.
func RunMilestoneGet(milestoneCode, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Get("/projects/" + milestoneProject(milestoneCode) + "/milestones/" + milestoneCode)
	if err != nil {
		output.Errorf("failed to get milestone: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var m milestoneResponse
	if err := json.Unmarshal(data, &m); err != nil {
		output.Errorf("cannot parse milestone: %v", err)
	}

	desc := ""
	if m.Description != nil {
		desc = *m.Description
	}
	due := ""
	if m.DueDate != nil {
		due = *m.DueDate
	}
	output.PrintKeyValue(
		"code", m.Code,
		"title", m.Title,
		"description", desc,
		"status", m.Status,
		"due-date", due,
		"project", m.ProjectCode,
		"created", m.CreatedAt,
	)
}

// RunMilestoneCreate implements `hf milestone create`.
func RunMilestoneCreate(args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

	project, title, desc, due := "", "", "", ""
	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--project":
			if i+1 >= len(args) {
				output.Error("--project requires a value")
			}
			i++
			project = args[i]
		case "--title":
			if i+1 >= len(args) {
				output.Error("--title requires a value")
			}
			i++
			title = args[i]
		case "--desc":
			if i+1 >= len(args) {
				output.Error("--desc requires a value")
			}
			i++
			desc = args[i]
		case "--due":
			if i+1 >= len(args) {
				output.Error("--due requires a value")
			}
			i++
			due = args[i]
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

	if project == "" || title == "" {
		output.Error("usage: hf milestone create --project <project-code> --title <title>")
	}

	payload := map[string]interface{}{
		"project_code": project,
		"title":        title,
	}
	if desc != "" {
		payload["description"] = desc
	}
	if due != "" {
		payload["due_date"] = toMilestoneDateTime(due)
	}

	body, err := json.Marshal(payload)
	if err != nil {
		output.Errorf("cannot marshal payload: %v", err)
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Post("/projects/"+project+"/milestones", bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to create milestone: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var m milestoneResponse
	if err := json.Unmarshal(data, &m); err != nil {
		fmt.Printf("milestone created: %s\n", title)
		return
	}
	fmt.Printf("milestone created: %s (code: %s)\n", m.Title, m.Code)
}

// RunMilestoneUpdate implements `hf milestone update <milestone-code>`.
func RunMilestoneUpdate(milestoneCode string, args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

	payload := make(map[string]interface{})
	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--title":
			if i+1 >= len(args) {
				output.Error("--title requires a value")
			}
			i++
			payload["title"] = args[i]
		case "--desc":
			if i+1 >= len(args) {
				output.Error("--desc requires a value")
			}
			i++
			payload["description"] = args[i]
		case "--status":
			if i+1 >= len(args) {
				output.Error("--status requires a value")
			}
			i++
			payload["status"] = args[i]
		case "--due":
			if i+1 >= len(args) {
				output.Error("--due requires a value")
			}
			i++
			payload["due_date"] = toMilestoneDateTime(args[i])
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

	if len(payload) == 0 {
		output.Error("nothing to update — provide at least one flag")
	}

	body, err := json.Marshal(payload)
	if err != nil {
		output.Errorf("cannot marshal payload: %v", err)
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	_, err = c.Patch("/projects/"+milestoneProject(milestoneCode)+"/milestones/"+milestoneCode, bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to update milestone: %v", err)
	}

	fmt.Printf("milestone updated: %s\n", milestoneCode)
}

// RunMilestoneDelete implements `hf milestone delete <milestone-code>`.
func RunMilestoneDelete(milestoneCode, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	_, err = c.Delete("/projects/" + milestoneProject(milestoneCode) + "/milestones/" + milestoneCode)
	if err != nil {
		output.Errorf("failed to delete milestone: %v", err)
	}
	fmt.Printf("milestone deleted: %s\n", milestoneCode)
}

// RunMilestoneProgress implements `hf milestone progress <milestone-code>`.
func RunMilestoneProgress(milestoneCode, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Get("/projects/" + milestoneProject(milestoneCode) + "/milestones/" + milestoneCode + "/progress")
	if err != nil {
		output.Errorf("failed to get milestone progress: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var p milestoneProgressResponse
	if err := json.Unmarshal(data, &p); err != nil {
		output.Errorf("cannot parse progress: %v", err)
	}

	output.PrintKeyValue(
		"code", p.Code,
		"title", p.Title,
		"status", p.Status,
		"total-tasks", fmt.Sprintf("%d", p.TotalTasks),
		"done-tasks", fmt.Sprintf("%d", p.DoneTasks),
		"progress", fmt.Sprintf("%.1f%%", p.Progress*100),
	)
}