package tui
import (
"fmt"
"time"
)
// A mood is a class of moment in a turn. Each class owns its own faces, so a
// face always means something: what albedo is doing, or how a turn ended.
type mood string
const (
moodPreparing mood = "preparing"
moodThinking mood = "thinking"
moodResponding mood = "responding"
moodWorking mood = "working"
moodCompacting mood = "compacting"
moodStopping mood = "stopping"
moodConnecting mood = "connecting"
moodDone mood = "done"
moodQuick mood = "quick"
moodLong mood = "long"
moodTired mood = "tired"
moodFailed mood = "failed"
moodStopped mood = "stopped"
)
// Faces avoid combining marks and right-to-left letters, which terminals
// disagree on.
//
// A phase owns a pool of animations and each turn plays one of them. A face
// keeps its parentheses in place across frames: only eyes, mouth, and what
// follows the face move.
var animations = map[mood][][]string{
moodPreparing: {{"(・・ )", "( ・・)"}},
moodThinking: {
{"( ˘ω˘ )", "( ˘ω˘ ).", "( ˘ω˘ )..", "( ˘ω˘ )..."},
{"(・ω・ )", "( ・ω・)", "(・ω・ )?", "( ・ω・)?"},
{"(´-ω-`)", "(´･ω･`)", "(´-ω-`)", "(´･ω･`)!"},
},
moodResponding: {
{"(ˊᗜˋ )", "(ˊ-ˋ )", "( ˊᗜˋ)", "( ˊ-ˋ)"},
{"(˶ᵔ ᗜ ᵔ˶)", "(˶ᵔ ᵕ ᵔ˶)"},
{"(・ᗜ・)", "(・-・)", "(・ᗜ・)ﾉ", "(・-・)ﾉ"},
},
moodWorking: {
{"(˶•ᴗ•)ｶﾀ", "(˶•ᴗ•)ｶﾀｶﾀ", "(˶•ᴗ•)ｶﾀｶﾀｶﾀ"},
{"(・_・ )", "( ・_・)", "(・ᴗ・ )✧"},
{"(っ•ᴗ•)っ･", "(っ•ᴗ•)っ ･", "(っ•ᴗ•)っ ･"},
{"ヽ(･ω･)ﾉ", "ヾ(･ω･)ﾉ"},
{"(๑•ᴗ•)", "(๑•ᴗ•)✧", "(๑•ᴗ•) ✧"},
},
moodCompacting: {{"(>_<)", "(>.<)"}},
moodStopping: {{"(・_・;)"}},
moodConnecting: {
{"(・ω・)ﾉ", "(・ω・)ﾉ ･", "(・ω・)ﾉ ･･", "(・ω・)ﾉ ･･･"},
{"( ˘ω˘ )～", "( ˘ω˘ )～～", "( ˘ω˘ )～～～"},
{"(っ•ᴗ•)っ", "(っ•ᴗ•)っ ･", "(っ•ᴗ•)っ ･ﾟ", "(っ•ᴗ•)っ ･ﾟ✧"},
},
}
// An outcome owns a pool of faces and each turn shows one of them.
// Additional faces come from https://wikileaks.org/ciav7p1/cms/page_17760284.html.
var faces = map[mood][]string{
moodDone: {"(˶ᵔ ᵕ ᵔ˶)", "(๑˃ᴗ˂)", "ヽ(・∀・)ﾉ", "(ᵔᴥᵔ)", "(っ˘ω˘ς)", "(◕‿◕)", "(✿◠‿◠)", "(o´ω｀o)", "☻_☻", "ᶘ ᵒᴥᵒᶅ"},
moodQuick: {"(・ω・)ノ", "(｀・ω・´)", "(^_−)☆", "(^▽^)"},
moodLong: {"(ง ˃ᴗ˂)ง", "(๑˃ᴗ˂)✧", "(ˊᗜˋ*)✧", "o(≧∀≦)o", "(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧"},
moodTired: {"(￣ー￣;)ゞ", "(・ω・;)ゞ", "( ˘ᴗ˘ )ﾌｩ", "(´-ω-`)zzZ", "_(:3 」∠)_", "(︶ω︶)", "(-＿- )ノ", "(n˘v˘•)¬"},
moodFailed: {"(╥﹏╥)", "(｡•︿•｡)", "(っ- ‸ – ς)", "(ಥ﹏ಥ)", "(╥_╥)", "☹_☹", "(ಠ~ಠ)", "(ಡ_ಡ)", "(ತಎತ)", "(ತ_ತ)", "(ಥдಥ)"},
moodStopped: {"(・_・;)", "(°ロ°)", "(￣□￣;)", "(ಠ_ಠ)", "(°Д°)"},
}
// pick chooses from n by seed, salted by the mood so one turn's picks for
// different moods do not move in step.
func (m mood) pick(seed int64, n int) int {
return int(fnv1a(uint64(seed), string(m)) % uint64(n))
}
// face picks a stable face for seed, so a rebuilt transcript keeps its faces.
func (m mood) face(seed int64) string {
set := faces[m]
return set[m.pick(seed, len(set))]
}
// faceInterval is how long each frame of an animation shows.
const faceInterval = 500 * time.Millisecond
// frame is the turn's animation at tick, one frame per faceInterval.
func (m mood) frame(seed int64, tick int) string {
pool := animations[m]
set := pool[m.pick(seed, len(pool))]
return set[tick%len(set)]
}
// reachingText is what waiting on a host reads as, by its label: connecting,
// or copying albedo's kernel over (step staging), which the first visit to a
// host, and the first after albedo's python changed, waits for.
func reachingText(label, step string) string {
if step == "staging" {
return "copying the kernel to " + label + "…"
}
return "connecting to " + label + "…"
}
// connectingFace is the animation for reaching a host, by its label, at
// tick: the same one for a host wherever it shows.
func connectingFace(host string, tick int) string {
return moodConnecting.frame(int64(fnv1a(fnvOffset64, host)), tick)
}
// outcome classes a finished turn by how it ended and how long it took.
func outcome(failed, stopped bool, elapsedMs int64) mood {
switch {
case stopped:
return moodStopped
case failed:
return moodFailed
case elapsedMs > 10*60_000:
return moodTired
case elapsedMs >= 3*60_000:
return moodLong
case elapsedMs > 0 && elapsedMs < 4_000:
return moodQuick
}
return moodDone
}
func formatElapsed(ms int64) string {
s := ms / 1000
switch {
case s < 60:
return fmt.Sprintf("%ds", s)
case s < 3600:
return fmt.Sprintf("%dm %ds", s/60, s%60)
}
return fmt.Sprintf("%dh %dm", s/3600, s/60%60)
}
// formatGap is how long you were away, in the largest whole unit.
func formatGap(ms int64) string {
m := ms / 60_000
switch {
case m < 60:
return fmt.Sprintf("%dm later", m)
case m < 48*60:
return fmt.Sprintf("%dh later", m/60)
}
return fmt.Sprintf("%dd later", m/(24*60))
}