package main

import (
	json "encoding/json"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"

	tea "github.com/charmbracelet/bubbletea"
	lipgloss "github.com/charmbracelet/lipgloss"
	// termenv "github.com/muesli/termenv"
	// isatty "github.com/mattn/go-isatty"
)

// Keeps the full data structure and a path that indexes our current position into it.
type model struct {
	path []index
	data val
}

// an index into a value, uint for lists and string for maps.
// nil for any scalar value.
// TODO: use an actual interface for these
type index interface{}

/// recursive value that we can represent.
type val struct {
	// the “type” of value; see tag const belove
	tag tag
	// last known position of our cursor
	last_index index
	// documentation (TODO)
	doc string
	// the actual value;
	// the actual structure is behind a pointer so we can replace the struct.
	// determined by the tag
	// tagString -> *string
	// tagFloat -> *float64
	// tagList -> *[]val
	// tagMap -> *map[string]val
	val interface{}
}

type tag string

const (
	tagString tag = "string"
	tagFloat  tag = "float"
	tagList   tag = "list"
	tagMap    tag = "map"
)

// print a value, flat
func (v val) Render() string {
	s := ""
	switch v.tag {
	case tagString:
		s += *v.val.(*string)
	case tagFloat:
		s += fmt.Sprint(*v.val.(*float64))
	case tagList:
		s += "[ "
		vs := []string{}
		for _, enum := range v.enumerate() {
			vs = append(vs, enum.v.Render())
		}
		s += strings.Join(vs, ", ")
		s += " ]"
	case tagMap:
		s += "{ "
		vs := []string{}
		for _, enum := range v.enumerate() {
			vs = append(vs, fmt.Sprintf("%s: %s", enum.i.(string), enum.v.Render()))
		}
		s += strings.Join(vs, ", ")
		s += " }"
	default:
		s += fmt.Sprintf("<unknown: %v>", v)
	}
	return s
}

// render an index, depending on the type
func renderIndex(i index) (s string) {
	switch i := i.(type) {
	case nil:
		s = ""
	// list index
	case uint:
		s = "*"
	// map index
	case string:
		s = i + ":"
	}
	return
}

// take an arbitrary (within restrictions) go value and construct a val from it
func makeVal(i interface{}) val {
	var v val
	switch i := i.(type) {
	case string:
		v = val{
			tag:        tagString,
			last_index: index(nil),
			doc:        "",
			val:        &i,
		}
	case float64:
		v = val{
			tag:        tagFloat,
			last_index: index(nil),
			doc:        "",
			val:        &i,
		}
	case []interface{}:
		ls := []val{}
		for _, i := range i {
			ls = append(ls, makeVal(i))
		}
		v = val{
			tag:        tagList,
			last_index: pos1Inner(tagList, &ls),
			doc:        "",
			val:        &ls,
		}
	case map[string]interface{}:
		ls := map[string]val{}
		for k, i := range i {
			ls[k] = makeVal(i)
		}
		v = val{
			tag:        tagMap,
			last_index: pos1Inner(tagMap, &ls),
			doc:        "",
			val:        &ls,
		}
	default:
		log.Fatalf("makeVal: cannot read json of type %T", i)
	}
	return v
}

// return an index that points at the first entry in val
func (v val) pos1() index {
	return v.enumerate()[0].i
}

func pos1Inner(tag tag, v interface{}) index {
	return enumerateInner(tag, v)[0].i
}

type enumerate struct {
	i index
	v val
}

// enumerate gives us a stable ordering of elements in this val.
// for scalars it’s just a nil index & the val itself.
// Guaranteed to always return at least one element.
func (v val) enumerate() (e []enumerate) {
	e = enumerateInner(v.tag, v.val)
	if e == nil {
		e = append(e, enumerate{
			i: nil,
			v: v,
		})
	}
	return
}

// like enumerate, but returns an empty slice for scalars without inner vals.
func enumerateInner(tag tag, v interface{}) (e []enumerate) {
	switch tag {
	case tagString:
		fallthrough
	case tagFloat:
		e = nil
	case tagList:
		for i, v := range *v.(*[]val) {
			e = append(e, enumerate{i: index(uint(i)), v: v})
		}
	case tagMap:
		// map sorting order is not stable (actually randomized thank jabber)
		// so let’s sort them
		keys := []string{}
		m := *v.(*map[string]val)
		for k, _ := range m {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			e = append(e, enumerate{i: index(k), v: m[k]})
		}
	default:
		log.Fatalf("unknown val tag %s, %v", tag, v)
	}
	return
}

func (m model) PathString() string {
	s := "/ "
	var is []string
	for _, v := range m.path {
		is = append(is, fmt.Sprintf("%v", v))
	}
	s += strings.Join(is, " / ")
	return s
}

// walk the given path down in data, to get the value at that point.
// Assumes that all path indexes are valid indexes into data.
// Returns a pointer to the value at point, in order to be able to change it.
func walk(data *val, path []index) (*val, bool, error) {
	res := data
	atPath := func(index int) string {
		return fmt.Sprintf("at path %v", path[:index+1])
	}
	errf := func(ty string, val interface{}, index int) error {
		return fmt.Errorf("walk: can’t walk into %s %v %s", ty, val, atPath(index))
	}
	for i, p := range path {
		switch res.tag {
		case tagString:
			return nil, true, nil
		case tagFloat:
			return nil, true, nil
		case tagList:
			switch p := p.(type) {
			case uint:
				list := *res.val.(*[]val)
				if int(p) >= len(list) || p < 0 {
					return nil, false, fmt.Errorf("index out of bounds %s", atPath(i))
				}
				res = &list[p]
			default:
				return nil, false, fmt.Errorf("not a list index %s", atPath(i))
			}
		case tagMap:
			switch p := p.(type) {
			case string:
				m := *res.val.(*map[string]val)
				if a, ok := m[p]; ok {
					res = &a
				} else {
					return nil, false, fmt.Errorf("index %s not in map %s", p, atPath(i))
				}
			default:
				return nil, false, fmt.Errorf("not a map index %v %s", p, atPath(i))
			}

		default:
			return nil, false, errf(string(res.tag), res.val, i)
		}
	}
	return res, false, nil
}

// descend into the selected index. Assumes that the index is valid.
// Will not descend into scalars.
func (m model) descend() (model, error) {
	// TODO: two walks?!
	this, _, err := walk(&m.data, m.path)
	if err != nil {
		return m, err
	}
	newPath := append(m.path, this.last_index)
	_, bounce, err := walk(&m.data, newPath)
	if err != nil {
		return m, err
	}
	// only descend if we *can*
	if !bounce {
		m.path = newPath
	}
	return m, nil
}

// ascend to one level up. stops at the root.
func (m model) ascend() (model, error) {
	if len(m.path) > 0 {
		m.path = m.path[:len(m.path)-1]
		_, _, err := walk(&m.data, m.path)
		return m, err
	}
	return m, nil
}

/// go to the next item, or wraparound
func (min model) next() (m model, err error) {
	m = min
	this, _, err := walk(&m.data, m.path)
	if err != nil {
		return
	}
	enumL := this.enumerate()
	setNext := false
	for _, enum := range enumL {
		if setNext {
			this.last_index = enum.i
			setNext = false
			break
		}
		if enum.i == this.last_index {
			setNext = true
		}
	}
	// wraparound
	if setNext {
		this.last_index = enumL[0].i
	}
	return
}

/// go to the previous item, or wraparound
func (min model) prev() (m model, err error) {
	m = min
	this, _, err := walk(&m.data, m.path)
	if err != nil {
		return
	}
	enumL := this.enumerate()
	// last element, wraparound
	prevIndex := enumL[len(enumL)-1].i
	for _, enum := range enumL {
		if enum.i == this.last_index {
			this.last_index = prevIndex
			break
		}
		prevIndex = enum.i
	}
	return
}

/// bubbletea implementations

func (m model) Init() tea.Cmd {
	return nil
}

func initialModel(v interface{}) model {
	val := makeVal(v)
	return model{
		path: []index{},
		data: val,
	}
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var err error
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "q":
			return m, tea.Quit

		case "up":
			m, err = m.prev()

		case "down":
			m, err = m.next()

		case "right":
			m, err = m.descend()

		case "left":
			m, err = m.ascend()

			// 	case "enter":
			// 		_, ok := m.selected[m.cursor]
			// 		if ok {
			// 			delete(m.selected, m.cursor)
			// 		} else {
			// 			m.selected[m.cursor] = struct{}{}
			// 		}
		}

	}
	if err != nil {
		log.Fatal(err)
	}
	return m, nil
}

var pathColor = lipgloss.NewStyle().
	// light blue
	Foreground(lipgloss.Color("12"))

var selectedColor = lipgloss.NewStyle().
	Bold(true)

func (m model) View() string {
	s := pathColor.Render(m.PathString())
	cur, _, err := walk(&m.data, m.path)
	if err != nil {
		log.Fatal(err)
	}
	s += cur.doc + "\n"
	s += "\n"
	for _, enum := range cur.enumerate() {
		is := renderIndex(enum.i)
		if is != "" {
			s += is + " "
		}
		if enum.i == cur.last_index {
			s += selectedColor.Render(enum.v.Render())
		} else {
			s += enum.v.Render()
		}
		s += "\n"
	}

	// s += fmt.Sprintf("%v\n", m)
	// s += fmt.Sprintf("%v\n", cur)

	return s
}

func main() {
	var input interface{}
	err := json.NewDecoder(os.Stdin).Decode(&input)
	if err != nil {
		log.Fatal("json from stdin: ", err)
	}
	p := tea.NewProgram(initialModel(input))
	if err := p.Start(); err != nil {
		log.Fatal("bubbletea TUI error: ", err)
	}
}