No activity when changing views

[diogorainhalopes]

Hi, I'm new to Go and BubbleTea, so pardon me if what I'm doing wrong is obvious 😅.

I'm trying to just get a second view to work after selecting a file from a generic filepicker but can't get it to work.
I think both Update and View are setup properly, so I don't know what the issue might be. I even tried to remake this with pointers to make sure I wasn't just updating some copies but with no success. If I change the state when initializing the model, the first view that is displayed works fine regardless which one it is.

this is just both `filepicker` and `realtime` examples together as I plan to track changes in files

package main

import (
	"errors"
	"flag"
	"fmt"
	"math/rand"
	"os"
	"strings"
	"time"

	"github.com/charmbracelet/bubbles/filepicker"
	"github.com/charmbracelet/bubbles/spinner"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

var (
	docStyle = lipgloss.NewStyle().Margin(1, 2)
	mainDir  string
)

const (
	fileSelectView sessionState = iota
	logView
)

// A message used to indicate that activity has occurred. In the real world (for
// example, chat) this would contain actual data.
type responseMsg struct{}

type sessionState int

type model struct {
	state        sessionState
	filepicker   filepicker.Model
	selectedFile string
	// rt
	sub       chan struct{} // where we'll receive activity notifications
	responses int           // how many responses we've received
	spinner   spinner.Model
	// other
	quitting bool
	err      error
}

type clearErrorMsg struct{}

func clearErrorAfter(t time.Duration) tea.Cmd {
	return tea.Tick(t, func(_ time.Time) tea.Msg {
		return clearErrorMsg{}
	})
}

// Simulate a process that sends events at an irregular interval in real time.
// In this case, we'll send events on the channel at a random interval between
// 100 to 1000 milliseconds. As a command, Bubble Tea will run this
// asynchronously.
func listenForActivity(sub chan struct{}) tea.Cmd {
	return func() tea.Msg {
		for {
			time.Sleep(time.Millisecond * time.Duration(rand.Int63n(900)+100)) // nolint:gosec
			sub <- struct{}{}
		}
	}
}

// A command that waits for the activity on a channel.
func waitForActivity(sub chan struct{}) tea.Cmd {
	return func() tea.Msg {
		return responseMsg(<-sub)
	}
}

func (m model) Init() tea.Cmd {
	return tea.Batch(
		m.filepicker.Init(),
		m.spinner.Tick,
		listenForActivity(m.sub), // generate activity
		waitForActivity(m.sub),   // wait for activity
	)
	//return m.filepicker.Init()
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	//	var cmd tea.Cmd
	// Make sure these keys always quit
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "q", "esc":
			m.quitting = true
			return m, tea.Quit
		}
	case clearErrorMsg:
		m.err = nil
	}

	// Hand off the message and model to the appropriate update function for the
	// appropriate view based on the current state.
	switch m.state {
	case fileSelectView:
		return updateFilePicker(m, msg)
	case logView:
		return updateLogViewer(m, msg)
	}

	return m, nil
}

func updateFilePicker(m model, msg tea.Msg) (tea.Model, tea.Cmd) {

	var cmd tea.Cmd
	m.filepicker, cmd = m.filepicker.Update(msg)

	// Did the user select a file?
	if didSelect, path := m.filepicker.DidSelectFile(msg); didSelect {
		// Get the path of the selected file.
		m.selectedFile = path
		m.state = logView
	}

	// Did the user select a disabled file?
	// This is only necessary to display an error to the user.
	if didSelect, path := m.filepicker.DidSelectDisabledFile(msg); didSelect {
		// Let's clear the selectedFile and display an error.
		m.err = errors.New(path + " is not valid.")
		m.selectedFile = ""
		return m, tea.Batch(cmd, clearErrorAfter(2*time.Second))
	}

	return m, cmd
}

func updateLogViewer(m model, msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg.(type) {
	case tea.KeyMsg:
		m.quitting = true
		return m, tea.Quit
	case responseMsg:
		m.responses++                    // record external activity
		return m, waitForActivity(m.sub) // wait for next event
	case spinner.TickMsg:
		var cmd tea.Cmd
		m.spinner, cmd = m.spinner.Update(msg)
		return m, cmd
	default:
		return m, nil
	}
}

func (m model) View() string {

	if m.quitting {
		return ""
	}

	var s string
	switch m.state {
	case fileSelectView:
		s = viewFilePicker(m)
	case logView:
		s = viewLogViewer(m)
	}
	return s
}

func viewFilePicker(m model) string {

	var s strings.Builder
	s.WriteString(docStyle.Render("bubblog"))
	s.WriteString("\n  ")
	if m.err != nil {
		s.WriteString(m.filepicker.Styles.DisabledFile.Render(m.err.Error()))
	} else if m.selectedFile == "" {
		s.WriteString("Pick a file:")
	} else {
		s.WriteString("Selected file: " + m.filepicker.Styles.Selected.Render(m.selectedFile))
	}
	s.WriteString("\n\n" + m.filepicker.View() + "\n")
	return s.String()
}

func viewLogViewer(m model) string {
	s := fmt.Sprintf("\n %s Events received: %d\n\n Press any key to exit\n", m.spinner.View(), m.responses)
	if m.quitting {
		s += "\n"
	}
	return s
}

func main() {
	flag.StringVar(&mainDir, "dir", "", "Main log directory")
	flag.Parse()

	fp := filepicker.New()

	if mainDir == "" {
		fp.CurrentDirectory, _ = os.UserHomeDir()
	} else {
		fp.CurrentDirectory = mainDir
	}

	fp.AllowedTypes = []string{".mod", ".sum", ".go", ".txt", ".md"}

	m := model{
		state:      fileSelectView,
		filepicker: fp,
		sub:        make(chan struct{}),
		spinner:    spinner.New(),
	}
	//tea.WithAltScreen()
	p := tea.NewProgram(m)
	if _, err := p.Run(); err != nil {
		fmt.Println("could not start program:", err)
	}
}