package commands

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/url"

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

// proposeResponse matches the backend ProposeResponse schema.
type proposeResponse struct {
	ID          int     `json:"id"`
	Code        string  `json:"code"`
	Title       string  `json:"title"`
	Description *string `json:"description"`
	Status      string  `json:"status"`
	ProjectCode string  `json:"project_code"`
	CreatedBy   *string `json:"created_by"`
	CreatedAt   string  `json:"created_at"`
}

type projectLookup struct {
	ID          int    `json:"id"`
	ProjectCode string `json:"project_code"`
}

func resolveProposalProject(c *client.Client, proposalCode string) string {
	data, err := c.Get("/projects")
	if err != nil {
		return ""
	}
	var projects []projectLookup
	if err := json.Unmarshal(data, &projects); err != nil {
		return ""
	}
	for _, p := range projects {
		if p.ProjectCode == "" {
			continue
		}
		if _, err := c.Get("/projects/" + p.ProjectCode + "/proposals/" + proposalCode); err == nil {
			return p.ProjectCode
		}
	}
	return ""
}

func proposalPath(c *client.Client, proposalCode string) string {
	if project := resolveProposalProject(c, proposalCode); project != "" {
		return "/projects/" + project + "/proposals/" + proposalCode
	}
	return "/proposes/" + proposalCode
}

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

	project := ""
	query := url.Values{}
	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.Set("status", args[i])
		case "--order-by":
			if i+1 >= len(args) {
				output.Error("--order-by requires a value")
			}
			i++
			query.Set("order_by", args[i])
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}
	legacyPath := false
	if project == "" {
		legacyPath = true
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	path := "/projects/" + project + "/proposals"
	if legacyPath {
		path = "/proposes"
	}
	if encoded := query.Encode(); encoded != "" {
		path += "?" + encoded
	}
	data, err := c.Get(path)
	if err != nil {
		output.Errorf("failed to list proposals: %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 proposes []proposeResponse
	if err := json.Unmarshal(data, &proposes); err != nil {
		output.Errorf("cannot parse proposal list: %v", err)
	}

	headers := []string{"CODE", "TITLE", "STATUS", "PROJECT", "CREATED BY"}
	var rows [][]string
	for _, p := range proposes {
		createdBy := ""
		if p.CreatedBy != nil {
			createdBy = *p.CreatedBy
		}
		title := p.Title
		if len(title) > 40 {
			title = title[:37] + "..."
		}
		rows = append(rows, []string{p.Code, title, p.Status, p.ProjectCode, createdBy})
	}
	output.PrintTable(headers, rows)
}

// RunProposeGet implements `hf propose get <propose-code>`.
func RunProposeGet(proposeCode, 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(proposalPath(c, proposeCode))
	if err != nil {
		output.Errorf("failed to get proposal: %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 proposeResponse
	if err := json.Unmarshal(data, &p); err != nil {
		output.Errorf("cannot parse proposal: %v", err)
	}

	desc := ""
	if p.Description != nil {
		desc = *p.Description
	}
	createdBy := ""
	if p.CreatedBy != nil {
		createdBy = *p.CreatedBy
	}
	output.PrintKeyValue(
		"code", p.Code,
		"title", p.Title,
		"description", desc,
		"status", p.Status,
		"project", p.ProjectCode,
		"created-by", createdBy,
		"created", p.CreatedAt,
	)
}

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

	project, title, desc := "", "", ""
	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]
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

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

	payload := map[string]interface{}{
		"title":       title,
		"description": desc,
	}

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

// RunProposeUpdate implements `hf propose update <propose-code>`.
func RunProposeUpdate(proposeCode 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]
		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(proposalPath(c, proposeCode), bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to update proposal: %v", err)
	}

	fmt.Printf("proposal updated: %s\n", proposeCode)
}

// acceptResponse holds the accept result including generated tasks.
type acceptResponse struct {
	ProposalCode   string          `json:"proposal_code"`
	Status         string          `json:"status"`
	GeneratedTasks []generatedTask `json:"generated_tasks"`
}

type generatedTask struct {
	TaskID      int     `json:"task_id"`
	TaskCode    *string `json:"task_code"`
	Title       string  `json:"title"`
	TaskType    string  `json:"task_type"`
	TaskSubtype *string `json:"task_subtype"`
}

// RunProposeAccept implements `hf proposal accept <proposal-code> --milestone <milestone-code>`.
func RunProposeAccept(proposeCode string, args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

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

	if milestone == "" {
		output.Error("usage: hf proposal accept <proposal-code> --milestone <milestone-code>")
	}

	payload := map[string]interface{}{
		"milestone_code": milestone,
	}
	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(proposalPath(c, proposeCode)+"/accept", bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to accept proposal: %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
	}

	fmt.Printf("proposal accepted: %s\n", proposeCode)

	// Try to parse and display generated tasks
	var resp acceptResponse
	if err := json.Unmarshal(data, &resp); err == nil && len(resp.GeneratedTasks) > 0 {
		fmt.Printf("\nGenerated %d story task(s):\n", len(resp.GeneratedTasks))
		for _, gt := range resp.GeneratedTasks {
			code := "(no task_code)"
			if gt.TaskCode != nil {
				code = *gt.TaskCode
			}
			subtype := ""
			if gt.TaskSubtype != nil {
				subtype = "/" + *gt.TaskSubtype
			}
			fmt.Printf("  %s  %s%s  %s\n", code, gt.TaskType, subtype, gt.Title)
		}
	}
}

// RunProposeReject implements `hf propose reject <propose-code>`.
func RunProposeReject(proposeCode string, args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

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

	var body io.Reader
	if reason != "" {
		payload := map[string]interface{}{
			"reason": reason,
		}
		data, err := json.Marshal(payload)
		if err != nil {
			output.Errorf("cannot marshal payload: %v", err)
		}
		body = bytes.NewReader(data)
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	_, err = c.Post(proposalPath(c, proposeCode)+"/reject", body)
	if err != nil {
		output.Errorf("failed to reject proposal: %v", err)
	}

	fmt.Printf("proposal rejected: %s\n", proposeCode)
}

// RunProposeReopen implements `hf propose reopen <propose-code>`.
func RunProposeReopen(proposeCode, 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(proposalPath(c, proposeCode)+"/reopen", nil)
	if err != nil {
		output.Errorf("failed to reopen proposal: %v", err)
	}

	fmt.Printf("proposal reopened: %s\n", proposeCode)
}