Piik/internal/app/console.go

package app

import (
	"context"
	"fmt"
	"io"
	"math/rand/v2"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	tea "charm.land/bubbletea/v2"
	"charm.land/lipgloss/v2"
	"github.com/TNTcraftHIM/Piik/internal/app/browser"
	"github.com/charmbracelet/colorprofile"
	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/term"
)

type consoleView struct {
	mode, state, entry, invite string
	protected                  bool
	problem                    string
}

type consoleLanguage string
type consoleFinished struct{ err error }
type consoleTick struct{}
type consoleIdleWink struct{}
type consoleOpenResult struct{ err error }
type consoleDiagnostic string
type consoleDebug struct {
	logPath string
	export  func() (string, error)
}
type consoleExportResult struct {
	path string
	err  error
}

type consoleModel struct {
	view        consoleView
	language    string
	width       int
	height      int
	colors      bool
	frame       int
	tickPending bool
	idlePending bool
	idleWink    bool
	finished    bool
	cancel      context.CancelFunc
	debug       consoleDebug
	exporting   bool
	exportPath  string
	exportError bool
}

type console struct {
	mu       sync.Mutex
	machine  bool
	finished bool
	program  *tea.Program
	done     chan error
	plain    consoleModel
}

var consoleCopy = map[string][3]string{
	"mode":         {"Mode", "模式", ""},
	"local":        {"Local network", "局域网", "□"},
	"link":         {"Public link", "公网链接", "↗"},
	"site":         {"Piik Site", "Piik 站点", "@"},
	"setup":        {"Choose a mode in the browser", "在浏览器中选择模式", "?"},
	"starting":     {"Starting", "正在启动", "…"},
	"ready":        {"Ready", "已就绪", "✓"},
	"stopping":     {"Stopping", "正在退出", "→"},
	"stopped":      {"Stopped", "已停止", "○"},
	"failed":       {"Could not continue", "运行失败", "!"},
	"entry":        {"Open in browser", "打开网页", "□"},
	"invite":       {"Site address", "站点地址", "↗"},
	"access":       {"Site access", "站点准入", ""},
	"open":         {"Open", "开放", "○"},
	"password":     {"Password protected", "已设置密码", "*"},
	"error":        {"Details", "详情", "!"},
	"exit":         {"quit", "退出", "↪"},
	"openFailed":   {"Could not open the browser; use the address above.", "无法打开浏览器，请使用上方地址。", "! ↗"},
	"log":          {"Log", "日志", ""},
	"export":       {"Export diagnostics", "导出诊断", ""},
	"exporting":    {"Saving diagnostics", "正在保存诊断", ""},
	"exported":     {"Saved", "已保存", ""},
	"exportFailed": {"Could not save diagnostics", "无法保存诊断", ""},
}

func newConsole(cancel context.CancelFunc, machine bool) *console {
	console := &console{
		machine: machine,
		plain: consoleModel{view: consoleView{state: "starting"}, language: defaultConsoleLanguage(), width: 76, cancel: cancel,
			colors: colorprofile.Detect(os.Stdout, os.Environ()) > colorprofile.ASCII},
	}
	if machine {
		return console
	}
	if term.IsTerminal(os.Stdin.Fd()) && term.IsTerminal(os.Stdout.Fd()) && os.Getenv("TERM") != "dumb" {
		console.program = tea.NewProgram(console.plain, tea.WithoutSignalHandler())
		console.done = make(chan error, 1)
		go func() {
			_, err := console.program.Run()
			console.done <- err
			cancel()
		}()
	}
	return console
}

func (console *console) send(message tea.Msg) {
	console.mu.Lock()
	defer console.mu.Unlock()
	if console.machine || console.finished {
		return
	}
	if _, finished := message.(consoleFinished); finished {
		console.finished = true
	}
	if console.program != nil {
		console.program.Send(message)
		return
	}
	updated, _ := console.plain.Update(message)
	console.plain = updated.(consoleModel)
	fmt.Fprintln(os.Stdout, console.plain.content(false))
}

func (console *console) show(view consoleView)       { console.send(view) }
func (console *console) setLanguage(language string) { console.send(consoleLanguage(language)) }

func (console *console) finish(err error) error {
	console.send(consoleFinished{err})
	if console.program != nil {
		terminalErr := <-console.done
		if err != nil {
			fmt.Fprintln(os.Stderr, "Piik App:", err)
		}
		if terminalErr != nil {
			fmt.Fprintln(os.Stderr, "Piik App:", terminalErr)
		}
		return terminalErr
	}
	return nil
}

func (console *console) logWriter() io.Writer {
	if console.program == nil {
		return os.Stderr
	}
	return console
}

func (console *console) Write(data []byte) (int, error) {
	if text := strings.TrimSpace(string(data)); text != "" {
		console.send(consoleDiagnostic(ansi.Strip(text)))
	}
	return len(data), nil
}

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

func (model consoleModel) Update(message tea.Msg) (tea.Model, tea.Cmd) {
	switch value := message.(type) {
	case consoleView:
		if model.view.state != "stopping" {
			model.view = value
		}
	case consoleLanguage:
		model.language = string(value)
	case consoleDiagnostic:
		model.view.problem = string(value)
	case consoleDebug:
		model.debug = value
	case consoleExportResult:
		model.exporting, model.exportError = false, value.err != nil
		if value.err == nil {
			model.exportPath = value.path
		}
	case tea.WindowSizeMsg:
		model.width, model.height = value.Width, value.Height
	case tea.ColorProfileMsg:
		model.colors = value.Profile > colorprofile.ASCII
	case consoleTick:
		model.tickPending = false
		model.frame++
		if model.frame >= 16 {
			model.idleWink = false
		}
	case consoleIdleWink:
		model.idlePending = false
		if model.view.state == "ready" || model.view.state == "setup" {
			model.frame, model.idleWink = 8, true
		}
	case consoleOpenResult:
		if value.err != nil {
			model.view.problem = model.text("openFailed")
		}
	case consoleFinished:
		model.finished = true
		model.view.entry, model.view.invite = "", ""
		model.view.state, model.view.problem = "stopped", ""
		if value.err != nil {
			model.view.state, model.view.problem = "failed", value.err.Error()
		}
		return model, tea.Quit
	case tea.KeyPressMsg:
		switch value.String() {
		case "q", "ctrl+c":
			model.view = consoleView{mode: model.view.mode, state: "stopping"}
			model.cancel()
		case "o":
			if target := model.view.entry; target != "" {
				return model, func() tea.Msg { return consoleOpenResult{browser.Open(launchURL(consoleAddress(target)))} }
			}
		case "d", "D":
			if model.debug.export != nil && !model.exporting && !model.finished && model.view.state != "stopping" {
				model.exporting, model.exportError = true, false
				return model, func() tea.Msg {
					path, err := model.debug.export()
					return consoleExportResult{path: path, err: err}
				}
			}
		}
	}
	if model.animating() && !model.tickPending {
		model.tickPending = true
		return model, tea.Tick(200*time.Millisecond, func(time.Time) tea.Msg { return consoleTick{} })
	}
	if !model.finished && !model.animating() && !model.idlePending &&
		(model.view.state == "ready" || model.view.state == "setup") {
		model.idlePending = true
		return model, tea.Tick(time.Duration(8+rand.IntN(13))*time.Second, func(time.Time) tea.Msg { return consoleIdleWink{} })
	}
	return model, nil
}

func (model consoleModel) animating() bool {
	return !model.finished && model.view.state != "stopping" &&
		(model.view.state == "starting" || model.frame < 8 || model.idleWink)
}

func (model consoleModel) text(key string) string {
	index := 0
	if model.language == "zh" {
		index = 1
	}
	if model.language == "vis" {
		return consoleVisualToken(key)
	}
	return consoleCopy[key][index]
}

func (model consoleModel) View() tea.View {
	view := tea.NewView(model.content(true))
	view.WindowTitle = "Piik App"
	view.AltScreen = true
	return view
}

func (model consoleModel) content(styled bool) string {
	width := max(12, min(model.width-2, 74))
	compact := model.height > 0 && model.height < 24
	compactDebug := compact && model.debug.logPath != ""
	visual := model.language == "vis"
	accent, muted, link := lipgloss.NewStyle(), lipgloss.NewStyle(), lipgloss.NewStyle()
	if styled {
		accent = accent.Bold(true)
		muted = muted.Faint(true)
		link = link.Underline(true)
	}
	revision := BuildRevision
	if len(revision) == 40 {
		revision = revision[:7]
	}
	var out strings.Builder
	version := buildVersion()
	heading := "Piik\nApp\n" + muted.Render(version)
	if revision != "" && revision != version {
		heading = "Piik App\n" + muted.Render(version) + "\n" + muted.Render(revision)
	}
	animated := styled && model.animating()
	mascot := accent.Render(consoleTV(model.frame, animated, compact || width < 34))
	if styled && model.colors && width >= 36 && !compactDebug {
		mascot = consoleBlockTV(model.frame, animated)
	}
	fmt.Fprintln(&out, lipgloss.JoinHorizontal(lipgloss.Center, mascot, heading))
	fmt.Fprintln(&out)
	state := model.text(model.view.state)
	if model.view.state == "starting" && !visual {
		dots := 3
		if styled {
			dots = model.frame%3 + 1
		}
		state += strings.Repeat(".", dots)
	}
	if visual {
		stateStyle := accent
		if styled && model.colors {
			switch model.view.state {
			case "ready":
				stateStyle = stateStyle.Foreground(lipgloss.Color("#3fb97a"))
			case "starting", "stopping":
				stateStyle = stateStyle.Foreground(lipgloss.Color("#e8a33d"))
			case "failed":
				stateStyle = stateStyle.Foreground(lipgloss.Color("#e25a52"))
			}
		}
		// Keep visual mode one line tall; multi-line scene art side by side
		// collapses on narrow terminals and reads like missing characters.
		fmt.Fprintln(&out, lipgloss.JoinHorizontal(lipgloss.Center,
			accent.Render(consoleVisualToken(model.view.mode)), " · ",
			stateStyle.Render(consoleVisualToken(model.view.state))))
	} else if compactDebug && model.view.mode != "" {
		fmt.Fprintf(&out, "%s  %s\n", accent.Render(state), model.text(model.view.mode))
	} else {
		fmt.Fprintln(&out, accent.Render(state))
		if model.view.mode != "" {
			fmt.Fprintf(&out, "%s  %s\n", muted.Render(model.text("mode")), model.text(model.view.mode))
		}
	}
	for _, item := range [][2]string{{"entry", model.view.entry}, {"invite", model.view.invite}} {
		if item[1] == "" || compact && item[0] == "invite" {
			continue
		}
		address := consoleAddress(item[1])
		style := link
		if styled {
			target := address
			if item[0] == "entry" {
				target = launchURL(address)
			}
			style = style.Hyperlink(target)
		}
		if compactDebug {
			fmt.Fprintf(&out, "\n%s\n", style.Render(address))
		} else if visual {
			label := consoleVisualToken(item[0])
			fmt.Fprintf(&out, "\n%s %s\n", label, style.Render(address))
		} else {
			fmt.Fprintf(&out, "\n%s\n%s\n", muted.Render(model.text(item[0])), style.Render(address))
		}
	}
	accessPicture := ""
	if !compact && model.view.entry != "" && (model.view.mode == "local" || model.view.mode == "link") {
		access := "open"
		if model.view.protected {
			access = "password"
		}
		if visual {
			accessPicture = consoleVisualToken(access) + "   "
		} else {
			fmt.Fprintf(&out, "\n%s  %s\n", muted.Render(model.text("access")), model.text(access))
		}
	}
	if model.view.problem != "" {
		lines := strings.Split(ansi.Hardwrap(ansi.Strip(model.view.problem), width-4, true), "\n")
		if len(lines) > 3 {
			lines = append(lines[:2], "...")
		}
		fmt.Fprintf(&out, "\n%s\n%s\n", model.text("error"), strings.Join(lines, "\n"))
	}
	if model.debug.logPath != "" {
		path, label := model.debug.logPath, "log"
		if model.exportPath != "" {
			path, label = model.exportPath, "exported"
		}
		separator := "\n"
		if compactDebug {
			separator = " "
		}
		fmt.Fprintf(&out, "\n%s%s%s\n", muted.Render(model.text(label)), separator, consoleFileLink(path, path, link, styled))
		if model.exporting {
			fmt.Fprintln(&out, model.text("exporting"))
		} else if model.exportError {
			fmt.Fprintln(&out, model.text("exportFailed"))
		}
	}
	if !model.finished {
		keys := "[q / Ctrl+C]"
		if !styled {
			keys = "Ctrl+C"
		}
		help := keys + " " + model.text("exit")
		if visual {
			if model.view.entry != "" && styled {
				help = "[o] ↗    " + help
			}
			help = lipgloss.JoinHorizontal(lipgloss.Center, accessPicture, help)
		} else if model.view.entry != "" && styled {
			separator := "    "
			if compact && model.debug.export != nil {
				separator = "\n"
			}
			help = "[o] " + model.text("entry") + separator + help
		}
		if model.debug.export != nil && styled {
			help = "[d] " + model.text("export") + "\n" + help
		}
		if visual {
			fmt.Fprintf(&out, "\n%s", accent.Render(help))
		} else {
			fmt.Fprintf(&out, "\n%s", muted.Render(help))
		}
	}
	content := ansi.Hardwrap(out.String(), width-4, true)
	if !styled {
		return content
	}
	padding := 1
	if model.height > 0 && lipgloss.Height(content)+4 > model.height {
		content = strings.ReplaceAll(content, "\n\n", "\n")
		padding = 0
	}
	return lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).
		Padding(padding, 1).Width(width).Render(content)
}

func consoleVisualToken(key string) string {
	switch key {
	case "local":
		return "□"
	case "link":
		return "↗"
	case "site":
		return "@"
	case "setup":
		return "?"
	case "starting":
		return "…"
	case "ready":
		return "✓"
	case "stopping":
		return "→"
	case "stopped":
		return "○"
	case "failed", "error":
		return "!"
	case "open":
		return "○"
	case "password":
		return "*"
	case "entry":
		return "□"
	case "invite":
		return "↗"
	case "exit":
		return "↪"
	case "log":
		return "LOG"
	case "export":
		return "ZIP"
	case "exporting":
		return "ZIP ..."
	case "exported":
		return "ZIP +"
	case "exportFailed":
		return "ZIP !"
	default:
		return "?"
	}
}

func consoleTV(frame int, animated, compact bool) string {
	phase := 0
	if animated {
		phase = frame % 8
	}
	eye := "o"
	if !animated || phase >= 4 {
		eye = "-"
	}
	if compact {
		return "  \\ /     \n [o  " + eye + "]   \n  /  \\     "
	}
	stars := [3]string{" ", " ", " "}
	if phase == 5 {
		stars[2] = "*"
	}
	if phase == 6 {
		stars[1] = "+"
	}
	if phase == 7 {
		stars[0] = "."
	}
	lines := []string{
		"     \\ /     " + stars[0] + " ",
		" .----v----.  " + stars[1] + " ",
		" | o     " + eye + " |  " + stars[2] + " ",
		" '---------'    ",
		"   /     \\      ",
	}
	return strings.Join(lines, "\n")
}

func consoleBlockTV(frame int, animated bool) string {
	phase := 0
	if animated {
		phase = frame % 8
	}
	shell := lipgloss.NewStyle().Reverse(true)
	spark := lipgloss.NewStyle().Foreground(lipgloss.Color("#f4c14d")).Faint(phase == 7)
	// Digits reveal the shell clockwise before the face; subsequent loops keep it drawn.
	rows := []string{"  2   2  ", "   2 2   ", " 0000011 ", "3sssssss1", "3sessses1", "3sssssss1", " 3222222 ", "  3   3  "}
	lines := make([]string, 0, len(rows))
	for rowIndex, row := range rows {
		var line strings.Builder
		for column, pixel := range row {
			if animated && (pixel >= '0' && pixel <= '3' && frame < int(pixel-'0') || (pixel == 's' || pixel == 'e') && frame < 3) {
				pixel = ' '
			}
			switch pixel {
			case '0', '1', '2', '3':
				line.WriteString(shell.Render("  "))
			case 's':
				line.WriteString("  ")
			case 'e':
				if column == len(row)-3 && (!animated || phase >= 4) {
					line.WriteString("\u2584\u2584")
				} else {
					line.WriteString(shell.Render("  "))
				}
			default:
				line.WriteString("  ")
			}
		}
		star := "   "
		starStyle := spark
		switch {
		case phase == 5 && rowIndex == 4:
			star = "\u2584\u2588\u2584"
		case phase == 5 && rowIndex == 5:
			star, starStyle = "\u2584 \u2584", spark.Reverse(true)
		case phase == 6 && rowIndex == 2:
			star = " \u2584 "
		case phase == 7 && rowIndex == 1:
			star = "  ."
		}
		lines = append(lines, line.String()+starStyle.Render(star))
	}
	return strings.Join(lines, "\n")
}

func consoleAddress(raw string) string {
	parsed, err := url.Parse(raw)
	if err != nil {
		return ""
	}
	parsed.User, parsed.RawQuery, parsed.Fragment, parsed.RawFragment, parsed.ForceQuery = nil, "", "", "", false
	return parsed.String()
}

func consoleFileLink(path, label string, style lipgloss.Style, styled bool) string {
	if !styled {
		return label
	}
	path = filepath.ToSlash(path)
	if !strings.HasPrefix(path, "/") {
		path = "/" + path
	}
	address := url.URL{Scheme: "file", Path: path}
	return style.Hyperlink(address.String()).Render(label)
}