package main

// The Author workspace: write a task.
//
// One panel with five fields, in the order Paperclip needs them: a title, what
// it must do, what must finish first, the command that proves it is done, and
// whether to hand it to an agent. The task is created unassigned and given its
// blocker in a separate call, because a task assigned at creation is claimed by
// an agent's run within seconds and that run then owns the task's fields.

import (
	"fmt"
	"strings"

	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"

	"paperclip-harness/tui/paperclip"
)

type createdMsg struct {
	issue    paperclip.Issue
	blocked  string
	assigned bool
	err      error
}

type newTaskModel struct {
	client *paperclip.Client
	proj   paperclip.Project
	agent  string

	inputs []textinput.Model
	focus  int
	err    error
	busy   bool
	result string

	tab           int
	width, height int
}

var authorTabs = []string{"form", "guidance", "preview"}

const (
	fieldTitle = iota
	fieldBody
	fieldBlocker
	fieldVerify
	fieldAssign
	fieldCount
)

var fieldNames = []string{"Title", "What it must do", "Must finish first", "A command that proves it (optional)", "Assign to an agent"}
var fieldHints = []string{
	"one line, the thing to be done",
	"details the agent needs: files, behaviour, limits",
	"identifier of a task that must finish first, or empty",
	"leave empty and the agent decides how to check its own work",
	"yes, to hand it to the configured agent after the blocker is set",
}

func newTaskForm(c *paperclip.Client, proj paperclip.Project, agentID string) newTaskModel {
	m := newTaskModel{client: c, proj: proj, agent: agentID}
	for range fieldNames {
		ti := textinput.New()
		ti.Placeholder = ""
		ti.CharLimit = 1000
		ti.Prompt = ""
		m.inputs = append(m.inputs, ti)
	}
	m.inputs[fieldTitle].Focus()
	return m
}

func (m newTaskModel) Init() tea.Cmd { return textinput.Blink }

// fieldTitle is index 0; kept as a method so the intent is readable above.
func (m newTaskModel) fieldTitle() int { return fieldTitle }

func (m newTaskModel) submit() tea.Cmd {
	title := strings.TrimSpace(m.inputs[fieldTitle].Value())
	body := strings.TrimSpace(m.inputs[fieldBody].Value())
	blocker := strings.TrimSpace(m.inputs[fieldBlocker].Value())
	verify := strings.TrimSpace(m.inputs[fieldVerify].Value())
	assign := strings.TrimSpace(m.inputs[fieldAssign].Value())

	c, proj, agent := m.client, m.proj, m.agent

	desc := body
	if verify != "" {
		desc += "\n\nDone when this command succeeds:\n\n    " + verify
	}
	if blocker != "" {
		desc += "\n\nMust finish first: " + blocker
	}

	return func() tea.Msg {
		is, err := c.CreateTask(paperclip.NewTask{Title: title, Description: desc, ProjectID: proj.ID})
		if err != nil {
			return createdMsg{err: err}
		}
		if blocker != "" {
			b, err := resolveIssue(c, blocker)
			if err != nil {
				return createdMsg{issue: is, err: fmt.Errorf("created %s, but no task matches %q", is.Identifier, blocker)}
			}
			if _, err := c.SetBlockers(is.ID, []string{b.ID}); err != nil {
				return createdMsg{issue: is, err: fmt.Errorf("created %s, but the blocker was refused: %w", is.Identifier, err)}
			}
		}
		assigned := false
		if strings.EqualFold(assign, "yes") || strings.EqualFold(assign, "y") {
			if _, err := c.Assign(is.ID, agent); err != nil {
				return createdMsg{issue: is, err: fmt.Errorf("created %s, but the assignment was refused: %w", is.Identifier, err)}
			}
			assigned = true
		}
		return createdMsg{issue: is, blocked: blocker, assigned: assigned}
	}
}

func (m newTaskModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width, m.height = msg.Width, msg.Height
		w := max(20, min(70, m.width-12))
		for i := range m.inputs {
			m.inputs[i].Width = w
		}
		return m, nil

	case tea.KeyMsg:
		switch msg.Type {
		case tea.KeyCtrlC:
			return m, tea.Quit
		case tea.KeyCtrlN:
			m.tab = (m.tab + 1) % len(authorTabs)
			return m, nil
		case tea.KeyCtrlP:
			m.tab = (m.tab + len(authorTabs) - 1) % len(authorTabs)
			return m, nil
		case tea.KeyEsc:
			if m.tab != 0 {
				m.tab = 0
				return m, m.inputs[m.focus].Focus()
			}
			return m, tea.Quit
		case tea.KeyTab, tea.KeyDown:
			m.inputs[m.focus].Blur()
			m.focus = (m.focus + 1) % fieldCount
			return m, m.inputs[m.focus].Focus()
		case tea.KeyShiftTab, tea.KeyUp:
			m.inputs[m.focus].Blur()
			m.focus = (m.focus + fieldCount - 1) % fieldCount
			return m, m.inputs[m.focus].Focus()
		case tea.KeyEnter:
			if m.focus < fieldCount-1 {
				m.inputs[m.focus].Blur()
				m.focus++
				return m, m.inputs[m.focus].Focus()
			}
			if strings.TrimSpace(m.inputs[fieldTitle].Value()) == "" {
				m.err = fmt.Errorf("a task needs a title")
				m.focus = fieldTitle
				return m, m.inputs[m.focus].Focus()
			}
			if m.busy {
				return m, nil
			}
			m.busy = true
			m.err = nil
			return m, m.submit()
		}

	case createdMsg:
		m.busy = false
		if msg.err != nil {
			m.err = msg.err
			return m, nil
		}
		// Stay open with a receipt and empty fields. A pane that quits on
		// success leaves nothing behind, which reads like a crash.
		m.result = "created " + msg.issue.Identifier
		if msg.blocked != "" {
			m.result += ", waiting on " + msg.blocked
		}
		if msg.assigned {
			m.result += ", handed to an agent which will start on its own"
		}
		for i := range m.inputs {
			m.inputs[i].SetValue("")
		}
		m.focus = fieldTitle
		m.inputs[m.fieldTitle()].Focus()
		m.tab = 0
		return m, nil
	}

	var cmd tea.Cmd
	m.inputs[m.focus], cmd = m.inputs[m.focus].Update(msg)
	return m, cmd
}

// descriptionPreview shows exactly what the agent will be given: the same
// text that submit() puts in the task's description, built the same way.
func (m newTaskModel) descriptionPreview() string {
	body := strings.TrimSpace(m.inputs[fieldBody].Value())
	verify := strings.TrimSpace(m.inputs[fieldVerify].Value())
	blocker := strings.TrimSpace(m.inputs[fieldBlocker].Value())
	out := body
	if verify != "" {
		out += "\n\nDone when this command succeeds:\n\n    " + verify
	}
	if blocker != "" {
		out += "\n\nMust finish first: " + blocker
	}
	if strings.TrimSpace(out) == "" {
		return "nothing written yet"
	}
	return out
}

func (m newTaskModel) previewLines(width int) []string {
	out := []string{"", dimStyle().Render(" the task's description, exactly as the agent receives it"), ""}
	for _, para := range strings.Split(m.descriptionPreview(), "\n") {
		for _, ln := range wrap(para, max(8, width-2)) {
			out = append(out, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(ln))
		}
		if para == "" {
			out = append(out, "")
		}
	}
	return out
}

// guidanceLines answers the four questions the form asks, with examples rather
// than metaphors. If a line here needs a second reading, it is the wrong line.
func (m newTaskModel) guidanceLines(width int) []string {
	out := []string{"", groupHeading("the five fields", -1, width-2), ""}
	add := func(field, what, example string) {
		out = append(out, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Accent)).Bold(true).Render(field))
		for _, ln := range wrap(what, max(8, width-4)) {
			out = append(out, "   "+mutedStyle2().Render(ln))
		}
		out = append(out, "   "+dimStyle().Render("example: "+example))
		out = append(out, "")
	}
	add("Title", "One sentence naming the change. It becomes the task title in Paperclip.",
		"Add a CHANGELOG.md with an Unreleased section")
	add("What it must do", "The files to create or change, by path, and the exact behaviour. Mention what must NOT be touched.",
		"Create CHANGELOG.md at the repository root. One section titled Unreleased with three bullets. Change no other file. Commit it.")
	add("Must finish first", "The identifier of another task, for example AUD-171. Paperclip then records a real blocker edge and will not let this task run before that one is done. Leave it empty when nothing must come first.",
		"AUD-171")
	add("A command that proves it", "Optional. Most tasks need nothing here: the agent does the work, runs the project's own tests, and says what it did. Fill this in only when you want a hard gate that no agent can talk its way past.",
		"make test      or      go test ./...")
	add("Assign to", "yes, or empty. yes hands the task to the configured agent as soon as it is created; empty leaves it for a person to assign on the board.",
		"yes")

	out = append(out, groupHeading("what these words mean", -1, width-2), "")
	for _, pair := range [][2]string{
		{"blocker", "Another task that must reach done before this one may start. It is a link between two tasks in Paperclip, not a sentence."},
		{"verify command", "The command that decides the task is finished. Run in the task's worktree; exit 0 means finished."},
		{"assign", "Giving the task to one agent. That is what wakes the agent and makes it start work."},
		{"worktree", "The task's own copy of the repository, made by Paperclip. Two tasks cannot overwrite each other because of it."},
	} {
		out = append(out, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(pair[0]))
		for _, ln := range wrap(pair[1], max(8, width-4)) {
			out = append(out, "   "+mutedStyle2().Render(ln))
		}
		out = append(out, "")
	}
	return out
}

func (m newTaskModel) View() string {
	if m.width == 0 || m.height == 0 {
		return "reading…"
	}
	if m.width < 80 || m.height < 24 {
		return lipgloss.NewStyle().Width(m.width).Height(m.height).Render(
			fmt.Sprintf("This workspace needs 80 × 24.\nThis panel is %d × %d.", m.width, m.height))
	}

	head := titleStyle.Render("Author") + mutedStyle2().Render("  ·  new task in "+m.proj.Name)
	bodyHeight := m.height - 2

	formLines := m.formLines(m.width - 4)
	footer := hintLine([]string{
		keyHint("tab", "field"),
		keyHint("enter", "next/create"),
		keyHint("ctrl+n", "tab"),
		keyHint("esc", "cancel"),
	}, m.width)

	// Wide screens: the form on the left, what to write and what will be sent on
	// the right. Narrow ones: one panel, switched with the tabs.
	if m.width >= 120 {
		formW := max(50, m.width*58/100)
		sideW := m.width - formW - 1
		topH := bodyHeight / 2
		bottomH := bodyHeight - topH

		form := panel{title: "new task", width: formW, height: bodyHeight, focused: true}
		guide := panel{title: "what a task needs", width: sideW, height: topH}
		prev := panel{title: "what will be sent", width: sideW, height: bottomH}
		page := lipgloss.JoinHorizontal(lipgloss.Top,
			form.render(formLines), " ",
			lipgloss.JoinVertical(lipgloss.Left,
				guide.render(m.guidanceLines(sideW-3)),
				prev.render(m.previewLines(sideW-3))))
		return strings.Join([]string{head, page, footer}, "\n")
	}

	p := panel{title: "new task", width: m.width, height: bodyHeight, tabs: authorTabs, active: m.tab, focused: true}
	lines := formLines
	switch m.tab {
	case 1:
		lines = m.guidanceLines(m.width - 3)
	case 2:
		lines = m.previewLines(m.width - 3)
	}
	return strings.Join([]string{head, p.render(lines), footer}, "\n")
}

func (m newTaskModel) formLines(width int) []string {
	var body []string
	body = append(body, "")
	if m.result != "" {
		body = append(body, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Success)).Bold(true).Render(m.result))
		body = append(body, "")
	}
	for i, in := range m.inputs {
		label := fieldNames[i]
		if i == fieldTitle {
			label += " (required)"
		}
		if i == m.focus {
			body = append(body, " ▸ "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Accent)).Bold(true).Render(label))
		} else {
			body = append(body, "   "+mutedStyle2().Render(label))
		}
		body = append(body, "   "+in.View())
		if i == m.focus {
			body = append(body, "   "+dimStyle().Render(fieldHints[i]))
		}
		body = append(body, "")
	}
	if m.err != nil {
		body = append(body, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Error)).Render("error: "+m.err.Error()))
	} else if m.busy {
		body = append(body, " "+mutedStyle2().Render("writing to Paperclip…"))
	}
	return body
}