# Colorful language

HELP := "
    colorful: A domain-specific language for writing colored text to the terminal
    Usage: colorful [args...] [--by-line] [--files files...]
"

CSI := "\033["

use patterns

lang Colorful
    convert(text:Text -> Colorful)
        text = text.translate({"@": "@(at)", "(": "@(lparen)", ")": "@(rparen)"})
        return Colorful.from_text(text)

    convert(i:Int -> Colorful) return Colorful.from_text("$i")
    convert(n:Num -> Colorful) return Colorful.from_text("$n")

    func for_terminal(c:Colorful -> Text)
        return CSI ++ "m" ++ _for_terminal(c, _TermState())

    func print(c:Colorful, newline=yes)
        say(c.for_terminal(), newline=newline)


func main(texts:[Text]=[], files:[Path]=[], by_line=no)
    for i,text in texts
        colorful := Colorful.from_text(text)
        colorful.print(newline=no)
        if i == texts.length then say("")
        else say(" ", newline=no)

    if texts.length == 0 and files.length == 0
        files = [(/dev/stdin)]

    for file in files
        if by_line
            for line in file.by_line() or exit("Could not read file: $file")
                colorful := Colorful.from_text(line)
                colorful.print()
        else
            colorful := Colorful.from_text(file.read() or exit("Could not read file: $file"))
            colorful.print(newline=no)


func _for_terminal(c:Colorful, state:_TermState -> Text)
    return $Pat'@(?)'.map(c.text, recursive=no, func(m:PatternMatch) _add_ansi_sequences(m.captures[1]!, state))

enum _Color(Default, Bright(color:Int16), Color8Bit(color:Int16), Color24Bit(color:Int32))
    func from_text(text:Text -> _Color?)
        if $Pat'#{3-6 hex}'.matches(text)
            hex := text.from(2)
            return none unless hex.length == 3 or hex.length == 6
            if hex.length == 3
                hex = hex[1]!++hex[1]!++hex[2]!++hex[2]!++hex[3]!++hex[3]!
            n := Int32.parse("0x" ++ hex) or return none
            return Color24Bit(n)
        else if $Pat'{1-3 digit}'.matches(text)
            n := Int16.parse(text) or return none
            if n >= 0 and n <= 255 return Color8Bit(n)
        else if text == "black" return _Color.Color8Bit(0)
        else if text == "red" return _Color.Color8Bit(1)
        else if text == "green" return _Color.Color8Bit(2)
        else if text == "yellow" return _Color.Color8Bit(3)
        else if text == "blue" return _Color.Color8Bit(4)
        else if text == "magenta" return _Color.Color8Bit(5)
        else if text == "cyan" return _Color.Color8Bit(6)
        else if text == "white" return _Color.Color8Bit(7)
        else if text == "default" return _Color.Default
        else if text == "BLACK" return _Color.Bright(0)
        else if text == "RED" return _Color.Bright(1)
        else if text == "GREEN" return _Color.Bright(2)
        else if text == "YELLOW" return _Color.Bright(3)
        else if text == "BLUE" return _Color.Bright(4)
        else if text == "MAGENTA" return _Color.Bright(5)
        else if text == "CYAN" return _Color.Bright(6)
        else if text == "WHITE" return _Color.Bright(7)
        return none

    func fg(c:_Color -> Text)
        when c is Color8Bit(color)
            if color >= 0 and color <= 7 return "$(30+color)"
            else if color >= 0 and color <= 255 return "38;5;$color"
        is Color24Bit(hex)
            if hex >= 0 and hex <= 0xFFFFFF
                return "38;2;$((hex >> 16) and 0xFF);$((hex >> 8) and 0xFF);$((hex >> 0) and 0xFF)"
        is Bright(color)
            if color <= 7 return "$(90+color)"
        is Default
            return "39"
        fail("Invalid foreground color: '$c'")

    func bg(c:_Color -> Text)
        when c is Color8Bit(color)
            if color >= 0 and color <= 7 return "$(40+color)"
            else if color >= 0 and color <= 255 return "48;5;$color"
        is Color24Bit(hex)
            if hex >= 0 and hex <= 0xFFFFFF
                return "48;2;$((hex >> 16) and 0xFF);$((hex >> 8) and 0xFF);$((hex >> 0) and 0xFF)"
        is Bright(color)
            if color <= 7 return "$(90+color)"
        is Default
            return "49"
        fail("Invalid background color: '$c'")

    func underline(c:_Color -> Text)
        when c is Color8Bit(color)
            if color >= 0 and color <= 255 return "58;5;$color"
        is Color24Bit(hex)
            if hex >= 0 and hex <= 0xFFFFFF
                return "58;2;$((hex >> 16) and 0xFF);$((hex >> 8) and 0xFF);$((hex >> 0) and 0xFF)"
        is Default
            return "59"
        is Bright(color)
            pass
        fail("Invalid underline color: '$c'")

func _toggle(sequences:&[Text], cur,new:Bool, apply,unapply:Text; inline)
    if new and not cur
        sequences.insert(apply)
    else if cur and not new
        sequences.insert(unapply)

func _toggle2(sequences:&[Text], cur1,cur2,new1,new2:Bool, apply1,apply2,unapply:Text; inline)
    return if new1 == cur1 and new2 == cur2
    if (cur1 and not new1) or (cur2 and not new2) # Gotta wipe at least one
        sequences.insert(unapply)
        cur1, cur2 = no, no # Wiped out

    if new1 and not cur1
        sequences.insert(apply1)
    if new2 and not cur2
        sequences.insert(apply2)

struct _TermState(
    bold=no, dim=no, italic=no, underline=no, blink=no,
    reverse=no, conceal=no, strikethrough=no, fraktur=no, frame=no,
    encircle=no, overline=no, superscript=no, subscript=no,
    bg=_Color.Default, fg=_Color.Default, underline_color=_Color.Default,
)

    func apply(old,new:_TermState -> Text)
        sequences : &[Text]
        _toggle2(sequences, old.bold, old.dim, new.bold, new.dim, "1", "2", "22")
        _toggle2(sequences, old.italic, old.fraktur, new.italic, new.fraktur, "3", "20", "23")
        _toggle(sequences, old.underline, new.underline, "4", "24")
        _toggle(sequences, old.blink, new.blink, "5", "25")
        _toggle(sequences, old.reverse, new.reverse, "7", "27")
        _toggle(sequences, old.conceal, new.conceal, "8", "28")
        _toggle(sequences, old.strikethrough, new.strikethrough, "9", "29")
        _toggle2(sequences, old.frame, old.encircle, new.frame, new.frame, "51", "52", "54")
        _toggle(sequences, old.overline, new.overline, "53", "55")
        _toggle2(sequences, old.subscript, old.subscript, new.superscript, new.superscript, "73", "74", "75")

        if new.bg != old.bg
            sequences.insert(new.bg.bg())

        if new.fg != old.fg
            sequences.insert(new.fg.fg())

        if new.underline_color != old.underline_color
            sequences.insert(new.underline_color.underline())

        if sequences.length == 0
            return ""
        return CSI ++ ";".join(sequences) ++ "m"

func _add_ansi_sequences(text:Text, prev_state:_TermState -> Text)
    if text == "lparen" return "("
    else if text == "rparen" return ")"
    else if text == "@" or text == "at" return "@"
    parts := (
        $Pat'{0+..}:{0+..}'.capture(text) or
        return "@("++_for_terminal(Colorful.from_text(text), prev_state)++")"
    )
    attributes := $Pat'{0+space},{0+space}'.split(parts[1]!)
    new_state := prev_state
    for attr in attributes
        if attr.starts_with("fg=")
            new_state.fg = _Color.from_text(attr.from(4))!
        else if attr.starts_with("bg=")
            new_state.bg = _Color.from_text(attr.from(4))!
        else if attr.starts_with("ul=")
            new_state.underline_color = _Color.from_text(attr.from(4))!
        else if color := _Color.from_text(attr)
            new_state.fg = color
        else if attr == "b" or attr == "bold"
            new_state.bold = yes
        else if attr == "d" or attr == "dim"
            new_state.dim = yes
        else if attr == "i" or attr == "italic"
            new_state.italic = yes
        else if attr == "u" or attr == "underline"
            new_state.underline = yes
        else if attr == "s" or attr == "strikethrough"
            new_state.strikethrough = yes
        else if attr == "B" or attr == "blink"
            new_state.blink = yes
        else if attr == "r" or attr == "reverse"
            new_state.reverse = yes
        else if attr == "fraktur"
            new_state.fraktur = yes
        else if attr == "frame"
            new_state.frame = yes
        else if attr == "encircle"
            new_state.encircle = yes
        else if attr == "overline"
            new_state.overline = yes
        else if attr == "super" or attr == "superscript"
            new_state.superscript = yes
        else if attr == "sub" or attr == "subscript"
            new_state.subscript = yes
        else
            fail("Invalid attribute: '$attr'")

    result := prev_state.apply(new_state)
    result ++= $Pat'@(?)'.map(parts[2]!, recursive=no, func(m:PatternMatch) _add_ansi_sequences(m.captures[1]!, new_state))
    result ++= new_state.apply(prev_state)
    return result