main.go

package main

import (
	"fmt"
	"os"
	"time"

	"github.com/charmbracelet/bubbles/help"
	"github.com/charmbracelet/bubbles/key"
	"github.com/charmbracelet/bubbles/timer"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"

	"github.com/isaacdonaldson/pomgo/fonts"
)

const (
	WorkPeriod     = time.Second * 1500 // 25 mins
	RestPeriod     = time.Second * 300  // 5 mins
	LongRestPeriod = time.Second * 1500 // 900 mins
)

const (
	ColorGreen     = "#a9dc76"
	ColorRed       = "#ff6188"
	ColorYellow    = "#ffd866"
	ColorGrey      = "#2d2a2e"
	ColorLightGrey = "#939293"
	ColorPurple    = "#ab9df2"
	ColorOrange    = "#fc9867"
)

type TextStyle int

const (
	SimpleLineSmall TextStyle = iota
	ShadowBlockLarge
	PlainBlockLarge
)

type viewport struct {
	Style     lipgloss.Style
	Width     int
	Height    int
	TextColor string
	TextStyle TextStyle
}

type timings struct {
	workPeriod int
	restPeriod int
}

type model struct {
	timer    timer.Model
	keymap   keymap
	help     help.Model
	quitting bool
	timings  timings
	viewport viewport
}

type keymap struct {
	start key.Binding
	stop  key.Binding
	reset key.Binding
	quit  key.Binding
}

func (m model) Init() tea.Cmd {
	return m.timer.Init()
}

func (m model) Timings() (int, int) {
	return m.timings.workPeriod, m.timings.restPeriod
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case timer.TickMsg:
		var cmd tea.Cmd
		m.timer, cmd = m.timer.Update(msg)
		return m, cmd

	case timer.StartStopMsg:
		var cmd tea.Cmd
		m.timer, cmd = m.timer.Update(msg)
		m.keymap.stop.SetEnabled(m.timer.Running())
		m.keymap.start.SetEnabled(!m.timer.Running())
		return m, cmd

	case timer.TimeoutMsg:
		// Stop the timer and reset the values for the next period
		var cmd tea.Cmd
		stopMsg := timer.StartStopMsg{ID: m.timer.ID()}
		m.timer, cmd = m.timer.Update(stopMsg)
		m.keymap.stop.SetEnabled(m.timer.Running())
		m.keymap.start.SetEnabled(!m.timer.Running())

		// TODO: have this display 00:00 and on start display the next time?
		work, rest := m.Timings()
		if work == 1 && rest == 0 {
			m.timings.restPeriod++
			m.timer.Timeout = RestPeriod
			m.viewport.TextColor = ColorGreen
			return m, cmd
		} else if work == 1 && rest == 1 {
			m.timings.workPeriod++
			m.timer.Timeout = WorkPeriod
			m.viewport.TextColor = ColorYellow
			return m, cmd
		} else if work == 2 && rest == 1 {
			m.timings.restPeriod++
			m.timer.Timeout = RestPeriod
			m.viewport.TextColor = ColorGreen
			return m, cmd
		} else if work == 2 && rest == 2 {
			m.timings.workPeriod++
			m.timer.Timeout = WorkPeriod
			m.viewport.TextColor = ColorYellow
			return m, cmd
		} else if work == 3 && rest == 2 {
			m.timings.restPeriod++
			m.timer.Timeout = LongRestPeriod
			m.viewport.TextColor = ColorGreen
			return m, cmd
		} else {
			m.timings.workPeriod = 1
			m.timings.restPeriod = 0
			m.timer.Timeout = WorkPeriod
			m.viewport.TextColor = ColorYellow
			return m, cmd
		}

	case tea.KeyMsg:
		switch {
		case key.Matches(msg, m.keymap.quit):
			m.quitting = true
			return m, tea.Quit
		case key.Matches(msg, m.keymap.reset):
			m.timings.workPeriod = 1
			m.timings.restPeriod = 0
			m.timer.Timeout = WorkPeriod
			m.viewport.TextColor = ColorYellow
		case key.Matches(msg, m.keymap.start, m.keymap.stop):
			return m, m.timer.Toggle()
		}

	case tea.WindowSizeMsg:
		m.viewport.Width = msg.Width
		m.viewport.Height = msg.Height
	}

	return m, nil
}

func (m model) helpView() string {
	return m.help.ShortHelpView([]key.Binding{
		m.keymap.start,
		m.keymap.stop,
		m.keymap.reset,
		m.keymap.quit,
	})
}

func (m model) View() string {
	// For a more detailed timer view you could read m.timer.Timeout to get
	// the remaining time as a time.Duration and skip calling m.timer.View()
	// entirely.
	t := m.timer.Timeout
	totalSeconds := int64(t.Seconds())
	mins := totalSeconds / 60
	secs := totalSeconds - (mins * 60)
	millis := t.Milliseconds()

	// TODO: also render the milliseconds
	minsString := numToString(mins, m.viewport.TextStyle)
	secsString := numToString(secs, m.viewport.TextStyle)

	// TODO: base this off the config/selected font
	var numRows int
	switch m.viewport.TextStyle {
	case SimpleLineSmall:
		numRows = fonts.SimpleLineSmallHeight
	case ShadowBlockLarge:
		numRows = fonts.ShadowBlockLargeHeight
	case PlainBlockLarge:
		numRows = fonts.PlainBlockLargeHeight
	default:
		numRows = fonts.ShadowBlockLargeHeight
	}

	s := "Pomogoro\n"
	for row := 0; row < numRows+1; row++ {
		s += minsString[row] + fonts.ColonForSize(numRows)[row] + " " + secsString[row]

		if row != numRows {
			s += "\n"
		}
	}

	s += lipgloss.NewStyle().
		Foreground(lipgloss.Color(ColorLightGrey)).
		Render(fmt.Sprintf("%03d", int(millis%1000)))
	s += "\n"

	// Adding the styling to the numbers
	timerStyle := lipgloss.NewStyle().
		MarginRight(4).
		MarginLeft(4).
		Foreground(lipgloss.Color(m.viewport.TextColor))

	if !m.quitting {
		// TODO: add in extra things like title and clock time here
		s += m.helpView()
		s = timerStyle.Render(s)
	} else {
		return timerStyle.
			UnsetBorderBottom().
			UnsetBorderTop().
			UnsetBorderLeft().
			UnsetBorderRight().
			Render(s)
	}

	w := m.viewport.Width
	h := m.viewport.Height

	clockWidth := lipgloss.Width(s)
	clockHeight := lipgloss.Height(s)

	// s += "\n-> " + strconv.Itoa(clockWidth) + " " + strconv.Itoa(clockHeight) + " | " + strconv.Itoa(w) + " " + strconv.Itoa(h) + " <-"

	halfW := (w - clockWidth) / 2
	halfH := (h - clockHeight) / 2

	// TODO: Move all styling to a separate function
	// Creating the styling for the terminal window
	terminalStyle := lipgloss.NewStyle().
		PaddingLeft(halfW).
		PaddingRight(halfW - 2).
		PaddingTop(halfH - 1).
		PaddingBottom(halfH - 1).
		BorderStyle(lipgloss.RoundedBorder()).
		BorderForeground(lipgloss.Color(ColorGreen)) // TODO: make a light green or yellow like zellij

	block := lipgloss.Place(w, h, lipgloss.Center, lipgloss.Center, terminalStyle.Render(s))

	return block
}

func main() {
	m := model{
		timer: timer.NewWithInterval(WorkPeriod, time.Millisecond),
		keymap: keymap{
			start: key.NewBinding(
				key.WithKeys("s"),
				key.WithHelp("s", "start"),
			),
			stop: key.NewBinding(
				key.WithKeys("s"),
				key.WithHelp("s", "stop"),
			),
			reset: key.NewBinding(
				key.WithKeys("r"),
				key.WithHelp("r", "reset"),
			),
			quit: key.NewBinding(
				key.WithKeys("q", "ctrl+c"),
				key.WithHelp("q", "quit"),
			),
		},
		help: help.New(),
		timings: timings{
			workPeriod: 1,
			restPeriod: 0,
		},
		viewport: viewport{
			Style:     lipgloss.NewStyle(),
			Width:     80,
			Height:    24,
			TextColor: ColorYellow,
			TextStyle: ShadowBlockLarge, // TODO: have this configurable
		},
	}
	m.keymap.start.SetEnabled(false)

	if _, err := tea.NewProgram(m).Run(); err != nil {
		fmt.Println("Uh oh, we encountered an error:", err)
		os.Exit(1)
	}
}

func numToString(num int64, style TextStyle) []string {
	if num < 0 {
		panic("number needs to be positive")
	}

	hundreds := (num / 100) % 10
	tens := (num / 10) % 10
	ones := num % 10

	ltrs := [][]string{}
	if hundreds > 0 {
		ltrs = append(ltrs, blockNums(hundreds, style))
	}

	ltrs = append(ltrs, blockNums(tens, style))
	ltrs = append(ltrs, blockNums(ones, style))

	var numRows int
	switch style {
	case SimpleLineSmall:
		numRows = fonts.SimpleLineSmallHeight
	case ShadowBlockLarge:
		numRows = fonts.ShadowBlockLargeHeight
	case PlainBlockLarge:
		numRows = fonts.PlainBlockLargeHeight
	default:
		numRows = fonts.ShadowBlockLargeHeight
	}

	block := []string{}
	for row := 0; row < numRows+1; row++ {
		s := ""
		for idx := 0; idx < len(ltrs); idx++ {
			s += ltrs[idx][row]
			s += " "
		}
		block = append(block, s)
	}

	return block
}

func blockNums(n int64, style TextStyle) []string {
	if n > 9 {
		panic("provided number was greater than 9. Provide numbers in the range 0-9")
	}

	var font [][]string
	switch style {
	case SimpleLineSmall:
		font = fonts.SimpleLineSmallNumbers
	case ShadowBlockLarge:
		font = fonts.ShadowBlockLargeNumbers
	case PlainBlockLarge:
		font = fonts.PlainBlockLargeNumbers
	default:
		font = fonts.ShadowBlockLargeNumbers
	}

	return font[n]
}

// TODO:
// [x] Block letter
// [x] Format to the center
// [x] add color to the numbers
// [x] add milliseconds in grey normal letter
// [ ] have the real clock time displayed as well
// [ ] configurable font, colours
// [ ] ability to invert colors so yellow background and dark grey text
// [ ] have other fonts
// [ ] have a small tomato?