package cli

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"

	"git.knownelement.com/ukrrs/mopac-redmine-go/redmine"
)

func marshalIndent(v any) ([]byte, error) { return json.MarshalIndent(v, "", "  ") }

// --- issue -----------------------------------------------------------------

func cmdIssue(args []string, stdout, stderr io.Writer) int {
	if len(args) == 0 {
		return usageErr(stderr, "issue: expected list|show|create|update (see mred help)")
	}
	sub, rest := args[0], args[1:]
	switch sub {
	case "list":
		return cmdIssueList(rest, stdout, stderr)
	case "show":
		return cmdIssueShow(rest, stdout, stderr)
	case "create":
		return cmdIssueCreate(rest, stdout, stderr)
	case "update":
		return cmdIssueUpdate(rest, stdout, stderr)
	default:
		return usageErr(stderr, "issue: unknown subcommand %q", sub)
	}
}

func cmdIssueList(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("issue list", stderr)
	project := fs.String("p", "", "project identifier (required)")
	status := fs.String("status", "open", "open|all|closed|status name")
	version := fs.String("version", "", "target version name")
	limit := fs.Int("limit", 0, "max issues returned (0 = server default)")
	pos, err := parseArgs(fs, args)
	if err != nil || len(pos) != 0 || *project == "" {
		return usageErr(stderr, "issue list: usage: mred issue list -p PROJECT [--status open|all|NAME] [--version NAME] [--limit N]")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	ctx := context.Background()

	f := redmine.IssueFilter{Project: *project, Limit: *limit}
	switch s := *status; s {
	case "open", "all", "closed":
		f.Status = map[string]string{"all": redmine.StatusAll}[s]
		if f.Status == "" {
			f.Status = s
		}
	default:
		id, err := c.StatusIDByName(ctx, s)
		if err != nil {
			return apiErr(stderr, err)
		}
		f.Status = strconv.Itoa(id)
	}
	if *version != "" {
		id, err := c.VersionIDByName(ctx, *project, *version)
		if err != nil {
			return apiErr(stderr, err)
		}
		f.FixedVersion = id
	}

	issues, _, err := c.ListIssues(ctx, f)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"issues": issues})
		return 0
	}
	for _, i := range issues {
		line := fmt.Sprintf("%-6d %-14s %s", i.ID, i.Status.Name, i.Subject)
		if i.FixedVersion.Name != "" {
			line += "  @" + i.FixedVersion.Name
		}
		fmt.Fprintln(stdout, line)
	}
	return 0
}

func cmdIssueShow(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("issue show", stderr)
	with := fs.String("with", "", "extra sections to include: journals")
	pos, err := parseArgs(fs, args)
	if err != nil || len(pos) != 1 {
		return usageErr(stderr, "issue show: usage: mred issue show ID [--with journals]")
	}
	id, err := strconv.Atoi(pos[0])
	if err != nil {
		return usageErr(stderr, "issue show: ID must be numeric, got %q", pos[0])
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	withJournals := false
	switch *with {
	case "":
	case "journals":
		withJournals = true
	default:
		return usageErr(stderr, "issue show: --with understands only journals")
	}
	issue, err := c.GetIssue(context.Background(), id, withJournals)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"issue": issue})
		return 0
	}
	printIssue(stdout, issue, withJournals)
	return 0
}

func printIssue(w io.Writer, i *redmine.Issue, withJournals bool) {
	fmt.Fprintf(w, "#%d  %s\n", i.ID, i.Subject)
	fmt.Fprintf(w, "Tracker: %-10s Status: %-12s Priority: %s\n", i.Tracker.Name, i.Status.Name, i.Priority.Name)
	meta := "Project: " + i.Project.Name
	if i.FixedVersion.Name != "" {
		meta += "  Version: " + i.FixedVersion.Name
	}
	if i.Category.Name != "" {
		meta += "  Category: " + i.Category.Name
	}
	if i.Parent.ID != 0 {
		meta += "  Parent: #" + strconv.Itoa(i.Parent.ID)
	}
	fmt.Fprintln(w, meta)
	facts := ""
	if i.DueDate != "" {
		facts += "Due: " + i.DueDate + "  "
	}
	if i.EstimatedHours != nil {
		facts += fmt.Sprintf("Estimate: %gh  ", *i.EstimatedHours)
	}
	if i.DoneRatio != 0 {
		facts += fmt.Sprintf("Done: %d%%  ", i.DoneRatio)
	}
	if facts != "" {
		fmt.Fprintln(w, strings.TrimRight(facts, " "))
	}
	fmt.Fprintf(w, "Created: %s  Updated: %s\n", i.CreatedOn, i.UpdatedOn)
	if i.Description != "" {
		fmt.Fprintln(w)
		fmt.Fprintln(w, i.Description)
	}
	if withJournals && len(i.Journals) > 0 {
		fmt.Fprintln(w)
		fmt.Fprintln(w, "Journals:")
		for _, j := range i.Journals {
			fmt.Fprintf(w, "* %s user %d: %s\n", j.CreatedOn, j.UserID, j.Notes)
		}
	}
}

func cmdIssueCreate(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("issue create", stderr)
	project := fs.String("p", "", "project identifier (required)")
	subject := fs.String("s", "", "subject (required)")
	desc := fs.String("desc", "", "description from FILE, or - for stdin")
	tracker := fs.String("tracker", "", "tracker name (e.g. feature)")
	priority := fs.String("priority", "", "priority name (e.g. immediate)")
	category := fs.String("category", "", "category name")
	version := fs.String("version", "", "target version name")
	due := fs.String("due", "", "due date YYYY-MM-DD")
	parent := fs.Int("parent", 0, "parent issue id")
	est := fs.Float64("est", 0, "estimated hours")
	note := fs.String("note", "", "create-time journal note")
	pos, perr := parseArgs(fs, args)
	if perr != nil || len(pos) != 0 || *project == "" || *subject == "" {
		return usageErr(stderr, "issue create: usage: mred issue create -p PROJECT -s SUBJECT [flags] (see mred help)")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	ctx := context.Background()

	p := redmine.IssueParams{Project: *project, Subject: *subject, DueDate: *due, Notes: *note}
	if *desc != "" {
		text, err := readDesc(*desc)
		if err != nil {
			return usageErr(stderr, "%v", err)
		}
		p.Description = text
	}
	if *tracker != "" {
		if p.TrackerID, err = c.TrackerIDByName(ctx, *tracker); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *priority != "" {
		if p.PriorityID, err = c.PriorityIDByName(ctx, *priority); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *category != "" {
		if p.CategoryID, err = c.CategoryIDByName(ctx, *project, *category); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *version != "" {
		if p.FixedVersionID, err = c.VersionIDByName(ctx, *project, *version); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *parent != 0 {
		p.ParentIssueID = *parent
	}
	if *est != 0 {
		p.EstimatedHours = est
	}

	issue, err := c.CreateIssue(ctx, p)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"issue": issue})
		return 0
	}
	fmt.Fprintf(stdout, "created issue #%d: %s\n", issue.ID, issue.Subject)
	return 0
}

func cmdIssueUpdate(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("issue update", stderr)
	status := fs.String("status", "", "status name (e.g. done, \"In Progress\")")
	priority := fs.String("priority", "", "priority name")
	category := fs.String("category", "", "category name")
	version := fs.String("version", "", "target version name")
	due := fs.String("due", "", "due date YYYY-MM-DD")
	doneRatio := fs.Int("done-ratio", -1, "progress percent 0-100")
	desc := fs.String("desc", "", "replace description from FILE, or - for stdin")
	note := fs.String("note", "", "append a journal note")
	pos, perr := parseArgs(fs, args)
	if perr != nil || len(pos) != 1 {
		return usageErr(stderr, "issue update: usage: mred issue update ID [flags] (see mred help)")
	}
	id, err := strconv.Atoi(pos[0])
	if err != nil {
		return usageErr(stderr, "issue update: ID must be numeric, got %q", pos[0])
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	ctx := context.Background()

	p := redmine.IssueParams{Notes: *note}

	// category/version names resolve within the issue's own project.
	var projectID string
	resolveProject := func() (string, error) {
		if projectID != "" {
			return projectID, nil
		}
		fresh, err := c.GetIssue(ctx, id, false)
		if err != nil {
			return "", err
		}
		if fresh.Project.ID == 0 {
			return "", fmt.Errorf("issue #%d carries no project id", id)
		}
		projectID = strconv.Itoa(fresh.Project.ID)
		return projectID, nil
	}
	if *status != "" {
		if p.StatusID, err = c.StatusIDByName(ctx, *status); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *priority != "" {
		if p.PriorityID, err = c.PriorityIDByName(ctx, *priority); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *category != "" {
		proj, perr := resolveProject()
		if perr != nil {
			return apiErr(stderr, perr)
		}
		if p.CategoryID, err = c.CategoryIDByName(ctx, proj, *category); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *version != "" {
		proj, perr := resolveProject()
		if perr != nil {
			return apiErr(stderr, perr)
		}
		if p.FixedVersionID, err = c.VersionIDByName(ctx, proj, *version); err != nil {
			return apiErr(stderr, err)
		}
	}
	if *due != "" {
		p.DueDate = *due
	}
	if *doneRatio >= 0 {
		p.DoneRatio = *doneRatio
	}
	if *desc != "" {
		text, err := readDesc(*desc)
		if err != nil {
			return usageErr(stderr, "%v", err)
		}
		p.Description = text
	}

	if err := c.UpdateIssue(ctx, id, p); err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		fresh, err := c.GetIssue(ctx, id, false)
		if err != nil {
			return apiErr(stderr, err)
		}
		emitJSON(stdout, map[string]any{"issue": fresh})
		return 0
	}
	fmt.Fprintf(stdout, "updated issue #%d\n", id)
	return 0
}

// readDesc loads a description from a file, or from stdin when path is "-".
func readDesc(path string) (string, error) {
	if path == "-" {
		b, err := io.ReadAll(os.Stdin)
		if err != nil {
			return "", fmt.Errorf("desc: cannot read stdin: %w", err)
		}
		return string(b), nil
	}
	b, err := os.ReadFile(path)
	if err != nil {
		return "", fmt.Errorf("desc: cannot read %s", path)
	}
	return string(b), nil
}

// --- version ----------------------------------------------------------------

func cmdVersion(args []string, stdout, stderr io.Writer) int {
	if len(args) == 0 {
		return usageErr(stderr, "version: expected list|create (see mred help)")
	}
	sub, rest := args[0], args[1:]
	switch sub {
	case "list":
		return cmdVersionList(rest, stdout, stderr)
	case "create":
		return cmdVersionCreate(rest, stdout, stderr)
	default:
		return usageErr(stderr, "version: unknown subcommand %q", sub)
	}
}

func cmdVersionList(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("version list", stderr)
	project := fs.String("p", "", "project identifier (required)")
	pos, err := parseArgs(fs, args)
	if err != nil || len(pos) != 0 || *project == "" {
		return usageErr(stderr, "version list: usage: mred version list -p PROJECT")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	versions, err := c.ListVersions(context.Background(), *project)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"versions": versions})
		return 0
	}
	for _, v := range versions {
		fmt.Fprintf(stdout, "%-6d %-10s %s %s\n", v.ID, v.Status, v.Name, dueSuffix(v.DueDate))
	}
	return 0
}

func cmdVersionCreate(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("version create", stderr)
	project := fs.String("p", "", "project identifier (required)")
	name := fs.String("n", "", "version name (required)")
	due := fs.String("due", "", "due date YYYY-MM-DD")
	status := fs.String("status", "open", "open|closed")
	pos, err := parseArgs(fs, args)
	if err != nil || len(pos) != 0 || *project == "" || *name == "" {
		return usageErr(stderr, "version create: usage: mred version create -p PROJECT -n NAME [--due DATE] [--status open|closed]")
	}
	if *status != "open" && *status != "closed" && *status != "locked" {
		return usageErr(stderr, "version create: --status must be open|closed|locked")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	v, err := c.CreateVersion(context.Background(), *project, redmine.VersionParams{
		Name: *name, DueDate: *due, Status: *status, Sharing: "descendants",
	})
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"version": v})
		return 0
	}
	fmt.Fprintf(stdout, "created version #%d %s (%s) %s\n", v.ID, v.Name, v.Status, dueSuffix(v.DueDate))
	return 0
}

func dueSuffix(due string) string {
	if due == "" {
		return ""
	}
	return "due " + due
}

// --- category -----------------------------------------------------------------

func cmdCategory(args []string, stdout, stderr io.Writer) int {
	if len(args) == 0 {
		return usageErr(stderr, "category: expected list|create (see mred help)")
	}
	sub, rest := args[0], args[1:]
	switch sub {
	case "list":
		return cmdCategoryList(rest, stdout, stderr)
	case "create":
		return cmdCategoryCreate(rest, stdout, stderr)
	default:
		return usageErr(stderr, "category: unknown subcommand %q", sub)
	}
}

func cmdCategoryList(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("category list", stderr)
	project := fs.String("p", "", "project identifier (required)")
	pos, err := parseArgs(fs, args)
	if err != nil || len(pos) != 0 || *project == "" {
		return usageErr(stderr, "category list: usage: mred category list -p PROJECT")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	cats, err := c.ListCategories(context.Background(), *project)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"issue_categories": cats})
		return 0
	}
	for _, cat := range cats {
		fmt.Fprintf(stdout, "%-6d %s\n", cat.ID, cat.Name)
	}
	return 0
}

func cmdCategoryCreate(args []string, stdout, stderr io.Writer) int {
	fs, cfgPath, out := newFlags("category create", stderr)
	project := fs.String("p", "", "project identifier (required)")
	name := fs.String("n", "", "category name (required)")
	pos, perr := parseArgs(fs, args)
	if perr != nil || len(pos) != 0 || *project == "" || *name == "" {
		return usageErr(stderr, "category create: usage: mred category create -p PROJECT -n NAME")
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	cat, err := c.CreateCategory(context.Background(), *project, *name)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"issue_category": cat})
		return 0
	}
	fmt.Fprintf(stdout, "created category #%d %s\n", cat.ID, cat.Name)
	return 0
}

// --- relation -------------------------------------------------------------------

func cmdRelation(args []string, stdout, stderr io.Writer) int {
	if len(args) == 0 {
		return usageErr(stderr, "relation: expected create (see mred help)")
	}
	if args[0] != "create" {
		return usageErr(stderr, "relation: unknown subcommand %q", args[0])
	}
	fs, cfgPath, out := newFlags("relation create", stderr)
	relType := fs.String("type", "", "blocks|relates (required)")
	pos, err := parseArgs(fs, args[1:])
	if err != nil || len(pos) != 2 || *relType == "" {
		return usageErr(stderr, "relation create: usage: mred relation create FROM TO --type blocks|relates")
	}
	if *relType != "blocks" && *relType != "relates" {
		return usageErr(stderr, "relation create: --type must be blocks|relates")
	}
	from, err := strconv.Atoi(pos[0])
	if err != nil {
		return usageErr(stderr, "relation create: FROM must be numeric, got %q", pos[0])
	}
	to, err := strconv.Atoi(pos[1])
	if err != nil {
		return usageErr(stderr, "relation create: TO must be numeric, got %q", pos[1])
	}
	c, err := client(*cfgPath)
	if err != nil {
		return usageErr(stderr, "%v", err)
	}
	rel, err := c.CreateRelation(context.Background(), from, to, *relType)
	if err != nil {
		return apiErr(stderr, err)
	}
	if *out == "json" {
		emitJSON(stdout, map[string]any{"relation": rel})
		return 0
	}
	fmt.Fprintf(stdout, "created relation #%d: %d %s %d\n", rel.ID, from, rel.RelationType, to)
	return 0
}