package cli

import (
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strings"

	tea "charm.land/bubbletea/v2"

	"reasonix/internal/i18n"
	"reasonix/internal/skill"
)

var scopePriority = map[skill.Scope]int{
	skill.ScopeProject: 0,
	skill.ScopeCustom:  1,
	skill.ScopeGlobal:  2,
	skill.ScopeBuiltin: 3,
}

type skillPickerMode string

const (
	pickerSkills        skillPickerMode = "skills"
	pickerSources       skillPickerMode = "sources"
	pickerSourceSkills  skillPickerMode = "source-skills"
	pickerDetail        skillPickerMode = "detail"
	pickerConfirmDelete skillPickerMode = "confirm-delete"
)

type skillPicker struct {
	mode            skillPickerMode
	skills          []skill.Skill
	roots           []skillRootLine
	enabled         map[string]bool
	originalEnabled map[string]bool
	query           string
	sel             int
	sourceSel       int
	sourceSkillSel  int
	showDiagnostics bool
	searchActive    bool
	detailSkill     skill.Skill
	detailBack      skillPickerMode
	detailAction    int
	confirm         int
	deleteSkill     skill.Skill
}

type skillRootLine struct {
	dir        string
	scope      skill.Scope
	status     skill.PathStatus
	skills     int
	configured bool
	diagnostic bool
}

func (m *chatTUI) openSkillPicker() {
	st := m.skillStore()
	skills := st.List()
	if m.ctrl != nil {
		skills = m.ctrl.AllSkills()
	}
	if len(skills) == 0 {
		m.notice(i18n.M.ListSkillsNone)
		return
	}
	sorted := sortedSkills(skills)
	enabled := map[string]bool{}
	original := map[string]bool{}
	disabled := m.disabledSkillNames()
	for _, sk := range sorted {
		on := !disabled[sk.Name]
		enabled[sk.Name] = on
		original[sk.Name] = on
	}
	m.skillPick = &skillPicker{
		mode:            pickerSkills,
		skills:          sorted,
		roots:           skillRootLines(st, sorted),
		enabled:         enabled,
		originalEnabled: original,
	}
}

func (m chatTUI) handleSkillPickerKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	if p == nil {
		return m, nil
	}

	if p.searchActive {
		switch msg.String() {
		case "esc":
			p.searchActive = false
			return m, nil
		case "enter":
			return m.saveSkillPick()
		case "backspace":
			if len(p.query) > 0 {
				p.query = p.query[:len(p.query)-1]
				p.sel = clampSel(p.sel, p.filteredSkills())
			}
			return m, nil
		case "up", "k":
			if p.sel > 0 {
				p.sel--
			}
			return m, nil
		case "down", "j":
			filtered := p.filteredSkills()
			if p.sel < len(filtered)-1 {
				p.sel++
			}
			return m, nil
		default:
			if t := msg.Text; t != "" {
				p.query += t
			} else if s := msg.String(); len(s) == 1 && s[0] >= 32 && s[0] < 127 {
				p.query += s
			}
			p.sel = clampSel(p.sel, p.filteredSkills())
			return m, nil
		}
	}

	switch p.mode {
	case pickerSkills:
		return m.handleSkillPickerSkillsKey(msg)
	case pickerSources:
		return m.handleSkillPickerSourcesKey(msg)
	case pickerSourceSkills:
		return m.handleSkillPickerSourceSkillsKey(msg)
	case pickerDetail:
		return m.handleSkillPickerDetailKey(msg)
	case pickerConfirmDelete:
		return m.handleSkillPickerConfirmDeleteKey(msg)
	}
	return m, nil
}

func (m chatTUI) handleSkillPickerSkillsKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	switch msg.String() {
	case "esc":
		m.skillPick = nil
	case "up", "k":
		if p.sel > 0 {
			p.sel--
		}
	case "down", "j":
		if p.sel < len(p.skills)-1 {
			p.sel++
		}
	case "enter":
		return m.saveSkillPick()
	case " ", "space":
		p.toggleSelectedSkill()
	case "right", "l":
		if sk, ok := p.selectedSkill(); ok {
			p.openDetail(sk, pickerSkills)
		}
	case "/":
		p.searchActive = true
		p.query = ""
	case "s":
		p.mode = pickerSources
		p.searchActive = false
		p.sourceSel = 0
	case "r":
		m.rescanSkills()
	}
	return m, nil
}

func (m chatTUI) handleSkillPickerSourcesKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	visible := p.visibleRoots()
	switch msg.String() {
	case "esc":
		m.skillPick = nil
	case "up", "k":
		if p.sourceSel > 0 {
			p.sourceSel--
		}
	case "down", "j":
		if p.sourceSel < len(visible)-1 {
			p.sourceSel++
		}
	case "enter", "right", "l":
		if len(visible) > 0 {
			p.mode = pickerSourceSkills
			p.sourceSkillSel = 0
		}
	case "d":
		p.showDiagnostics = !p.showDiagnostics
		p.sourceSel = clampSel(p.sourceSel, visible)
	case "s":
		p.mode = pickerSkills
		p.sourceSel = 0
		p.showDiagnostics = false
	case "r":
		m.rescanSkills()
	}
	return m, nil
}

func (m chatTUI) handleSkillPickerSourceSkillsKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	skills := p.selectedRootSkills()
	switch msg.String() {
	case "esc", "left", "h":
		p.mode = pickerSources
	case "up", "k":
		if p.sourceSkillSel > 0 {
			p.sourceSkillSel--
		}
	case "down", "j":
		if p.sourceSkillSel < len(skills)-1 {
			p.sourceSkillSel++
		}
	case "enter", "right", "l":
		if p.sourceSkillSel >= 0 && p.sourceSkillSel < len(skills) {
			p.openDetail(skills[p.sourceSkillSel], pickerSourceSkills)
		}
	case " ", "space":
		if p.sourceSkillSel >= 0 && p.sourceSkillSel < len(skills) {
			p.toggleSkill(skills[p.sourceSkillSel].Name)
		}
	}
	p.sourceSkillSel = clampSel(p.sourceSkillSel, skills)
	return m, nil
}

func (m chatTUI) handleSkillPickerDetailKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	actions := skillActionsFor(p.detailSkill)
	p.detailAction = clampInt(p.detailAction, len(actions))
	switch msg.String() {
	case "esc", "left", "h":
		p.mode = p.detailBack
		p.detailAction = 0
	case "up", "k":
		if p.detailAction > 0 {
			p.detailAction--
		}
	case "down", "j":
		if p.detailAction < len(actions)-1 {
			p.detailAction++
		}
	case "enter":
		if len(actions) > 0 {
			return m.applySkillAction(p.detailSkill, actions[p.detailAction])
		}
	case " ", "space":
		p.toggleSkill(p.detailSkill.Name)
	}
	p.detailAction = clampInt(p.detailAction, len(actions))
	return m, nil
}

func (m chatTUI) handleSkillPickerConfirmDeleteKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	p := m.skillPick
	switch msg.String() {
	case "up", "k", "down", "j":
		if p.confirm == 0 {
			p.confirm = 1
		} else {
			p.confirm = 0
		}
	case "y":
		p.confirm = 0
		return m.deleteSkillPick(p.deleteSkill)
	case "n", "esc":
		p.mode = pickerDetail
	case "enter":
		if p.confirm == 0 {
			return m.deleteSkillPick(p.deleteSkill)
		}
		p.mode = pickerDetail
	}
	return m, nil
}

func (m chatTUI) saveSkillPick() (tea.Model, tea.Cmd) {
	p := m.skillPick
	if p == nil {
		return m, nil
	}
	changes := p.changedEnabled()
	m.skillPick = nil
	if len(changes) == 0 {
		m.notice(i18n.M.SkillPickerNoChanges)
		return m, nil
	}
	m.skillSaveEnabledChanges(changes)
	if m.pendingModelSwitch != nil {
		return m, m.pendingModelSwitch
	}
	return m, nil
}

func (m chatTUI) deleteSkillPick(sk skill.Skill) (tea.Model, tea.Cmd) {
	p := m.skillPick
	target, ok, err := skillDeleteTarget(sk)
	if err != nil {
		m.notice("skill delete: " + err.Error())
		if p != nil {
			p.mode = pickerDetail
		}
		return m, nil
	}
	if !ok {
		m.notice("skill delete: built-in skills cannot be removed")
		if p != nil {
			p.mode = pickerDetail
		}
		return m, nil
	}
	if err := os.RemoveAll(target); err != nil {
		m.notice("skill delete: " + err.Error())
		if p != nil {
			p.mode = pickerDetail
		}
		return m, nil
	}
	if p != nil {
		delete(p.enabled, sk.Name)
		delete(p.originalEnabled, sk.Name)
		p.mode = pickerSkills
		p.detailAction = 0
	}
	m.notice(fmt.Sprintf(i18n.M.SkillPickerDeletedFmt, sk.Name))
	m.refreshSkillPickerData()
	m.scheduleSkillSessionRefresh("skill delete", "deleted skill "+sk.Name+" — refreshing session")
	return m, m.pendingModelSwitch
}

func (m *chatTUI) rescanSkills() {
	m.refreshSkillPickerData()
	m.notice(i18n.M.SkillPickerRescanned)
}

func (m *chatTUI) refreshSkillPickerData() {
	st := m.skillStore()
	skills := st.List()
	m.skills = skills
	m.invalidateSlashCatalog()
	if m.skillPick != nil {
		sorted := sortedSkills(skills)
		m.skillPick.skills = sorted
		m.skillPick.roots = skillRootLines(st, sorted)
		m.skillPick.syncEnabledMaps(sorted, m.disabledSkillNames())
		if m.skillPick.searchActive && m.skillPick.query != "" {
			m.skillPick.sel = clampSel(m.skillPick.sel, m.skillPick.filteredSkills())
		} else {
			m.skillPick.sel = clampSel(m.skillPick.sel, sorted)
		}
		m.skillPick.sourceSel = clampSel(m.skillPick.sourceSel, m.skillPick.visibleRoots())
		m.skillPick.sourceSkillSel = clampSel(m.skillPick.sourceSkillSel, m.skillPick.selectedRootSkills())
	}
}

func (p *skillPicker) filteredSkills() []skill.Skill {
	if p.query == "" {
		return p.skills
	}
	q := strings.ToLower(p.query)
	var out []skill.Skill
	for _, s := range p.skills {
		if strings.Contains(strings.ToLower(s.SlashName()), q) ||
			strings.Contains(strings.ToLower(s.Plugin), q) ||
			strings.Contains(strings.ToLower(s.Description), q) {
			out = append(out, s)
		}
	}
	return out
}

func (p *skillPicker) visibleRoots() []skillRootLine {
	if p.showDiagnostics {
		return p.roots
	}
	var out []skillRootLine
	for _, r := range p.roots {
		if !r.diagnostic || r.configured || r.skills > 0 {
			out = append(out, r)
		}
	}
	return out
}

func (p *skillPicker) selectedSkill() (skill.Skill, bool) {
	if p == nil {
		return skill.Skill{}, false
	}
	skills := p.skills
	if p.searchActive && p.query != "" {
		skills = p.filteredSkills()
	}
	if len(skills) == 0 {
		return skill.Skill{}, false
	}
	p.sel = clampSel(p.sel, skills)
	return skills[p.sel], true
}

func (p *skillPicker) toggleSelectedSkill() {
	if sk, ok := p.selectedSkill(); ok {
		p.toggleSkill(sk.Name)
	}
}

func (p *skillPicker) openDetail(sk skill.Skill, back skillPickerMode) {
	p.detailSkill = sk
	p.detailBack = back
	p.detailAction = 0
	p.mode = pickerDetail
}

func (p *skillPicker) skillEnabled(name string) bool {
	if p == nil || p.enabled == nil {
		return true
	}
	if enabled, ok := p.enabled[name]; ok {
		return enabled
	}
	return true
}

func (p *skillPicker) toggleSkill(name string) {
	if p.enabled == nil {
		p.enabled = map[string]bool{}
	}
	if p.originalEnabled == nil {
		p.originalEnabled = map[string]bool{}
	}
	if _, ok := p.originalEnabled[name]; !ok {
		p.originalEnabled[name] = p.skillEnabled(name)
	}
	p.enabled[name] = !p.skillEnabled(name)
}

func (p *skillPicker) changedEnabled() map[string]bool {
	changes := map[string]bool{}
	if p == nil {
		return changes
	}
	for name, enabled := range p.enabled {
		original, ok := p.originalEnabled[name]
		if !ok {
			original = true
		}
		if enabled != original {
			changes[name] = enabled
		}
	}
	return changes
}

func (p *skillPicker) syncEnabledMaps(skills []skill.Skill, disabled map[string]bool) {
	nextEnabled := map[string]bool{}
	nextOriginal := map[string]bool{}
	for _, sk := range skills {
		enabled := !disabled[sk.Name]
		if p.enabled != nil {
			if existing, ok := p.enabled[sk.Name]; ok {
				enabled = existing
			}
		}
		original := !disabled[sk.Name]
		if p.originalEnabled != nil {
			if existing, ok := p.originalEnabled[sk.Name]; ok {
				original = existing
			}
		}
		nextEnabled[sk.Name] = enabled
		nextOriginal[sk.Name] = original
	}
	p.enabled = nextEnabled
	p.originalEnabled = nextOriginal
}

func (p *skillPicker) selectedRoot() (skillRootLine, bool) {
	if p == nil {
		return skillRootLine{}, false
	}
	roots := p.visibleRoots()
	if len(roots) == 0 {
		return skillRootLine{}, false
	}
	p.sourceSel = clampSel(p.sourceSel, roots)
	return roots[p.sourceSel], true
}

func (p *skillPicker) selectedRootSkills() []skill.Skill {
	root, ok := p.selectedRoot()
	if !ok {
		return nil
	}
	var out []skill.Skill
	for _, sk := range p.skills {
		if skillInRoot(sk, root) {
			out = append(out, sk)
		}
	}
	return out
}

func skillInRoot(sk skill.Skill, root skillRootLine) bool {
	if root.scope == skill.ScopeBuiltin {
		return sk.Scope == skill.ScopeBuiltin
	}
	if sk.Scope != root.scope || sk.Path == "" || sk.Scope == skill.ScopeBuiltin {
		return false
	}
	cleanPath := filepath.Clean(sk.Path)
	cleanRoot := filepath.Clean(root.dir)
	prefix := cleanRoot + string(filepath.Separator)
	return cleanPath == cleanRoot || strings.HasPrefix(cleanPath, prefix)
}

func skillRootLines(st *skill.Store, skills []skill.Skill) []skillRootLine {
	storeRoots := st.Roots()
	lines := make([]skillRootLine, len(storeRoots))
	for i, r := range storeRoots {
		lines[i] = skillRootLine{
			dir:    r.Dir,
			scope:  r.Scope,
			status: r.Status,
		}
	}
	for _, s := range skills {
		if s.Scope == skill.ScopeBuiltin {
			continue
		}
		cleanPath := filepath.Clean(s.Path)
		for i := range lines {
			if lines[i].scope != s.Scope {
				continue
			}
			// Trailing separator: directory-boundary match so /skills can't match /skills-extra.
			prefix := filepath.Clean(lines[i].dir) + string(filepath.Separator)
			if strings.HasPrefix(cleanPath, prefix) {
				lines[i].skills++
				break
			}
		}
	}
	for i := range lines {
		if lines[i].scope == skill.ScopeCustom {
			lines[i].configured = true
		} else {
			lines[i].diagnostic = true
		}
	}
	builtinCount := 0
	for _, s := range skills {
		if s.Scope == skill.ScopeBuiltin {
			builtinCount++
		}
	}
	if builtinCount > 0 {
		lines = append(lines, skillRootLine{
			dir:        i18n.M.SkillPickerBuiltinSource,
			scope:      skill.ScopeBuiltin,
			status:     skill.StatusOK,
			skills:     builtinCount,
			diagnostic: true,
		})
	}
	return lines
}

type skillActionKind string

const (
	skillActionToggle skillActionKind = "toggle"
	skillActionDelete skillActionKind = "delete"
)

type skillActionItem struct {
	kind  skillActionKind
	label string
}

func skillActionsFor(s skill.Skill) []skillActionItem {
	actions := []skillActionItem{{
		kind:  skillActionToggle,
		label: i18n.M.SkillPickerActionToggle,
	}}
	if _, ok, _ := skillDeleteTarget(s); ok {
		actions = append(actions, skillActionItem{
			kind:  skillActionDelete,
			label: i18n.M.SkillPickerActionDelete,
		})
	}
	return actions
}

func (m chatTUI) applySkillAction(sk skill.Skill, action skillActionItem) (tea.Model, tea.Cmd) {
	p := m.skillPick
	if p == nil {
		return m, nil
	}
	switch action.kind {
	case skillActionToggle:
		p.toggleSkill(sk.Name)
	case skillActionDelete:
		p.deleteSkill = sk
		p.confirm = 1
		p.mode = pickerConfirmDelete
	}
	return m, nil
}

func skillDeleteTarget(s skill.Skill) (string, bool, error) {
	if s.Scope == skill.ScopeBuiltin {
		return "", false, nil
	}
	path := strings.TrimSpace(s.Path)
	if path == "" || path == "(builtin)" {
		return "", false, nil
	}
	clean := filepath.Clean(path)
	info, err := os.Stat(clean)
	if err != nil {
		return "", false, err
	}
	if filepath.Base(clean) == skill.SkillFile {
		dir := filepath.Dir(clean)
		if dir == "." || dir == string(filepath.Separator) {
			return "", false, fmt.Errorf("refusing to remove unsafe skill directory %q", dir)
		}
		return dir, true, nil
	}
	if info.Mode().IsRegular() {
		return clean, true, nil
	}
	return "", false, fmt.Errorf("skill path is not removable: %s", clean)
}

func skillDeleteTargetLabel(s skill.Skill) string {
	target, ok, _ := skillDeleteTarget(s)
	if !ok {
		return ""
	}
	return target
}

func sortedSkills(skills []skill.Skill) []skill.Skill {
	sorted := make([]skill.Skill, len(skills))
	copy(sorted, skills)
	sort.SliceStable(sorted, func(i, j int) bool {
		pi := scopePriority[sorted[i].Scope]
		pj := scopePriority[sorted[j].Scope]
		if pi != pj {
			return pi < pj
		}
		return sorted[i].Name < sorted[j].Name
	})
	return sorted
}

func clampSel[T any](sel int, items []T) int {
	if len(items) == 0 {
		return 0
	}
	if sel < 0 {
		return 0
	}
	if sel >= len(items) {
		return len(items) - 1
	}
	return sel
}

func clampInt(sel, total int) int {
	if total <= 0 {
		return 0
	}
	if sel < 0 {
		return 0
	}
	if sel >= total {
		return total - 1
	}
	return sel
}