package server

import (
	"strconv"
	"strings"
)

// LogSpan is een stuk tekst met ANSI-classes. Class is leeg voor gewone tekst.
type LogSpan struct {
	Class string
	Text  string
}

type ansiState struct {
	bold      bool
	dim       bool
	italic    bool
	underline bool
	fg        string
	bg        string
}

func (st ansiState) class() string {
	var parts []string
	if st.bold {
		parts = append(parts, "ansi-bold")
	}
	if st.dim {
		parts = append(parts, "ansi-dim")
	}
	if st.italic {
		parts = append(parts, "ansi-italic")
	}
	if st.underline {
		parts = append(parts, "ansi-underline")
	}
	if st.fg != "" {
		parts = append(parts, "ansi-fg-"+st.fg)
	}
	if st.bg != "" {
		parts = append(parts, "ansi-bg-"+st.bg)
	}
	return strings.Join(parts, " ")
}

func ansiSpans(s string) []LogSpan {
	var spans []LogSpan
	var b strings.Builder
	var st ansiState
	flush := func() {
		if b.Len() == 0 {
			return
		}
		spans = append(spans, LogSpan{Class: st.class(), Text: b.String()})
		b.Reset()
	}
	for i := 0; i < len(s); i++ {
		if s[i] != 0x1b || i+1 >= len(s) {
			b.WriteByte(s[i])
			continue
		}
		if s[i+1] == '[' {
			end := i + 2
			for end < len(s) && s[end] >= 0x20 && s[end] <= 0x3f {
				end++
			}
			if end < len(s) && s[end] >= 0x40 && s[end] <= 0x7e {
				flush()
				if s[end] == 'm' {
					st.apply(s[i+2 : end])
				}
				i = end
				continue
			}
		}
		if s[i+1] == ']' {
			end := i + 2
			for end < len(s) && s[end] != 0x07 && !(s[end] == 0x1b && end+1 < len(s) && s[end+1] == '\\') {
				end++
			}
			flush()
			if end < len(s) && s[end] == 0x07 {
				i = end
				continue
			}
			if end+1 < len(s) && s[end] == 0x1b {
				i = end + 1
				continue
			}
		}
		b.WriteByte(s[i])
	}
	flush()
	if len(spans) == 0 {
		return []LogSpan{{Text: s}}
	}
	return spans
}

func (st *ansiState) apply(params string) {
	if params == "" {
		*st = ansiState{}
		return
	}
	parts := strings.Split(params, ";")
	nums := make([]int, len(parts))
	for i, part := range parts {
		n, _ := strconv.Atoi(strings.TrimSpace(part))
		nums[i] = n
	}
	for i := 0; i < len(nums); i++ {
		n := nums[i]
		switch {
		case n == 0:
			*st = ansiState{}
		case n == 1:
			st.bold = true
			st.dim = false
		case n == 2:
			st.dim = true
		case n == 3:
			st.italic = true
		case n == 4:
			st.underline = true
		case n == 22:
			st.bold = false
			st.dim = false
		case n == 23:
			st.italic = false
		case n == 24:
			st.underline = false
		case n >= 30 && n <= 37:
			st.fg = ansiColor(n - 30)
		case n == 39:
			st.fg = ""
		case n >= 40 && n <= 47:
			st.bg = ansiColor(n - 40)
		case n == 49:
			st.bg = ""
		case n >= 90 && n <= 97:
			st.fg = "bright-" + ansiColor(n-90)
		case n >= 100 && n <= 107:
			st.bg = "bright-" + ansiColor(n-100)
		case n == 38 || n == 48:
			name, ok, skip := ansiExtended(nums[i+1:])
			i += skip
			if !ok {
				continue
			}
			if n == 38 {
				st.fg = name
			} else {
				st.bg = name
			}
		}
	}
}

func ansiExtended(rest []int) (string, bool, int) {
	if len(rest) >= 2 && rest[0] == 5 {
		if rest[1] >= 0 && rest[1] <= 7 {
			return ansiColor(rest[1]), true, 2
		}
		if rest[1] >= 8 && rest[1] <= 15 {
			return "bright-" + ansiColor(rest[1]-8), true, 2
		}
		return "", false, 2
	}
	if len(rest) >= 4 && rest[0] == 2 {
		return "", false, 4
	}
	return "", false, 0
}

func ansiColor(n int) string {
	names := []string{"black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"}
	if n < 0 || n >= len(names) {
		return ""
	}
	return names[n]
}
