package cli

import (
	"fmt"
	"os"
	"strings"

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

	"github.com/hachem-wtf/benson/internal/config"
	"github.com/hachem-wtf/benson/internal/setup"
)

type command struct {
	name string
	desc string
	run  func(m *model) tea.Cmd
}

type outputMsg struct {
	text string
}

type model struct {
	cfg     *config.Config
	version string

	input textinput.Model
	spin  spinner.Model

	commands []command
	args     []string
	busy     bool
	quitting bool
	events   chan tea.Msg

	form          *huh.Form
	pickerStage   int
	pickerAction  string
	pickerQuery   string
	pickerSlug    string
	pickerVersion string

	width, height int
}

func Run(version string) error {
	cfg, err := config.Load()
	if err != nil {
		if !os.IsNotExist(err) {
			return fmt.Errorf("failed to load %s: %w", config.Path(), err)
		}

		fmt.Println("No configuration found — let's set one up.")
		if err := setup.Run(); err != nil {
			return err
		}

		cfg, err = config.Load()
		if err != nil {
			return fmt.Errorf("setup did not complete — run `benson setup` to configure")
		}
	}

	_, err = tea.NewProgram(newModel(cfg, version)).Run()
	return err
}

func newModel(cfg *config.Config, version string) *model {
	ti := textinput.New()
	ti.Placeholder = "type a command… (try 'help')"
	ti.Prompt = ""
	ti.CharLimit = 128
	ti.Focus()

	sp := spinner.New()
	sp.Spinner = spinner.Dot
	sp.Style = lipgloss.NewStyle().Foreground(colPrimary)

	m := &model{
		cfg:     cfg,
		version: version,
		input:   ti,
		spin:    sp,
	}
	m.commands = defaultCommands()
	return m
}

func (m *model) Init() tea.Cmd {
	return tea.Batch(textinput.Blink, tea.Println(welcomeBlock(m.cfg, m.version)))
}

func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	if m.form != nil {
		return m.updatePicker(msg)
	}

	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width, m.height = msg.Width, msg.Height
		m.input.Width = max(msg.Width-12, 20)
		return m, nil

	case tea.KeyMsg:
		switch msg.Type {
		case tea.KeyCtrlC, tea.KeyCtrlD:
			m.quitting = true
			return m, tea.Quit
		case tea.KeyTab:
			if s := m.firstSuggestion(); s != "" {
				m.input.SetValue(s)
				m.input.CursorEnd()
			}
			return m, nil
		case tea.KeyEnter:
			if m.busy {
				return m, nil
			}
			return m, m.submit()
		}

	case outputMsg:
		m.busy = false
		return m, tea.Println(msg.text)

	case modManagerMsg:
		m.busy = false
		return m, m.handleModManager(msg)

	case streamMsg:
		return m, tea.Sequence(tea.Println(msg.text), waitForEvent(m.events))

	case streamDoneMsg:
		m.busy = false
		m.events = nil
		if msg.text == "" {
			return m, nil
		}
		return m, tea.Println(msg.text)

	case spinner.TickMsg:
		if !m.busy {
			return m, nil
		}
		var cmd tea.Cmd
		m.spin, cmd = m.spin.Update(msg)
		return m, cmd
	}

	var cmd tea.Cmd
	m.input, cmd = m.input.Update(msg)
	return m, cmd
}

func (m *model) View() string {
	if m.quitting {
		return ""
	}
	if m.form != nil {
		return "\n" + m.form.View() + "\n"
	}
	return "\n" + m.suggestionRow() + "\n" + m.promptLine() + "\n"
}

func (m *model) submit() tea.Cmd {
	raw := strings.TrimSpace(m.input.Value())
	m.input.Reset()
	if raw == "" {
		return nil
	}

	echo := tea.Println(promptStyle.Render("benson ❯ ") + raw)

	fields := strings.Fields(strings.ToLower(raw))
	name := fields[0]
	m.args = fields[1:]
	if name == "?" {
		name = "help"
	}

	if isExit(name) {
		m.quitting = true
		return tea.Sequence(echo, tea.Println(mutedStyle.Render("Goodbye!")), tea.Quit)
	}

	if c := m.find(name); c != nil {
		return tea.Sequence(echo, c.run(m))
	}

	unknown := tea.Println(errorStyle.Render("Unknown command: "+name) + mutedStyle.Render("  ·  type 'help'"))
	return tea.Sequence(echo, unknown)
}

func (m *model) find(name string) *command {
	for i := range m.commands {
		if m.commands[i].name == name {
			return &m.commands[i]
		}
	}
	return nil
}

func isExit(name string) bool {
	switch name {
	case "exit", "quit", "q":
		return true
	}
	return false
}

func (m *model) promptLine() string {
	if m.busy {
		return "  " + m.spin.View() + " " + mutedStyle.Render("working…")
	}
	return promptStyle.Render("  benson ❯ ") + m.input.View()
}

func (m *model) suggestionRow() string {
	cur := strings.ToLower(strings.TrimSpace(m.input.Value()))

	chips := make([]string, 0, len(m.commands)+1)
	for _, c := range m.commands {
		if cur != "" && strings.HasPrefix(c.name, cur) {
			chips = append(chips, chipActiveStyle.Render(c.name))
		} else {
			chips = append(chips, chipStyle.Render(c.name))
		}
	}
	chips = append(chips, chipStyle.Render("exit"))

	return "  " + lipgloss.JoinHorizontal(lipgloss.Left, chips...)
}

func (m *model) firstSuggestion() string {
	cur := strings.ToLower(strings.TrimSpace(m.input.Value()))
	if cur == "" {
		return ""
	}
	for _, c := range m.commands {
		if c.name != cur && strings.HasPrefix(c.name, cur) {
			return c.name
		}
	}
	return ""
}