collapse_tty.go

// Copyright 2023 The Okteto Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package displayer

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"os"
	"regexp"
	"runtime"
	"strings"
	"sync"
	"text/template"
	"time"

	"github.com/manifoldco/promptui"
	"github.com/manifoldco/promptui/screenbuf"
	oktetoLog "github.com/okteto/okteto/pkg/log"
	"golang.org/x/term"
)

const ansi = "[\u001B\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"

var (
	spinnerChars = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	cursorUp     = "\x1b[1A"
	resetLine    = "\x1b[0G"
	re           = regexp.MustCompile(ansi)
)

// TTYCollapseDisplayer displays with a screenbuff
type TTYCollapseDisplayer struct {
	err                   error
	commandContext        context.Context
	stdoutScanner         *bufio.Scanner
	stderrScanner         *bufio.Scanner
	screenbuf             *screenbuf.ScreenBuf
	cancel                context.CancelFunc
	command               string
	linesToDisplay        []string
	numberOfLines         int
	buildingpreviousLines int
	isBuilding            bool
}

// Display displays a
func (d *TTYCollapseDisplayer) Display(commandName string) {
	d.command = commandName

	d.hideCursor()
	d.commandContext, d.cancel = context.WithCancel(context.Background())
	wg := &sync.WaitGroup{}
	wgDelta := 0
	if d.stdoutScanner != nil {
		wgDelta++
	}
	if d.stderrScanner != nil {
		wgDelta++
	}
	wg.Add(wgDelta)

	commandChan := make(chan bool, 1)
	go d.displayCommand(commandChan)
	if d.stdoutScanner != nil {
		go d.displayStdout(wg)
	}
	if d.stderrScanner != nil {
		go d.displayStderr(wg)
	}
	wg.Wait()
	d.cancel()
	<-commandChan
}

func (d *TTYCollapseDisplayer) displayCommand(commandChan chan bool) {
	t := time.NewTicker(50 * time.Millisecond)
	shouldExit := false
	for {
		for i := 0; i < len(spinnerChars); i++ {
			select {
			case <-t.C:
				width, _, err := term.GetSize(int(os.Stdout.Fd()))
				if err != nil {
					oktetoLog.Infof("Error getting terminal size: %s", err)
				}
				commandLines := renderCommand(spinnerChars[i], d.command, width)
				for _, commandLine := range commandLines {
					if _, err := d.screenbuf.Write(commandLine); err != nil {
						oktetoLog.Infof("Error writing command line: %s", err)
					}
				}
				lines := renderLines(d.linesToDisplay, width)
				for _, line := range lines {
					if _, err := d.screenbuf.Write(line); err != nil {
						oktetoLog.Infof("Error writing line: %s", err)
					}
				}
				d.screenbuf.Flush()
			case <-d.commandContext.Done():
				shouldExit = true
			}
			if shouldExit {
				break
			}
		}
		if shouldExit {
			break
		}
	}
	commandChan <- true
}

func (d *TTYCollapseDisplayer) displayStdout(wg *sync.WaitGroup) {
	for d.stdoutScanner.Scan() {
		select {
		case <-d.commandContext.Done():
		default:
			line := strings.TrimSpace(d.stdoutScanner.Text())
			if isTopDisplay(line) {
				prevState := d.isBuilding
				d.isBuilding = checkIfIsBuildingLine(line)
				if d.isBuilding && d.isBuilding != prevState {
					d.buildingpreviousLines = len(d.linesToDisplay)
				}
				sanitizedLine := strings.ReplaceAll(line, cursorUp, "")
				sanitizedLine = strings.ReplaceAll(sanitizedLine, resetLine, "")
				d.linesToDisplay = append(d.linesToDisplay[:d.buildingpreviousLines-1], sanitizedLine)
			} else {
				if len(d.linesToDisplay) >= d.numberOfLines {
					d.linesToDisplay = d.linesToDisplay[1:]
				}
				d.linesToDisplay = append(d.linesToDisplay, line)
			}
			if os.Stdout == oktetoLog.GetOutput() {
				oktetoLog.AddToBuffer(oktetoLog.InfoLevel, line)
			}
			continue
		}
		break
	}
	if d.stdoutScanner.Err() != nil {
		oktetoLog.Infof("Error reading command output: %s", d.stdoutScanner.Err().Error())
	}
	wg.Done()
}

func checkIfIsBuildingLine(line string) bool {
	if strings.Contains(line, "Building") {
		return !strings.Contains(line, "FINISHED")
	}
	return false
}

func (d *TTYCollapseDisplayer) displayStderr(wg *sync.WaitGroup) {
	for d.stderrScanner.Scan() {
		select {
		case <-d.commandContext.Done():
		default:
			line := strings.TrimSpace(d.stderrScanner.Text())
			d.err = errors.New(line)
			if len(d.linesToDisplay) >= d.numberOfLines {
				d.linesToDisplay = d.linesToDisplay[1:]
			}
			d.linesToDisplay = append(d.linesToDisplay, line)
			if os.Stdout == oktetoLog.GetOutput() {
				oktetoLog.AddToBuffer(oktetoLog.WarningLevel, line)
			}
			continue
		}
		break
	}
	if d.stderrScanner.Err() != nil {
		oktetoLog.Infof("Error reading command output: %s", d.stderrScanner.Err().Error())
	}
	wg.Done()
}

func isTopDisplay(line string) bool {
	return strings.Contains(line, fmt.Sprintf("%s%s", cursorUp, resetLine))
}

// CleanUp collapses and stop displaying
func (d *TTYCollapseDisplayer) CleanUp(err error) {
	if d.screenbuf == nil {
		return
	}
	if d.command == "" {
		return
	}

	var message []byte
	if err == nil {
		message = renderSuccessCommand(d.command)
		d.screenbuf.Reset()
		if err := d.screenbuf.Clear(); err != nil {
			oktetoLog.Infof("Error clearing screen: %s", err)
		}
		if err := d.screenbuf.Flush(); err != nil {
			oktetoLog.Infof("Error flushing screen: %s", err)
		}
		if _, err := d.screenbuf.Write(message); err != nil {
			oktetoLog.Infof("Error writing success message: %s", err)
		}
		d.screenbuf.Flush()
	} else {
		message = renderFailCommand(d.command, err)
		d.screenbuf.Reset()
		if err := d.screenbuf.Clear(); err != nil {
			oktetoLog.Infof("Error clearing screen: %s", err)
		}
		if err := d.screenbuf.Flush(); err != nil {
			oktetoLog.Infof("Error flushing screen: %s", err)
		}
		if _, err := d.screenbuf.Write(message); err != nil {
			oktetoLog.Infof("Error writing fail message: %s", err)
		}
		width, _, err := term.GetSize(int(os.Stdout.Fd()))
		if err != nil {
			oktetoLog.Infof("Error getting terminal size: %s", err)
		}
		lines := renderLines(d.linesToDisplay, width)
		for _, line := range lines {
			if _, err := d.screenbuf.Write(line); err != nil {
				oktetoLog.Infof("Error writing line: %s", err)
			}
		}
		d.screenbuf.Flush()
	}
	d.cancel()
	<-d.commandContext.Done()
	d.reset()
	d.showCursor()

}

func renderCommand(spinnerChar, command string, charsPerLine int) [][]byte {
	firstLineCommandTemplate := fmt.Sprintf(` %s {{ . | oktetoblue }}`, spinnerChar)
	otherLineCommandTemplate := `    {{ . | oktetoblue }}`
	lastLineCommandTemplate := `    {{ . | oktetoblue }}:`
	funcMap := promptui.FuncMap
	funcMap["oktetoblue"] = oktetoLog.BlueString
	firstLineTpl, err := template.New("").Funcs(funcMap).Parse(firstLineCommandTemplate)
	if err != nil {
		return [][]byte{}
	}

	otherLinesTpl, err := template.New("").Funcs(funcMap).Parse(otherLineCommandTemplate)
	if err != nil {
		return [][]byte{}
	}

	lastLineTpl, err := template.New("").Funcs(funcMap).Parse(lastLineCommandTemplate)
	if err != nil {
		return [][]byte{}
	}

	command = fmt.Sprintf(" Running '%s'", command)
	result := [][]byte{}
	if charsPerLine == 0 || charsPerLine < 5 {
		result = append(result, render(firstLineTpl, command))
		return result
	}
	iterations := (len(command) + 4) / charsPerLine
	start := 0
	end := charsPerLine - 5
	for i := 0; i < iterations+1; i++ {
		if i == iterations {
			end = len(command) - 1
		}
		currentLine := command[start:end]
		if i == 0 {
			result = append(result, render(firstLineTpl, currentLine))
		} else if i < iterations {
			result = append(result, render(otherLinesTpl, currentLine))
		} else {
			result = append(result, render(lastLineTpl, currentLine))
		}
		start = end
		end += charsPerLine - 5
	}
	return result
}

func renderSuccessCommand(command string) []byte {
	commandTemplate := `{{ " ✓ " | bgGreen | black }} {{ . | green }}`
	tpl, err := template.New("").Funcs(promptui.FuncMap).Parse(commandTemplate)
	if err != nil {
		return []byte{}
	}

	return render(tpl, command)
}

func renderFailCommand(command string, err error) []byte {
	message := fmt.Sprintf("%s: %s", command, err.Error())
	commandTemplate := `{{ " x " | bgRed | black }} {{ . | oktetored }}`
	funcMap := promptui.FuncMap
	funcMap["oktetored"] = oktetoLog.RedString
	tpl, err := template.New("").Funcs(funcMap).Parse(commandTemplate)
	if err != nil {
		return []byte{}
	}

	return render(tpl, message)
}

func renderLines(queue []string, charsPerLine int) [][]byte {
	lineTemplate := "{{ . | white }} "
	tpl, err := template.New("").Funcs(promptui.FuncMap).Parse(lineTemplate)
	if err != nil {
		return [][]byte{}
	}

	result := [][]byte{}
	for _, line := range queue {
		lineWithoutColors := re.ReplaceAllString(line, "")
		if len(line) == len(lineWithoutColors) {
			result = append(result, renderLogWithoutColors(tpl, line, charsPerLine)...)
		} else {
			result = append(result, renderLogWithColors(tpl, line, charsPerLine)...)
			continue
		}
	}
	return result
}

func renderLogWithColors(tpl *template.Template, line string, charsPerLine int) [][]byte {
	result := [][]byte{}
	if charsPerLine > 4 && len(line)+2 > charsPerLine {
		result = append(result, render(tpl, fmt.Sprintf("%s...", line[:charsPerLine-1])))
	} else if line == "" {
		result = append(result, []byte(""))
	} else {
		result = append(result, render(tpl, fmt.Sprintf("%s...", line)))
	}
	return result
}

func renderLogWithoutColors(tpl *template.Template, line string, charsPerLine int) [][]byte {
	result := [][]byte{}
	if line == "" {
		result = append(result, []byte(""))
	} else if charsPerLine == 0 {
		line = strings.TrimSpace(line)
		result = append(result, render(tpl, line))
	} else if iterations := len(line) / charsPerLine; iterations != 0 {
		start := 0
		end := charsPerLine - 2
		for i := 0; i < iterations+1; i++ {
			if i == iterations {
				end = len(line) - 1
			}
			currentLine := line[start:end]
			currentLine = strings.TrimSpace(currentLine)
			result = append(result, render(tpl, currentLine))
			start = end
			end += charsPerLine - 2

		}
	} else {
		line = strings.TrimSpace(line)
		result = append(result, render(tpl, line))
	}
	return result
}

func render(tpl *template.Template, data interface{}) []byte {
	var buf bytes.Buffer
	err := tpl.Execute(&buf, data)
	if err != nil {
		return []byte(fmt.Sprintf("%v", data))
	}
	return buf.Bytes()
}

func (*TTYCollapseDisplayer) hideCursor() {
	if runtime.GOOS != "windows" {
		fmt.Print("\033[?25l")
	}
}

func (*TTYCollapseDisplayer) showCursor() {
	if runtime.GOOS != "windows" {
		fmt.Print("\033[?25h")
	}
}

func (d *TTYCollapseDisplayer) reset() {

	d.command = ""
	d.err = nil

	d.linesToDisplay = []string{}
	d.screenbuf.Reset()
}