HarborForge.Cli/internal/commands/meeting.go

package commands

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

	"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"
)

// meetingResponse matches the backend MeetingResponse schema.
type meetingResponse struct {
	ID            int      `json:"id"`
	Code          string   `json:"code"`
	Title         string   `json:"title"`
	Description   *string  `json:"description"`
	Status        string   `json:"status"`
	MeetingTime   *string  `json:"meeting_time"`
	ProjectCode   string   `json:"project_code"`
	MilestoneCode *string  `json:"milestone_code"`
	Participants  []string `json:"participants"`
	CreatedAt     string   `json:"created_at"`
}

// RunMeetingList implements `hf meeting list`.
func RunMeetingList(args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

	query := ""
	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--project":
			if i+1 >= len(args) {
				output.Error("--project requires a value")
			}
			i++
			query = appendQuery(query, "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)
	}
	c := client.New(cfg.BaseURL, token)
	path := "/meetings"
	if query != "" {
		path += "?" + query
	}
	data, err := c.Get(path)
	if err != nil {
		output.Errorf("failed to list meetings: %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 meetings []meetingResponse
	if err := json.Unmarshal(data, &meetings); err != nil {
		output.Errorf("cannot parse meeting list: %v", err)
	}

	headers := []string{"CODE", "TITLE", "STATUS", "TIME", "PROJECT"}
	var rows [][]string
	for _, m := range meetings {
		meetTime := ""
		if m.MeetingTime != nil {
			meetTime = *m.MeetingTime
		}
		title := m.Title
		if len(title) > 40 {
			title = title[:37] + "..."
		}
		rows = append(rows, []string{m.Code, title, m.Status, meetTime, m.ProjectCode})
	}
	output.PrintTable(headers, rows)
}

// RunMeetingGet implements `hf meeting get <meeting-code>`.
func RunMeetingGet(meetingCode, 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("/meetings/" + meetingCode)
	if err != nil {
		output.Errorf("failed to get meeting: %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 meetingResponse
	if err := json.Unmarshal(data, &m); err != nil {
		output.Errorf("cannot parse meeting: %v", err)
	}

	desc := ""
	if m.Description != nil {
		desc = *m.Description
	}
	meetTime := ""
	if m.MeetingTime != nil {
		meetTime = *m.MeetingTime
	}
	milestone := ""
	if m.MilestoneCode != nil {
		milestone = *m.MilestoneCode
	}
	participants := ""
	if len(m.Participants) > 0 {
		for i, p := range m.Participants {
			if i > 0 {
				participants += ", "
			}
			participants += p
		}
	}
	output.PrintKeyValue(
		"code", m.Code,
		"title", m.Title,
		"description", desc,
		"status", m.Status,
		"time", meetTime,
		"project", m.ProjectCode,
		"milestone", milestone,
		"participants", participants,
		"created", m.CreatedAt,
	)
}

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

	project, title, milestone, desc, meetTime := "", "", "", "", ""
	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 "--milestone":
			if i+1 >= len(args) {
				output.Error("--milestone requires a value")
			}
			i++
			milestone = args[i]
		case "--desc":
			if i+1 >= len(args) {
				output.Error("--desc requires a value")
			}
			i++
			desc = args[i]
		case "--time":
			if i+1 >= len(args) {
				output.Error("--time requires a value")
			}
			i++
			meetTime = args[i]
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

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

	payload := map[string]interface{}{
		"project_code": project,
		"title":        title,
	}
	if milestone != "" {
		payload["milestone_code"] = milestone
	}
	if desc != "" {
		payload["description"] = desc
	}
	if meetTime != "" {
		payload["meeting_time"] = meetTime
	}

	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("/meetings", bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to create meeting: %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 meetingResponse
	if err := json.Unmarshal(data, &m); err != nil {
		fmt.Printf("meeting created: %s\n", title)
		return
	}
	fmt.Printf("meeting created: %s (code: %s)\n", m.Title, m.Code)
}

// RunMeetingUpdate implements `hf meeting update <meeting-code>`.
func RunMeetingUpdate(meetingCode 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 "--time":
			if i+1 >= len(args) {
				output.Error("--time requires a value")
			}
			i++
			payload["meeting_time"] = 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("/meetings/"+meetingCode, bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to update meeting: %v", err)
	}

	fmt.Printf("meeting updated: %s\n", meetingCode)
}

// RunMeetingAttend implements `hf meeting attend <meeting-code>`.
func RunMeetingAttend(meetingCode, 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.Post("/meetings/"+meetingCode+"/attend", nil)
	if err != nil {
		output.Errorf("failed to attend meeting: %v", err)
	}

	fmt.Printf("attending meeting: %s\n", meetingCode)
}

// RunMeetingDelete implements `hf meeting delete <meeting-code>`.
func RunMeetingDelete(meetingCode, 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("/meetings/" + meetingCode)
	if err != nil {
		output.Errorf("failed to delete meeting: %v", err)
	}
	fmt.Printf("meeting deleted: %s\n", meetingCode)
}