package main

import (
	"context"
	"fmt"
	"hash/fnv"
	"slices"
	"sort"
	"strings"
	"time"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/charmbracelet/x/ansi"
)

type screen int

const (
	prScreen screen = iota
	dashboardScreen
	threadScreen
)

type pane int

const (
	threadListPane pane = iota
	threadDetailPane
)

type tickMsg time.Time
type pathTickMsg time.Time
type prsLoadedMsg struct {
	prs    []PullRequest
	err    error
	cached bool
}
type detailsLoadedMsg struct {
	owner   string
	repo    string
	number  int
	details PRDetails
	err     error
	cached  bool
}

type App struct {
	service     GitHubService
	owner, repo string
	showAll     bool
	limit       int
	poll        time.Duration

	screen        screen
	prs           []PullRequest
	prIndex       int
	details       PRDetails
	threadIndex   int
	folded        map[string]bool
	focus         pane
	listHidden    bool
	scroll        int
	width, height int
	loading       bool
	err           error
	lastRefresh   time.Time
	pendingZ      bool
	searching     bool
	searchQuery   string
	searchOrigin  int
	helpVisible   bool
	helpScroll    int

	foldResolved           bool
	threadListWidthPercent int
	pathScroll             bool
	pathScrollInterval     time.Duration
	pathScrollStep         int
	threadStatusOrder      []string
	threadWithinStatus     string
	dashboardMode          string
	dashboardReturn        screen
	compactReviews         bool
	readState              *readStateStore
	knownThreads           map[string]bool
	knownComments          map[string]bool
	initializedPRs         map[string]bool
	unreadThreads          map[string]bool
	updatedThreads         map[string]bool
}

type AppSettings struct {
	FoldResolved           bool
	ThreadListWidthPercent int
	PathScroll             bool
	PathScrollInterval     time.Duration
	ThreadStatusOrder      []string
	ThreadWithinStatus     string
	DashboardMode          string
	CompactReviews         bool
	ReadState              *readStateStore
}

func defaultAppSettings() AppSettings {
	return AppSettings{
		FoldResolved:           true,
		ThreadListWidthPercent: 33,
		PathScrollInterval:     350 * time.Millisecond,
		ThreadStatusOrder:      []string{"unresolved", "outdated", "resolved"},
		ThreadWithinStatus:     "file",
		DashboardMode:          "hotkey",
		CompactReviews:         true,
	}
}

func NewApp(service GitHubService, owner, repo string, showAll bool, limit int, poll time.Duration) App {
	return NewAppWithSettings(service, owner, repo, showAll, limit, poll, defaultAppSettings())
}

func NewAppWithSettings(
	service GitHubService,
	owner, repo string,
	showAll bool,
	limit int,
	poll time.Duration,
	settings AppSettings,
) App {
	state := settings.ReadState
	if state == nil {
		state = &readStateStore{Data: make(map[string]readPRState)}
	}
	return App{
		service: service, owner: owner, repo: repo, showAll: showAll, limit: limit, poll: poll,
		folded: make(map[string]bool), loading: true,
		foldResolved: settings.FoldResolved, threadListWidthPercent: settings.ThreadListWidthPercent,
		pathScroll: settings.PathScroll, pathScrollInterval: settings.PathScrollInterval,
		threadStatusOrder:  append([]string(nil), settings.ThreadStatusOrder...),
		threadWithinStatus: settings.ThreadWithinStatus,
		dashboardMode:      settings.DashboardMode, dashboardReturn: prScreen,
		compactReviews: settings.CompactReviews,
		readState:      state,
		knownThreads:   make(map[string]bool), knownComments: make(map[string]bool),
		initializedPRs: make(map[string]bool), unreadThreads: make(map[string]bool),
		updatedThreads: make(map[string]bool),
	}
}

func (m App) Init() tea.Cmd {
	commands := []tea.Cmd{m.loadPRs(true), m.nextTick()}
	if m.pathScroll {
		commands = append(commands, m.nextPathTick())
	}
	return tea.Batch(commands...)
}

func (m App) nextTick() tea.Cmd {
	return tea.Tick(m.poll, func(t time.Time) tea.Msg { return tickMsg(t) })
}

func (m App) nextPathTick() tea.Cmd {
	return tea.Tick(m.pathScrollInterval, func(t time.Time) tea.Msg { return pathTickMsg(t) })
}

func (m App) loadPRs(useCache bool) tea.Cmd {
	commands := []tea.Cmd{m.loadLivePRs()}
	if cache, ok := m.service.(cachedSnapshotService); ok && useCache {
		commands = append([]tea.Cmd{func() tea.Msg {
			prs, err := cache.CachedPullRequests(m.owner, m.repo, m.limit, m.showAll)
			return prsLoadedMsg{prs: prs, err: err, cached: true}
		}}, commands...)
	}
	return tea.Batch(commands...)
}

func (m App) loadLivePRs() tea.Cmd {
	return func() tea.Msg {
		ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
		defer cancel()
		var prs []PullRequest
		var err error
		if live, ok := m.service.(liveGitHubService); ok {
			prs, err = live.LivePullRequests(ctx, m.owner, m.repo, m.limit, m.showAll)
		} else {
			prs, err = m.service.ListPullRequests(ctx, m.owner, m.repo, m.limit, m.showAll)
		}
		return prsLoadedMsg{prs: prs, err: err}
	}
}

func (m App) loadDetails(pr PullRequest, useCache bool) tea.Cmd {
	commands := []tea.Cmd{m.loadLiveDetails(pr)}
	if cache, ok := m.service.(cachedSnapshotService); ok && useCache {
		commands = append([]tea.Cmd{func() tea.Msg {
			details, err := cache.CachedPullRequest(pr.Owner, pr.Repository, pr.Number)
			return detailsLoadedMsg{
				owner: pr.Owner, repo: pr.Repository, number: pr.Number,
				details: details, err: err, cached: true,
			}
		}}, commands...)
	}
	return tea.Batch(commands...)
}

func (m App) loadLiveDetails(pr PullRequest) tea.Cmd {
	return func() tea.Msg {
		ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
		defer cancel()
		var details PRDetails
		var err error
		if live, ok := m.service.(liveGitHubService); ok {
			details, err = live.LivePullRequest(ctx, pr.Owner, pr.Repository, pr.Number)
		} else {
			details, err = m.service.GetPullRequest(ctx, pr.Owner, pr.Repository, pr.Number)
		}
		return detailsLoadedMsg{
			owner: pr.Owner, repo: pr.Repository, number: pr.Number,
			details: details, err: err,
		}
	}
}

func (m App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width, m.height = msg.Width, msg.Height
	case tickMsg:
		if !m.loading {
			m.loading = true
			if (m.screen == dashboardScreen || m.screen == threadScreen) && m.details.Number != 0 {
				return m, tea.Batch(m.loadDetails(m.details.PullRequest, false), m.nextTick())
			}
			return m, tea.Batch(m.loadPRs(false), m.nextTick())
		}
		return m, m.nextTick()
	case pathTickMsg:
		if m.pathScroll && m.screen == threadScreen {
			m.pathScrollStep++
		}
		if m.pathScroll {
			return m, m.nextPathTick()
		}
		return m, nil
	case prsLoadedMsg:
		if m.screen != prScreen || msg.cached && !m.loading {
			return m, nil
		}
		if !msg.cached {
			m.loading = false
		}
		if msg.err != nil {
			if msg.cached {
				return m, nil
			}
			m.err = msg.err
			return m, nil
		}
		selected := ""
		if len(m.prs) > 0 && m.prIndex < len(m.prs) {
			selected = m.prs[m.prIndex].ID
		}
		m.prs = msg.prs
		sort.SliceStable(m.prs, func(i, j int) bool {
			left, right := strings.ToLower(m.prs[i].RepoWithOwner), strings.ToLower(m.prs[j].RepoWithOwner)
			if left != right {
				return left < right
			}
			return m.prs[i].UpdatedAt.After(m.prs[j].UpdatedAt)
		})
		m.prIndex = indexPR(m.prs, selected)
		m.err = nil
		if msg.cached && len(msg.prs) > 0 {
			m.lastRefresh = msg.prs[0].CachedAt
		} else {
			m.lastRefresh = time.Now()
		}
	case detailsLoadedMsg:
		if m.screen != dashboardScreen && m.screen != threadScreen {
			return m, nil
		}
		if msg.cached && !m.loading {
			return m, nil
		}
		if !msg.cached {
			m.loading = false
		}
		if m.details.Number != 0 && (msg.number != m.details.Number ||
			msg.owner != m.details.Owner || msg.repo != m.details.Repository) {
			return m, nil
		}
		if msg.err != nil {
			if msg.cached {
				return m, nil
			}
			m.err = msg.err
			return m, nil
		}
		selected := ""
		anchor := ""
		if m.threadIndex < len(m.details.Threads) {
			selected = m.details.Threads[m.threadIndex].ID
			anchor = m.detailScrollAnchor()
		}
		m.trackThreadUpdates(msg.details)
		sortReviewThreads(msg.details.Threads, m.threadStatusOrder, m.threadWithinStatus)
		m.details = msg.details
		m.threadIndex = indexThread(m.details.Threads, selected)
		if selected != "" && (len(m.details.Threads) == 0 || m.details.Threads[m.threadIndex].ID != selected) {
			m.scroll = 0
		}
		for _, thread := range m.details.Threads {
			if _, set := m.folded[thread.ID]; !set && thread.IsResolved && m.foldResolved {
				m.folded[thread.ID] = true
			}
		}
		if m.screen == dashboardScreen {
			m.scroll = min(m.scroll, m.dashboardMaxScroll())
		} else {
			if anchor != "" {
				m.restoreDetailAnchor(anchor)
			} else {
				m.scroll = min(m.scroll, m.detailMaxScroll())
			}
		}
		m.err = nil
		if msg.cached {
			m.lastRefresh = msg.details.CachedAt
		} else {
			m.lastRefresh = time.Now()
		}
	}

	key, ok := msg.(tea.KeyMsg)
	if !ok {
		return m, nil
	}
	k := key.String()
	if m.helpVisible {
		switch k {
		case "ctrl+c":
			return m, tea.Quit
		case "?", "esc", "q":
			m.helpVisible, m.helpScroll = false, 0
		case "j", "down":
			m.helpScroll = min(m.helpScroll+1, m.helpMaxScroll())
		case "k", "up":
			m.helpScroll = max(0, m.helpScroll-1)
		case "g":
			m.helpScroll = 0
		case "G":
			m.helpScroll = m.helpMaxScroll()
		case "ctrl+d", "pgdown":
			m.helpScroll = min(m.helpScroll+max(3, m.height/2), m.helpMaxScroll())
		case "ctrl+u", "pgup":
			m.helpScroll = max(0, m.helpScroll-max(3, m.height/2))
		}
		return m, nil
	}
	if m.searching {
		switch k {
		case "ctrl+c":
			return m, tea.Quit
		case "esc":
			m.searching, m.searchQuery = false, ""
			m.threadIndex = clamp(m.searchOrigin, 0, len(m.details.Threads)-1)
			m.scroll = 0
		case "enter":
			m.searching = false
		case "up":
			m.moveSearch(-1)
		case "down", "tab":
			m.moveSearch(1)
		case "backspace":
			runes := []rune(m.searchQuery)
			if len(runes) > 0 {
				m.searchQuery = string(runes[:len(runes)-1])
				m.selectBestSearchMatch()
			}
		case "ctrl+u":
			m.searchQuery = ""
			m.threadIndex = clamp(m.searchOrigin, 0, len(m.details.Threads)-1)
			m.scroll = 0
		default:
			if key.Type == tea.KeyRunes || key.Type == tea.KeySpace {
				m.searchQuery += string(key.Runes)
				m.selectBestSearchMatch()
			}
		}
		return m, nil
	}
	if k == "ctrl+c" || k == "q" {
		return m, tea.Quit
	}
	if k == "?" {
		m.helpVisible, m.helpScroll = true, 0
		return m, nil
	}
	if m.pendingZ {
		m.pendingZ = false
		if k == "a" && m.screen == threadScreen && len(m.details.Threads) > 0 {
			thread := m.details.Threads[m.threadIndex]
			m.folded[thread.ID] = !m.folded[thread.ID]
			m.scroll = 0
		}
		return m, nil
	}
	if k == "z" && m.screen == threadScreen {
		m.pendingZ = true
		return m, nil
	}
	switch k {
	case "F":
		if m.screen == threadScreen {
			m.searchQuery = ""
			m.threadIndex = clamp(m.threadIndex, 0, len(m.details.Threads)-1)
		}
	case "/":
		if m.screen == threadScreen {
			m.searching, m.searchQuery, m.searchOrigin = true, "", m.threadIndex
			m.focus, m.listHidden, m.scroll = threadListPane, false, 0
		}
	case "r":
		if m.loading {
			return m, nil
		}
		m.loading = true
		if m.screen == dashboardScreen || m.screen == threadScreen {
			return m, m.loadDetails(m.details.PullRequest, false)
		}
		return m, m.loadPRs(false)
	case "j", "down":
		if m.screen == dashboardScreen {
			m.scrollDashboard(1)
		} else if m.screen == threadScreen && m.focus == threadDetailPane {
			m.scrollDetail(1)
		} else {
			m.move(1)
		}
	case "k", "up":
		if m.screen == dashboardScreen {
			m.scrollDashboard(-1)
		} else if m.screen == threadScreen && m.focus == threadDetailPane {
			m.scrollDetail(-1)
		} else {
			m.move(-1)
		}
	case "g":
		m.toStart()
	case "G":
		m.toEnd()
	case "tab":
		if m.screen == threadScreen {
			m.listHidden = !m.listHidden
			if m.listHidden {
				m.focus = threadDetailPane
			} else {
				m.focus = threadListPane
			}
			m.scroll = 0
		}
	case "ctrl+d", "pgdown":
		m.page(1)
	case "ctrl+u", "pgup":
		m.page(-1)
	case "n":
		if m.screen == threadScreen {
			m.moveToUnread(1)
		}
	case "N":
		if m.screen == threadScreen {
			m.moveToUnread(-1)
		}
	case "d":
		if m.screen == prScreen && len(m.prs) > 0 {
			return m, m.openSelectedPR(dashboardScreen)
		}
		if m.screen == threadScreen {
			m.dashboardReturn, m.screen, m.scroll = threadScreen, dashboardScreen, 0
			return m, nil
		}
	case "l":
		if m.screen == prScreen && len(m.prs) > 0 {
			return m, m.openSelectedPR(m.defaultPRTargetScreen())
		}
		if m.screen == dashboardScreen {
			m.screen, m.scroll, m.focus, m.listHidden = threadScreen, 0, threadListPane, false
			return m, nil
		}
		if m.screen == threadScreen {
			m.focus = threadDetailPane
			m.markCurrentThreadRead()
		}
	case "h":
		if m.screen == threadScreen {
			m.focus = threadListPane
			m.listHidden = false
		}
	case "enter":
		if m.screen == prScreen && len(m.prs) > 0 {
			return m, m.openSelectedPR(m.defaultPRTargetScreen())
		}
		if m.screen == dashboardScreen {
			m.screen, m.scroll, m.focus, m.listHidden = threadScreen, 0, threadListPane, false
			return m, nil
		}
		if m.screen == threadScreen && len(m.details.Threads) > 0 {
			thread := m.details.Threads[m.threadIndex]
			m.folded[thread.ID] = !m.folded[thread.ID]
			m.markCurrentThreadRead()
			m.scroll = 0
		}
	case "b", "esc":
		if m.screen == threadScreen {
			if m.dashboardMode == "intermediate" {
				m.dashboardReturn, m.screen, m.scroll, m.err = prScreen, dashboardScreen, 0, nil
				return m, nil
			}
			m.screen, m.err, m.loading = prScreen, nil, true
			return m, m.loadPRs(false)
		}
		if m.screen == dashboardScreen {
			m.screen, m.scroll, m.err = m.dashboardReturn, 0, nil
			if m.screen == prScreen {
				m.loading = true
				m.searching, m.searchQuery = false, ""
				return m, m.loadPRs(false)
			}
			return m, nil
		}
	}
	return m, nil
}

func (m App) defaultPRTargetScreen() screen {
	if m.dashboardMode == "hotkey" {
		return threadScreen
	}
	return dashboardScreen
}

func (m *App) openSelectedPR(target screen) tea.Cmd {
	m.screen, m.dashboardReturn = target, prScreen
	m.details = PRDetails{PullRequest: m.prs[m.prIndex]}
	m.threadIndex, m.scroll, m.focus, m.listHidden, m.loading, m.err = 0, 0, threadListPane, false, true, nil
	m.searching, m.searchQuery = false, ""
	m.pathScrollStep = 0
	return m.loadDetails(m.details.PullRequest, true)
}

func (m *App) trackThreadUpdates(details PRDetails) {
	if m.knownThreads == nil {
		m.knownThreads = make(map[string]bool)
		m.knownComments = make(map[string]bool)
		m.initializedPRs = make(map[string]bool)
		m.unreadThreads = make(map[string]bool)
	}
	m.updatedThreads = make(map[string]bool)
	prID := details.ID
	if prID == "" {
		prID = fmt.Sprintf("%s#%d", details.RepoWithOwner, details.Number)
	}
	state := m.readState.Data[prID]
	if state.Threads == nil {
		state.Threads = make(map[string]bool)
		state.Comments = make(map[string]bool)
	}
	if !state.Initialized {
		for _, thread := range details.Threads {
			state.Threads[thread.ID] = true
			for _, comment := range thread.Comments {
				state.Comments[comment.ID] = true
			}
		}
		state.Initialized = true
		m.readState.Data[prID] = state
		_ = m.readState.save()
		return
	}
	for _, thread := range details.Threads {
		updated := !state.Threads[thread.ID]
		for _, comment := range thread.Comments {
			if !state.Comments[comment.ID] {
				updated = true
			}
			m.knownComments[comment.ID] = true
		}
		m.knownThreads[thread.ID] = true
		if updated {
			m.unreadThreads[thread.ID] = true
			m.updatedThreads[thread.ID] = true
		}
	}
	m.initializedPRs[prID] = true
}

func (m *App) markCurrentThreadRead() {
	if m.threadIndex >= 0 && m.threadIndex < len(m.details.Threads) {
		thread := m.details.Threads[m.threadIndex]
		delete(m.unreadThreads, thread.ID)
		prID := m.currentPRKey()
		state := m.readState.Data[prID]
		if state.Threads == nil {
			state.Threads = make(map[string]bool)
			state.Comments = make(map[string]bool)
		}
		state.Initialized = true
		state.Threads[thread.ID] = true
		for _, comment := range thread.Comments {
			state.Comments[comment.ID] = true
		}
		m.readState.Data[prID] = state
		_ = m.readState.save()
	}
}

func (m App) currentPRKey() string {
	if m.details.ID != "" {
		return m.details.ID
	}
	return fmt.Sprintf("%s#%d", m.details.RepoWithOwner, m.details.Number)
}

func (m *App) moveToUnread(direction int) {
	count := len(m.details.Threads)
	if count == 0 {
		return
	}
	for offset := 1; offset <= count; offset++ {
		index := (m.threadIndex + direction*offset) % count
		if index < 0 {
			index += count
		}
		if m.unreadThreads[m.details.Threads[index].ID] {
			m.threadIndex, m.scroll = index, 0
			m.markCurrentThreadRead()
			return
		}
	}
}

func (m *App) move(delta int) {
	if m.screen == prScreen {
		m.prIndex = clamp(m.prIndex+delta, 0, len(m.prs)-1)
		return
	}
	if m.searchQuery != "" {
		matches := m.matchingThreadIndices()
		if len(matches) == 0 {
			return
		}
		position := slices.Index(matches, m.threadIndex)
		if position < 0 {
			position = 0
		}
		m.threadIndex = matches[clamp(position+delta, 0, len(matches)-1)]
		m.scroll = 0
		m.markCurrentThreadRead()
		return
	}
	m.threadIndex = clamp(m.threadIndex+delta, 0, len(m.details.Threads)-1)
	m.scroll = 0
	m.markCurrentThreadRead()
}

func (m *App) moveSearch(delta int) {
	matches := m.matchingThreadIndices()
	if len(matches) == 0 {
		return
	}
	position := 0
	for i, index := range matches {
		if index == m.threadIndex {
			position = i
			break
		}
	}
	position = clamp(position+delta, 0, len(matches)-1)
	m.threadIndex = matches[position]
	m.scroll = 0
}

func (m *App) selectBestSearchMatch() {
	matches := m.matchingThreadIndices()
	if len(matches) > 0 {
		m.threadIndex = matches[0]
		m.scroll = 0
	}
}

func (m App) matchingThreadIndices() []int {
	if m.searchQuery == "" {
		indices := make([]int, len(m.details.Threads))
		for i := range m.details.Threads {
			indices[i] = i
		}
		return indices
	}
	type match struct {
		index int
		score int
	}
	filter := parseThreadFilter(m.searchQuery)
	matches := make([]match, 0, len(m.details.Threads))
	for i, thread := range m.details.Threads {
		if filter.status != "" && threadStatus(thread) != filter.status {
			continue
		}
		if filter.updated && !m.updatedThreads[thread.ID] {
			continue
		}
		if filter.author != "" && !threadHasAuthor(thread, filter.author) {
			continue
		}
		if score, ok := fuzzyPathScore(thread.Path, filter.path); ok {
			matches = append(matches, match{index: i, score: score})
		}
	}
	sort.SliceStable(matches, func(i, j int) bool {
		return matches[i].score > matches[j].score
	})
	indices := make([]int, len(matches))
	for i, match := range matches {
		indices[i] = match.index
	}
	return indices
}

type threadFilter struct {
	path    string
	status  string
	author  string
	updated bool
}

func parseThreadFilter(query string) threadFilter {
	var filter threadFilter
	var pathTerms []string
	for _, term := range strings.Fields(query) {
		key, value, found := strings.Cut(term, ":")
		if !found {
			pathTerms = append(pathTerms, term)
			continue
		}
		switch strings.ToLower(key) {
		case "status":
			value = strings.ToLower(value)
			if value == "open" {
				value = "unresolved"
			}
			if value == "unresolved" || value == "outdated" || value == "resolved" {
				filter.status = value
			}
		case "author":
			filter.author = strings.TrimPrefix(strings.ToLower(value), "@")
		case "updated", "new":
			filter.updated = value == "" || value == "1" || strings.EqualFold(value, "true") ||
				strings.EqualFold(value, "yes")
		default:
			pathTerms = append(pathTerms, term)
		}
	}
	filter.path = strings.Join(pathTerms, " ")
	return filter
}

func threadHasAuthor(thread ReviewThread, author string) bool {
	for _, comment := range thread.Comments {
		if strings.Contains(strings.ToLower(comment.Author), author) {
			return true
		}
	}
	return false
}

func sortReviewThreads(threads []ReviewThread, statusOrder []string, withinStatus string) {
	ranks := map[string]int{
		"unresolved": 0,
		"outdated":   1,
		"resolved":   2,
	}
	for rank, status := range statusOrder {
		ranks[status] = rank
	}
	if withinStatus == "" {
		withinStatus = "file"
	}
	sort.SliceStable(threads, func(i, j int) bool {
		left, right := threads[i], threads[j]
		leftRank, rightRank := ranks[threadStatus(left)], ranks[threadStatus(right)]
		if leftRank != rightRank {
			return leftRank < rightRank
		}
		if withinStatus == "timestamp" {
			if less, decided := compareThreadTimestamps(left, right); decided {
				return less
			}
		}
		leftPath, rightPath := strings.ToLower(left.Path), strings.ToLower(right.Path)
		if leftPath != rightPath {
			return leftPath < rightPath
		}
		if left.Line != right.Line {
			return left.Line < right.Line
		}
		if withinStatus != "timestamp" {
			if less, decided := compareThreadTimestamps(left, right); decided {
				return less
			}
		}
		return false
	})
}

func threadStatus(thread ReviewThread) string {
	if thread.IsResolved {
		return "resolved"
	}
	if thread.IsOutdated {
		return "outdated"
	}
	return "unresolved"
}

func threadOpenedAt(thread ReviewThread) time.Time {
	var opened time.Time
	for _, comment := range thread.Comments {
		if comment.CreatedAt.IsZero() || (!opened.IsZero() && !comment.CreatedAt.Before(opened)) {
			continue
		}
		opened = comment.CreatedAt
	}
	return opened
}

func compareThreadTimestamps(left, right ReviewThread) (less, decided bool) {
	leftTime, rightTime := threadOpenedAt(left), threadOpenedAt(right)
	switch {
	case leftTime.IsZero() && rightTime.IsZero():
		return false, false
	case leftTime.IsZero():
		return false, true
	case rightTime.IsZero():
		return true, true
	case !leftTime.Equal(rightTime):
		return leftTime.Before(rightTime), true
	default:
		return false, false
	}
}

func (m *App) toStart() {
	if m.screen == prScreen {
		m.prIndex = 0
	} else if m.screen == dashboardScreen {
		m.scroll = 0
	} else if m.focus == threadDetailPane {
		m.scroll = 0
	} else {
		m.threadIndex, m.scroll = 0, 0
	}
}
func (m *App) toEnd() {
	if m.screen == prScreen {
		m.prIndex = max(0, len(m.prs)-1)
	} else if m.screen == dashboardScreen {
		m.scroll = m.dashboardMaxScroll()
	} else if m.focus == threadDetailPane {
		m.scroll = m.detailMaxScroll()
	} else {
		m.threadIndex, m.scroll = max(0, len(m.details.Threads)-1), 0
	}
}
func (m *App) page(direction int) {
	if m.screen == dashboardScreen {
		m.scrollDashboard(direction * max(3, m.dashboardViewportHeight()/2))
		return
	}
	if m.screen == threadScreen && m.focus == threadDetailPane {
		m.scrollDetail(direction * max(3, m.detailViewportHeight()/2))
		return
	}
	m.move(direction * max(3, m.height/2))
}

func (m *App) scrollDetail(delta int) {
	m.scroll = clamp(m.scroll+delta, 0, m.detailMaxScroll())
}

func (m *App) scrollDashboard(delta int) {
	m.scroll = clamp(m.scroll+delta, 0, m.dashboardMaxScroll())
}

func (m App) dashboardViewportHeight() int {
	return max(1, m.height-2)
}

func (m App) dashboardMaxScroll() int {
	return max(0, len(m.dashboardLines())-m.dashboardViewportHeight())
}

func (m App) detailPaneSize() (int, int) {
	topLines := 3
	if m.details.ThreadsTruncated {
		topLines++
	}
	height := max(3, m.height-topLines-1)
	if m.width < 70 || m.listHidden {
		return max(3, m.width), height
	}
	leftWidth := m.threadListWidth()
	return max(20, m.width-leftWidth-1), height
}

func (m App) threadListWidth() int {
	percent := m.threadListWidthPercent
	if percent == 0 {
		percent = 33
	}
	return clamp(m.width*percent/100, 30, max(30, m.width-20))
}

func (m App) detailViewportHeight() int {
	_, height := m.detailPaneSize()
	return max(1, height-2)
}

func (m App) detailMaxScroll() int {
	width, _ := m.detailPaneSize()
	return max(0, len(m.detailLines(width))-m.detailViewportHeight())
}

func (m App) View() string {
	if m.width == 0 {
		return "Loading…"
	}
	if m.helpVisible {
		return m.viewHelp()
	}
	if m.screen == prScreen {
		return m.viewPRs()
	}
	if m.screen == dashboardScreen {
		return m.viewDashboard()
	}
	return m.viewThreads()
}

type helpBinding struct {
	key    string
	action string
}

func (m App) helpBindings() []helpBinding {
	if m.screen == prScreen {
		openAction := "Open pull request dashboard"
		if m.dashboardMode == "hotkey" {
			openAction = "Open review threads"
		}
		return []helpBinding{
			{"j / ↓", "Next pull request"},
			{"k / ↑", "Previous pull request"},
			{"g / G", "First / last pull request"},
			{"ctrl-d / ctrl-u", "Page down / up"},
			{"enter / l", openAction},
			{"d", "Open pull request dashboard"},
			{"r", "Refresh now"},
			{"?", "Close this help"},
			{"q / ctrl-c", "Quit"},
		}
	}
	if m.screen == dashboardScreen {
		backAction := "Return to pull requests"
		if m.dashboardReturn == threadScreen {
			backAction = "Return to review threads"
		}
		return []helpBinding{
			{"j / ↓", "Scroll description down"},
			{"k / ↑", "Scroll description up"},
			{"g / G", "Top / bottom"},
			{"ctrl-d / ctrl-u", "Page down / up"},
			{"enter / l", "Open review threads"},
			{"b / esc", backAction},
			{"r", "Refresh now"},
			{"?", "Close this help"},
			{"q / ctrl-c", "Quit"},
		}
	}
	backAction := "Return to pull requests"
	if m.dashboardMode == "intermediate" {
		backAction = "Return to PR dashboard"
	}
	bindings := []helpBinding{
		{"h / l", "Focus thread list / detail"},
		{"j / k", "Move or scroll focused pane"},
		{"↓ / ↑", "Move or scroll focused pane"},
		{"g / G", "First / last item"},
		{"ctrl-d / ctrl-u", "Page down / up"},
		{"tab", "Hide / reveal thread list"},
		{"/", "Fuzzy-search file paths and combine status:, author:, and updated:true filters"},
		{"F", "Clear the active thread filter and show every thread"},
		{"n / N", "Next / previous new update"},
		{"d", "Open pull request dashboard"},
		{"enter / za", "Fold / expand thread"},
		{"b / esc", backAction},
		{"r", "Refresh now"},
	}
	for _, item := range writeCapabilities(m.details, m.selectedThread()) {
		state := item.reason
		if item.authorized {
			state = "ready; " + item.reason
		}
		bindings = append(bindings, helpBinding{"write", item.name + ": " + state})
	}
	bindings = append(bindings,
		helpBinding{"?", "Close this help"},
		helpBinding{"q / ctrl-c", "Quit"},
	)
	return bindings
}

func (m App) helpVisibleRows() int {
	return max(1, m.height-5)
}

func (m App) helpMaxScroll() int {
	return max(0, len(m.helpRows(m.helpContentWidth()))-m.helpVisibleRows())
}

func (m App) viewHelp() string {
	contentWidth := m.helpContentWidth()
	rows := m.helpRows(contentWidth)
	visibleRows := m.helpVisibleRows()
	start := clamp(m.helpScroll, 0, max(0, len(rows)-visibleRows))
	end := min(len(rows), start+visibleRows)

	title := "Pull request picker keys"
	if m.screen == dashboardScreen {
		title = "Pull request dashboard keys"
	} else if m.screen == threadScreen {
		title = "Review thread keys"
	}
	lines := []string{titleStyle.Render(title)}
	lines = append(lines, rows[start:end]...)
	if len(rows) > visibleRows {
		lines = append(lines, dimStyle.Render(fmt.Sprintf(
			"%d–%d of %d  •  j/k scroll  •  ?/esc/q close",
			start+1, end, len(rows),
		)))
	} else {
		lines = append(lines, dimStyle.Render("?/esc/q close"))
	}
	for i := range lines {
		lines[i] = ansi.Truncate(lines[i], contentWidth, "")
	}
	popup := paneStyle(true).Width(contentWidth).Render(strings.Join(lines, "\n"))
	return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, popup)
}

func (m App) helpContentWidth() int {
	return max(1, min(70, m.width-4))
}

func (m App) helpRows(contentWidth int) []string {
	keyWidth := min(17, max(8, contentWidth/3))
	actionWidth := max(1, contentWidth-keyWidth-1)
	var rows []string
	for _, binding := range m.helpBindings() {
		wrapped := ansi.Hardwrap(ansi.Wordwrap(binding.action, actionWidth, ""), actionWidth, false)
		actionLines := strings.Split(wrapped, "\n")
		for index, action := range actionLines {
			key := ""
			if index == 0 {
				key = binding.key
			}
			rows = append(rows, titleStyle.Render(pad(key, keyWidth))+" "+action)
		}
	}
	return rows
}

var (
	titleStyle        = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#F0B72F"))
	dimStyle          = lipgloss.NewStyle().Foreground(lipgloss.Color("#777777"))
	activeStyle       = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#FFFFFF")).Background(lipgloss.Color("#3B4261"))
	okStyle           = lipgloss.NewStyle().Foreground(lipgloss.Color("#67C587"))
	warnStyle         = lipgloss.NewStyle().Foreground(lipgloss.Color("#E5C07B"))
	badStyle          = lipgloss.NewStyle().Foreground(lipgloss.Color("#E06C75"))
	paneInactiveColor = lipgloss.Color("#50566F")
	paneActiveColor   = lipgloss.Color("#F0B72F")

	selectedLineBackground     = "\x1b[48;5;24m"
	suggestionRemoveBackground = "\x1b[48;5;52m"
	suggestionAddBackground    = "\x1b[48;5;22m"
	changedRemoveBackground    = "\x1b[48;2;55;0;0m"
	changedAddBackground       = "\x1b[48;2;0;55;0m"
)

func paneStyle(active bool) lipgloss.Style {
	color := paneInactiveColor
	if active {
		color = paneActiveColor
	}
	return lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(color)
}

func (m App) viewPRs() string {
	header := titleStyle.Render("gh-threads")
	if m.owner != "" {
		header += "  " + m.owner + "/" + m.repo
	}
	if m.showAll {
		header += dimStyle.Render("  all open pull requests")
	} else {
		header += dimStyle.Render("  assigned to you")
	}
	lines := []string{header, ""}
	if m.loading && len(m.prs) == 0 {
		lines = append(lines, "Loading open pull requests…")
	} else if len(m.prs) == 0 && m.err == nil {
		lines = append(lines, "No matching assigned pull requests.")
	}
	rows, selectedRow := groupedPRRows(m.prs, m.prIndex)
	available := max(1, m.height-4)
	start := windowStart(selectedRow, len(rows), available)
	for _, row := range rows[start:min(len(rows), start+available)] {
		if row.header {
			lines = append(lines, titleStyle.Render(row.repository))
			continue
		}
		pr := m.prs[row.prIndex]
		draft := ""
		if pr.IsDraft {
			draft = " DRAFT"
		}
		if pr.FromCache {
			draft += " CACHED"
		}
		titleWidth := max(10, m.width-36)
		line := fmt.Sprintf("  #%-5d %-*s  %2d threads%s", pr.Number, titleWidth, truncate(pr.Title, titleWidth), pr.ReviewCount, draft)
		if row.prIndex == m.prIndex {
			line = activeStyle.Render(line)
		}
		lines = append(lines, line)
	}
	footer := "? keys • j/k move • enter dashboard • q quit"
	if m.dashboardMode == "hotkey" {
		footer = "? keys • j/k move • enter threads • d dashboard • q quit"
	}
	return m.frame(lines, footer)
}

type prListRow struct {
	repository string
	prIndex    int
	header     bool
}

func groupedPRRows(prs []PullRequest, selected int) ([]prListRow, int) {
	rows := make([]prListRow, 0, len(prs)*2)
	selectedRow := 0
	lastRepository := ""
	for index, pr := range prs {
		repository := pr.RepoWithOwner
		if repository == "" {
			repository = "(unknown repository)"
		}
		if repository != lastRepository {
			rows = append(rows, prListRow{repository: repository, header: true})
			lastRepository = repository
		}
		if index == selected {
			selectedRow = len(rows)
		}
		rows = append(rows, prListRow{repository: repository, prIndex: index})
	}
	return rows, selectedRow
}

func (m App) viewDashboard() string {
	lines := m.dashboardLines()
	viewportHeight := m.dashboardViewportHeight()
	maxScroll := max(0, len(lines)-viewportHeight)
	scroll := min(m.scroll, maxScroll)
	visible := lines[scroll:min(len(lines), scroll+viewportHeight)]
	return m.frame(visible, "? keys • j/k scroll • enter threads • b back • q quit")
}

func (m App) dashboardLines() []string {
	pr := m.details
	width := max(10, m.width-2)
	draft := ""
	if pr.IsDraft {
		draft = "  " + warnStyle.Render("DRAFT")
	}
	lines := []string{
		titleStyle.Render(fmt.Sprintf("%s #%d", pr.RepoWithOwner, pr.Number)) + draft,
		titleStyle.Render(truncate(pr.Title, width)),
	}
	if pr.FromCache {
		lines = append(lines, warnStyle.Render("OFFLINE CACHE  •  saved "+pr.CachedAt.Local().Format("2006-01-02 15:04")))
	}
	if m.loading && pr.BaseRef == "" {
		return append(lines, "", "Loading pull request details…")
	}

	open, outdated, resolved := threadStatusCounts(pr.Threads)
	created := "unknown"
	if !pr.CreatedAt.IsZero() {
		created = pr.CreatedAt.Local().Format("2006-01-02 15:04")
	}
	updated := "unknown"
	if !pr.UpdatedAt.IsZero() {
		updated = pr.UpdatedAt.Local().Format("2006-01-02 15:04")
	}
	milestone := firstNonEmpty(pr.Milestone, "none")
	labels := "none"
	if len(pr.Labels) > 0 {
		labels = strings.Join(pr.Labels, ", ")
	}
	lines = append(lines,
		"",
		dashboardMetadata("author", authorStyle(pr.Author).Render("@"+pr.Author)),
		dashboardMetadata("branches", pr.HeadRef+" → "+pr.BaseRef),
		dashboardMetadata("review", reviewAndMergeState(pr)),
		dashboardMetadata("checks", coloredState(pr.CheckState)),
		dashboardMetadata("merge state", firstNonEmpty(strings.ToLower(pr.MergeState), "unknown")),
		dashboardMetadata("assignees", handlesText(pr.Assignees)),
		dashboardMetadata("reviewers", reviewersText(pr.Reviewers)),
		dashboardMetadata("labels", labels),
		dashboardMetadata("milestone", milestone),
		dashboardMetadata("activity", fmt.Sprintf(
			"%d commits  •  %d conversation comments", pr.CommitCount, pr.CommentCount,
		)),
		dashboardMetadata("changes", fmt.Sprintf(
			"%s  %s  •  %d files",
			okStyle.Render(fmt.Sprintf("+%d", pr.Additions)),
			badStyle.Render(fmt.Sprintf("-%d", pr.Deletions)),
			pr.ChangedFiles,
		)),
		dashboardMetadata("threads", fmt.Sprintf(
			"%d open  •  %d outdated  •  %d resolved", open, outdated, resolved,
		)),
		dashboardMetadata("requirements", mergeRequirementsText(pr.Requirements)),
		dashboardMetadata("permission", viewerPermissionsText(pr.Permissions)),
		dashboardMetadata("head sha", shortOID(pr.HeadOID)),
		dashboardMetadata("created", created),
		dashboardMetadata("updated", updated),
		dashboardMetadata("url", pr.URL),
	)
	lines = append(lines, "", titleStyle.Render("Write capability gate"), "")
	lines = append(lines, writeCapabilityLines(pr, m.selectedThread())...)
	if pr.ThreadsTruncated {
		lines = append(lines, warnStyle.Render("Thread totals only include the first 100 review threads."))
	}
	lines = append(lines, "", titleStyle.Render("Description"), "")
	if strings.TrimSpace(pr.Body) == "" {
		lines = append(lines, dimStyle.Render("No description provided."))
	} else {
		lines = append(lines, renderCommentMarkdown(pr.Body, width)...)
	}
	lines = append(lines, "", titleStyle.Render(fmt.Sprintf("Checks (%d)", len(pr.Checks))), "")
	if len(pr.Checks) == 0 {
		lines = append(lines, dimStyle.Render("No individual checks reported."))
	}
	for _, check := range pr.Checks {
		line := coloredState(check.State) + "  " + check.Name
		if check.URL != "" {
			line += "  " + dimStyle.Render(check.URL)
		}
		lines = append(lines, line)
		if check.Summary != "" && check.State != "SUCCESS" {
			lines = append(lines, dimStyle.Render("  "+truncate(strings.Join(strings.Fields(check.Summary), " "), width-2)))
		}
		for _, annotation := range check.Annotations {
			location := fmt.Sprintf("%s:%d", annotation.Path, annotation.StartLine)
			lines = append(lines, "  "+coloredState(strings.ToUpper(annotation.Level))+"  "+
				location+"  "+truncate(firstNonEmpty(annotation.Title, annotation.Message), max(10, width-len(location)-8)))
		}
	}
	lines = append(lines, "", titleStyle.Render(fmt.Sprintf("Commit and force-push timeline (%d)", len(pr.Timeline))), "")
	if len(pr.Timeline) == 0 {
		lines = append(lines, dimStyle.Render("No commit timeline events reported."))
	}
	for _, event := range pr.Timeline {
		when := event.CreatedAt.Local().Format("2006-01-02 15:04")
		if event.Kind == "force-push" {
			lines = append(lines, warnStyle.Render("force-push")+"  "+shortOID(event.BeforeOID)+" → "+
				shortOID(event.AfterOID)+"  "+authorStyle(event.Author).Render("@"+event.Author)+"  "+dimStyle.Render(when))
		} else {
			lines = append(lines, shortOID(event.OID)+"  "+truncate(event.Title, max(10, width-35))+
				"  "+authorStyle(event.Author).Render("@"+event.Author)+"  "+dimStyle.Render(when))
		}
	}
	lines = append(lines, "", titleStyle.Render(fmt.Sprintf("Applicable rulesets (%d)", applicableRulesetCount(pr.Rulesets))), "")
	for _, ruleset := range pr.Rulesets {
		if ruleset.Applies {
			lines = append(lines, ruleset.Name+"  "+dimStyle.Render(strings.ToLower(ruleset.Enforcement))+
				"  "+strings.Join(ruleset.RuleTypes, ", "))
		}
	}
	if applicableRulesetCount(pr.Rulesets) == 0 {
		lines = append(lines, dimStyle.Render("No applicable active rulesets reported."))
	}
	if pr.MergeQueue != nil {
		lines = append(lines, dashboardMetadata("merge queue", fmt.Sprintf(
			"%s, position %d", strings.ToLower(pr.MergeQueue.State), pr.MergeQueue.Position,
		)))
	}
	lines = append(lines, "", titleStyle.Render(fmt.Sprintf("Submitted reviews (%d)", len(pr.Reviews))), "")
	if len(pr.Reviews) == 0 {
		lines = append(lines, dimStyle.Render("No submitted reviews."))
	}
	if m.compactReviews {
		lines = append(lines, compactReviewLines(pr.Reviews, width)...)
		if len(pr.Reviews) > 0 {
			lines = append(lines, "")
		}
	} else {
		for _, review := range pr.Reviews {
			header := authorStyle(review.Author).Render("@"+review.Author) + "  " +
				coloredState(review.State)
			if !review.SubmittedAt.IsZero() {
				header += "  " + dimStyle.Render(review.SubmittedAt.Local().Format("2006-01-02 15:04"))
			}
			if review.CommitOID != "" {
				header += "  " + dimStyle.Render(shortOID(review.CommitOID))
			}
			lines = append(lines, header)
			if strings.TrimSpace(review.Body) != "" {
				lines = append(lines, renderCommentMarkdown(review.Body, width)...)
			}
			lines = append(lines, "")
		}
	}
	lines = append(lines, titleStyle.Render(fmt.Sprintf("Conversation (%d)", len(pr.Conversation))), "")
	if len(pr.Conversation) == 0 {
		lines = append(lines, dimStyle.Render("No PR conversation comments."))
	}
	for _, comment := range pr.Conversation {
		header := authorStyle(comment.Author).Render("@" + comment.Author)
		if !comment.CreatedAt.IsZero() {
			header += "  " + dimStyle.Render(comment.CreatedAt.Local().Format("2006-01-02 15:04"))
		}
		lines = append(lines, header)
		lines = append(lines, renderCommentMarkdown(comment.Body, width)...)
		lines = append(lines, "")
	}
	return lines
}

func compactReviewLines(reviews []ReviewSummary, width int) []string {
	if len(reviews) == 0 {
		return nil
	}

	stateCounts := make(map[string]int)
	authorCounts := make(map[string]int)
	for _, review := range reviews {
		stateCounts[review.State]++
		authorCounts[review.Author]++
	}

	states := make([]string, 0, len(stateCounts))
	for state := range stateCounts {
		states = append(states, state)
	}
	sort.Strings(states)
	authors := make([]string, 0, len(authorCounts))
	for author := range authorCounts {
		authors = append(authors, author)
	}
	sort.Slice(authors, func(i, j int) bool {
		if authorCounts[authors[i]] != authorCounts[authors[j]] {
			return authorCounts[authors[i]] > authorCounts[authors[j]]
		}
		return strings.ToLower(authors[i]) < strings.ToLower(authors[j])
	})

	summary := make([]string, 0, len(states)+len(authors))
	for _, state := range states {
		summary = append(summary, coloredState(state)+dimStyle.Render(fmt.Sprintf(" ×%d", stateCounts[state])))
	}
	for _, author := range authors {
		summary = append(summary,
			authorStyle(author).Render("@"+author)+dimStyle.Render(fmt.Sprintf(" ×%d", authorCounts[author])),
		)
	}
	lines := []string{ansi.Truncate(strings.Join(summary, dimStyle.Render("  •  ")), width, "…")}
	for _, review := range reviews {
		if body := compactReviewBody(review.Body, width); body != "" {
			line := authorStyle(review.Author).Render("@"+review.Author) + "  " +
				coloredState(review.State) + dimStyle.Render(" — ") + body
			lines = append(lines, ansi.Truncate(line, width, "…"))
		}
	}
	return lines
}

func compactReviewBody(body string, width int) string {
	if strings.TrimSpace(body) == "" {
		return ""
	}
	rendered := ansi.Strip(strings.Join(renderCommentMarkdown(body, width), " "))
	return strings.Join(strings.Fields(rendered), " ")
}

func dashboardMetadata(label, value string) string {
	return titleStyle.Render(pad(label+":", 13)) + " " + value
}

func threadStatusCounts(threads []ReviewThread) (open, outdated, resolved int) {
	for _, thread := range threads {
		switch threadStatus(thread) {
		case "resolved":
			resolved++
		case "outdated":
			outdated++
		default:
			open++
		}
	}
	return open, outdated, resolved
}

func mergeRequirementsText(requirements MergeRequirements) string {
	var items []string
	if requirements.RequiresApprovals {
		approval := "approvals"
		if requirements.ApprovalsRequired == 1 {
			approval = "approval"
		}
		items = append(items, fmt.Sprintf("%d %s", requirements.ApprovalsRequired, approval))
	}
	if requirements.RequiresCodeOwnerReview {
		items = append(items, "code owner review")
	}
	if requirements.RequiresStatusChecks {
		items = append(items, "status checks")
	}
	if requirements.RequiresStrictChecks {
		items = append(items, "up-to-date branch")
	}
	if requirements.RequiresDeployments {
		item := "deployments"
		if len(requirements.RequiredDeployments) > 0 {
			item += " (" + strings.Join(requirements.RequiredDeployments, ", ") + ")"
		}
		items = append(items, item)
	}
	if requirements.RequiresLinearHistory {
		items = append(items, "linear history")
	}
	if requirements.RequiresSignatures {
		items = append(items, "signed commits")
	}
	if requirements.RequiresMergeQueue {
		items = append(items, "merge queue")
	}
	if requirements.RequiresConversation {
		items = append(items, "resolved conversations")
	}
	if len(items) == 0 {
		return "none reported"
	}
	return strings.Join(items, ", ")
}

func applicableRulesetCount(rulesets []Ruleset) int {
	count := 0
	for _, ruleset := range rulesets {
		if ruleset.Applies {
			count++
		}
	}
	return count
}

type writeCapability struct {
	name, reason string
	authorized   bool
}

func writeCapabilities(pr PRDetails, thread *ReviewThread) []writeCapability {
	if pr.FromCache {
		reason := "offline cached snapshot"
		return []writeCapability{
			{name: "reply", reason: reason}, {name: "resolve", reason: reason},
			{name: "react", reason: reason}, {name: "update branch", reason: reason},
			{name: "auto-merge", reason: reason},
		}
	}
	threadReason := "select a review thread"
	canReply, canResolve := false, false
	if thread != nil {
		canReply = thread.ViewerCanReply
		canResolve = thread.ViewerCanResolve || thread.ViewerCanUnresolve
		threadReason = "GitHub did not grant permission for this thread"
	}
	return []writeCapability{
		capability("reply", canReply, threadReason),
		capability("resolve / unresolve", canResolve, threadReason),
		capability("react", pr.Permissions.CanReact, "GitHub did not grant reaction permission"),
		capability("update branch", pr.Permissions.CanUpdatePR, "GitHub did not grant update permission"),
		capability("auto-merge", pr.Permissions.CanEnableMerge, "auto-merge is unavailable for this PR"),
	}
}

func capability(name string, allowed bool, denied string) writeCapability {
	if allowed {
		return writeCapability{name: name, authorized: true, reason: "authorized; write UI not implemented"}
	}
	return writeCapability{name: name, reason: denied}
}

func writeCapabilityLines(pr PRDetails, thread *ReviewThread) []string {
	var lines []string
	for _, item := range writeCapabilities(pr, thread) {
		marker := badStyle.Render("disabled")
		if item.authorized {
			marker = okStyle.Render("ready")
		}
		lines = append(lines, pad(item.name, 21)+" "+marker+"  "+dimStyle.Render(item.reason))
	}
	return lines
}

func (m App) selectedThread() *ReviewThread {
	if m.threadIndex < 0 || m.threadIndex >= len(m.details.Threads) {
		return nil
	}
	thread := m.details.Threads[m.threadIndex]
	return &thread
}

func viewerPermissionsText(permissions ViewerPermissions) string {
	items := []string{strings.ToLower(firstNonEmpty(permissions.Repository, "unknown"))}
	if permissions.CanUpdatePR {
		items = append(items, "update")
	}
	if permissions.CanResolveAny {
		items = append(items, "resolve")
	}
	if permissions.CanUnresolveAny {
		items = append(items, "unresolve")
	}
	if permissions.CanReplyAny {
		items = append(items, "reply")
	}
	if permissions.CanEnableMerge {
		items = append(items, "auto-merge")
	}
	return strings.Join(items, ", ")
}

func (m App) viewThreads() string {
	pr := m.details
	header := titleStyle.Render(fmt.Sprintf("%s #%d %s", pr.RepoWithOwner, pr.Number, truncate(pr.Title, max(10, m.width-len(pr.RepoWithOwner)-12))))
	meta := fmt.Sprintf("%s → %s  checks: %s  %s", pr.HeadRef, pr.BaseRef, coloredState(pr.CheckState), reviewAndMergeState(pr))
	people := "assignees: " + handlesText(pr.Assignees) + "  reviewers: " + reviewersText(pr.Reviewers)
	top := []string{header, meta, people}
	if pr.FromCache {
		top = append(top, warnStyle.Render(
			"CACHED snapshot  •  saved "+pr.CachedAt.Local().Format("2006-01-02 15:04")+
				"  •  refreshing live data",
		))
	}
	if pr.ThreadsTruncated {
		top = append(top, warnStyle.Render("Showing the first 100 review threads."))
	}

	contentHeight := max(3, m.height-len(top)-1)
	var body string
	if m.width < 70 {
		if m.focus == threadListPane {
			body = m.threadList(max(3, m.width), contentHeight)
		} else {
			body = m.threadDetail(max(3, m.width), contentHeight)
		}
	} else if m.listHidden {
		body = m.threadDetail(m.width, contentHeight)
	} else {
		leftWidth := m.threadListWidth()
		rightWidth := max(20, m.width-leftWidth-1)
		left := m.threadList(leftWidth, contentHeight)
		right := m.threadDetail(rightWidth, contentHeight)
		body = lipgloss.JoinHorizontal(lipgloss.Top, left, " ", right)
	}
	help := "? keys • h/l focus • j/k move/scroll • n/N new • d dashboard • b back • q quit"
	if m.searching {
		help = "path words • status:open • author:name • updated:true • enter apply • esc cancel"
	}
	return m.frame(append(top, body), help)
}

func (m App) threadList(width, height int) string {
	innerWidth := max(1, width-2)
	innerHeight := max(1, height-2)
	matches := m.matchingThreadIndices()
	lines := []string{titleStyle.Render(fmt.Sprintf("Threads (%d/%d)", len(matches), len(m.details.Threads)))}
	if m.searching {
		queryWidth := max(1, innerWidth-len("Filter: ")-1)
		query := ansi.Truncate(m.searchQuery, queryWidth, "…")
		lines = append(lines, titleStyle.Render("Filter: ")+query+"█")
	}
	if m.loading && len(m.details.Threads) == 0 {
		lines = append(lines, "Loading…")
	}
	selectedPosition := 0
	for position, index := range matches {
		if index == m.threadIndex {
			selectedPosition = position
			break
		}
	}
	available := max(1, innerHeight-len(lines))
	start := windowStart(selectedPosition, len(matches), available)
	if len(matches) == 0 && m.searchQuery != "" {
		lines = append(lines, dimStyle.Render("No matching threads."))
	}
	for _, i := range matches[start:min(len(matches), start+available)] {
		thread := m.details.Threads[i]
		icon := "●"
		if thread.IsResolved {
			icon = "✓"
		} else if thread.IsOutdated {
			icon = "○"
		}
		suffix := fmt.Sprintf(":%d · %d", thread.Line, len(thread.Comments))
		if m.unreadThreads[thread.ID] {
			suffix += " " + warnStyle.Render("NEW")
		}
		pathWidth := max(4, innerWidth-lipgloss.Width(suffix)-2)
		path := truncatePath(thread.Path, pathWidth)
		if m.pathScroll {
			path = scrollingPath(thread.Path, pathWidth, m.pathScrollStep)
		}
		line := icon + " " + pad(path, pathWidth) + suffix
		line = ansi.Truncate(line, innerWidth, "")
		if thread.IsResolved {
			line = dimStyle.Render(line)
		}
		if i == m.threadIndex {
			line = activeStyle.Render(pad(line, innerWidth))
		}
		lines = append(lines, line)
	}
	return renderPane(lines, width, height, m.focus == threadListPane)
}

func (m App) threadDetail(width, height int) string {
	if len(m.details.Threads) == 0 {
		return renderPane([]string{"No review threads."}, width, height, m.focus == threadDetailPane)
	}
	lines := m.detailLines(width)
	viewportHeight := max(1, height-2)
	maxScroll := max(0, len(lines)-viewportHeight)
	scroll := min(m.scroll, maxScroll)
	visible := lines[scroll:min(len(lines), scroll+viewportHeight)]
	rendered := make([]string, 0, len(visible))
	innerWidth := max(1, width-2)
	for _, line := range visible {
		railWidth := ansi.StringWidth(line.rail)
		contentWidth := max(1, innerWidth-railWidth)
		var renderedLine string
		if line.suggestionChange != 0 {
			renderedLine = suggestionHighlight(line.fixed, line.text, contentWidth, line.suggestionChange)
		} else {
			renderedLine = ansi.Truncate(line.fixed+line.text, contentWidth, "…")
		}
		renderedLine = line.rail + renderedLine
		if line.selected {
			renderedLine = selectedBackground(renderedLine, innerWidth)
		}
		rendered = append(rendered, renderedLine)
	}
	return renderPane(rendered, width, height, m.focus == threadDetailPane)
}

type detailLine struct {
	text             string
	fixed            string
	rail             string
	selected         bool
	suggestionChange byte
	anchor           string
}

func (m App) detailLines(width int) []detailLine {
	if len(m.details.Threads) == 0 {
		return nil
	}
	thread := m.details.Threads[m.threadIndex]
	status := "open"
	if thread.IsResolved {
		status = "resolved"
	}
	if thread.IsOutdated {
		status += ", outdated"
	}
	if m.unreadThreads[thread.ID] {
		status += ", new updates"
	}
	if len(thread.Comments) > 0 && thread.Comments[0].OriginalCommitOID != "" {
		status += ", snapshot " + shortOID(thread.Comments[0].OriginalCommitOID)
	}
	if pushedAt := latestForcePush(m.details.Timeline); !pushedAt.IsZero() &&
		threadOpenedAt(thread).Before(pushedAt) {
		status += ", predates latest force-push"
	}
	lines := []detailLine{
		{anchor: "header", text: titleStyle.Render(fmt.Sprintf("[%d/%d] %s:%d", m.threadIndex+1, len(m.details.Threads), truncatePath(thread.Path, max(8, width-24)), thread.Line)) + "  " + dimStyle.Render(status)},
	}
	if m.folded[thread.ID] {
		lines = append(lines, detailLine{}, detailLine{text: dimStyle.Render("Thread folded. Press za or enter to expand.")})
	} else {
		if len(thread.Comments) > 0 {
			lines = append(lines, detailLine{})
			startLine, endLine := reviewAnchor(thread)
			for codeIndex, codeLine := range highlightDiff(thread.Path, thread.Comments[0].DiffHunk, startLine, endLine, thread.DiffSide) {
				wrapped := wrapDiffLine(codeLine, max(1, width-2))
				for wrapIndex := range wrapped {
					wrapped[wrapIndex].anchor = fmt.Sprintf("code:%d:%d", codeIndex, wrapIndex)
				}
				lines = append(lines, wrapped...)
			}
		}
		for _, comment := range thread.Comments {
			content := parseCommentBody(comment.Body)
			rail := lipgloss.NewStyle().Foreground(authorColor(comment.Author)).Render("│ ")
			lines = append(lines, detailLine{}, detailLine{
				rail:   rail,
				anchor: "comment:" + comment.ID + ":header",
				text: authorStyle(comment.Author).Render("@"+comment.Author) + " " +
					dimStyle.Render(comment.CreatedAt.Local().Format("2006-01-02 15:04")),
			})
			if content.Prose != "" {
				for lineIndex, commentLine := range renderCommentMarkdown(content.Prose, max(10, width-4)) {
					lines = append(lines, detailLine{
						rail: rail, text: commentLine,
						anchor: fmt.Sprintf("comment:%s:body:%d", comment.ID, lineIndex),
					})
				}
			}
			for suggestionIndex, suggestion := range content.Suggestions {
				removed, added := normalizeSuggestion(reviewedSourceLines(thread, comment), suggestion)
				removedRanges, addedRanges := suggestionChangedRanges(removed, added)
				label := "suggested change"
				if len(content.Suggestions) > 1 {
					label = fmt.Sprintf("suggested change %d/%d", suggestionIndex+1, len(content.Suggestions))
				}
				lines = append(lines, detailLine{rail: rail}, detailLine{rail: rail, text: dimStyle.Render(label)})
				for sourceIndex, source := range removed {
					lines = append(lines, addCommentRail(
						wrapSuggestionLine(
							thread.Path, source, '-', removedRanges[sourceIndex], max(1, width-4),
						), rail,
					)...)
				}
				for sourceIndex, source := range added {
					lines = append(lines, addCommentRail(
						wrapSuggestionLine(
							thread.Path, source, '+', addedRanges[sourceIndex], max(1, width-4),
						), rail,
					)...)
				}
			}
		}
		if thread.IsTruncated {
			lines = append(lines, detailLine{}, detailLine{text: warnStyle.Render("Showing the first 100 comments in this thread.")})
		}
	}
	return lines
}

func latestForcePush(events []TimelineEvent) time.Time {
	var latest time.Time
	for _, event := range events {
		if event.Kind == "force-push" && event.CreatedAt.After(latest) {
			latest = event.CreatedAt
		}
	}
	return latest
}

func (m App) detailScrollAnchor() string {
	width, _ := m.detailPaneSize()
	lines := m.detailLines(width)
	for index := min(m.scroll, len(lines)-1); index >= 0; index-- {
		if lines[index].anchor != "" {
			return lines[index].anchor
		}
	}
	return ""
}

func (m *App) restoreDetailAnchor(anchor string) {
	width, _ := m.detailPaneSize()
	for index, line := range m.detailLines(width) {
		if line.anchor == anchor {
			m.scroll = min(index, m.detailMaxScroll())
			return
		}
	}
	m.scroll = min(m.scroll, m.detailMaxScroll())
}

func wrapDiffLine(line highlightedDiffLine, width int) []detailLine {
	gutterWidth := ansi.StringWidth(line.gutter)
	if gutterWidth == 0 {
		wrapped := ansi.Hardwrap(line.code, width, true)
		parts := strings.Split(wrapped, "\n")
		result := make([]detailLine, 0, len(parts))
		for _, part := range parts {
			result = append(result, detailLine{text: part, selected: line.selected})
		}
		return result
	}

	codeWidth := max(1, width-gutterWidth)
	parts := wrapCodeWithIndent(line.code, codeWidth)
	result := make([]detailLine, 0, len(parts))
	for i, part := range parts {
		gutter := line.gutter
		if i > 0 {
			gutter = strings.Repeat(" ", gutterWidth)
		}
		result = append(result, detailLine{
			text: part, fixed: gutter, selected: line.selected,
		})
	}
	return result
}

func wrapSuggestionLine(path, source string, change byte, changed codeRange, width int) []detailLine {
	marker := badStyle.Render(string(change))
	if change == '+' {
		marker = okStyle.Render(string(change))
	}
	code := highlightedSource(lexerForPath(path), source)
	code = highlightCodeRange(code, changed, change)
	lines := wrapDiffLine(highlightedDiffLine{
		gutter: marker + " ",
		code:   code,
	}, width)
	for i := range lines {
		lines[i].suggestionChange = change
	}
	return lines
}

func highlightCodeRange(code string, changed codeRange, change byte) string {
	if changed.End <= changed.Start {
		return code
	}
	totalWidth := ansi.StringWidth(code)
	start := clamp(changed.Start, 0, totalWidth)
	end := clamp(changed.End, start, totalWidth)
	if end <= start {
		return code
	}

	background := changedRemoveBackground
	if change == '+' {
		background = changedAddBackground
	}
	if background == "" {
		return code
	}
	const reset = "\x1b[0m"
	before := ansi.Cut(code, 0, start)
	middle := ansi.Cut(code, start, end)
	after := ansi.Cut(code, end, totalWidth)
	middle = strings.ReplaceAll(middle, reset, reset+background)
	return before + background + middle + reset + after
}

func addCommentRail(lines []detailLine, rail string) []detailLine {
	for i := range lines {
		lines[i].rail = rail
	}
	return lines
}

func wrapCodeWithIndent(code string, width int) []string {
	if width <= 0 || ansi.StringWidth(code) <= width {
		return []string{code}
	}

	plain := ansi.Strip(code)
	indent := len(plain) - len(strings.TrimLeft(plain, " "))
	totalWidth := ansi.StringWidth(code)
	continuationPrefix := strings.Repeat(" ", indent+2) + dimStyle.Render("↳ ")
	continuationWidth := max(1, width-ansi.StringWidth(continuationPrefix))
	parts := make([]string, 0, totalWidth/width+1)
	offset := 0
	for offset < totalWidth {
		available := width
		prefix := ""
		if offset > 0 {
			available = continuationWidth
			prefix = continuationPrefix
		}
		end := syntaxBreakColumn(plain, offset, available)
		if end <= offset {
			end = min(totalWidth, offset+available)
		}
		parts = append(parts, prefix+ansi.Cut(code, offset, end))
		offset = end
	}
	return parts
}

func syntaxBreakColumn(code string, start, width int) int {
	limit := start + width
	column := 0
	best := -1
	for _, r := range code {
		column += ansi.StringWidth(string(r))
		if column <= start {
			continue
		}
		if column > limit {
			break
		}
		if isCodeBreakpoint(r) {
			best = column
		}
	}
	if best > start {
		return best
	}
	return min(ansi.StringWidth(code), limit)
}

func isCodeBreakpoint(r rune) bool {
	if r == ' ' || r == '\t' {
		return true
	}
	return strings.ContainsRune(",.;:()[]{}+-*/%=<>|&", r)
}

func reviewAnchor(thread ReviewThread) (int, int) {
	if len(thread.Comments) > 0 {
		return commentReviewAnchor(thread, thread.Comments[0])
	}
	return commentReviewAnchor(thread, ReviewComment{})
}

func shortOID(oid string) string {
	if len(oid) <= 7 {
		return oid
	}
	return oid[:7]
}

func selectedBackground(line string, width int) string {
	const reset = "\x1b[0m"
	background := selectedLineBackground
	line = pad(ansi.Truncate(line, width, ""), width)
	if background == "" {
		return line
	}
	line = strings.ReplaceAll(line, reset, reset+background)
	return background + line + reset
}

func suggestionHighlight(gutter, code string, width int, change byte) string {
	background := suggestionRemoveBackground
	if change == '+' {
		background = suggestionAddBackground
	}
	if background == "" {
		return pad(ansi.Truncate(gutter+code, width, ""), width)
	}
	const reset = "\x1b[0m"
	gutter = ansi.Truncate(gutter, width, "")
	gutter = strings.ReplaceAll(gutter, reset, reset+background)
	codeWidth := max(0, width-ansi.StringWidth(gutter))
	code = ansi.Truncate(code, codeWidth, "")
	code = strings.ReplaceAll(code, reset, reset+background)
	content := background + gutter + code + reset
	padding := max(0, width-ansi.StringWidth(gutter)-ansi.StringWidth(code))
	if padding > 0 {
		content += background + strings.Repeat(" ", padding) + reset
	}
	return content
}

var authorPalette = []lipgloss.Color{
	"#61AFEF", "#C678DD", "#56B6C2", "#E5C07B",
	"#E06C75", "#98C379", "#D19A66", "#7FC8FF",
}

func authorStyle(login string) lipgloss.Style {
	return lipgloss.NewStyle().Bold(true).Foreground(authorColor(login))
}

func authorColor(login string) lipgloss.Color {
	hash := fnv.New32a()
	_, _ = hash.Write([]byte(strings.ToLower(login)))
	return authorPalette[int(hash.Sum32())%len(authorPalette)]
}

func (m App) frame(lines []string, help string) string {
	body := strings.Join(lines, "\n")
	status := ""
	if m.err != nil {
		status = badStyle.Render("error: " + truncate(m.err.Error(), max(20, m.width-8)))
	}
	if m.loading {
		status = warnStyle.Render("refreshing…")
	}
	if status == "" && !m.lastRefresh.IsZero() {
		status = dimStyle.Render("updated " + m.lastRefresh.Format("15:04:05"))
	}
	footer := truncate(help, m.width)
	if status != "" {
		footer = truncate(help, max(0, m.width-lipgloss.Width(status)-2)) + "  " + status
	}
	bodyLines := strings.Split(body, "\n")
	if len(bodyLines) > max(0, m.height-1) {
		bodyLines = bodyLines[:max(0, m.height-1)]
	}
	for i := range bodyLines {
		bodyLines[i] = ansi.Truncate(bodyLines[i], m.width, "")
	}
	bodyLines = append(bodyLines, ansi.Truncate(dimStyle.Render(footer), m.width, ""))
	return lipgloss.NewStyle().Width(m.width).Height(m.height).Render(strings.Join(bodyLines, "\n"))
}

func renderPane(lines []string, width, height int, active bool) string {
	innerWidth := max(1, width-2)
	innerHeight := max(1, height-2)
	if len(lines) > innerHeight {
		lines = lines[:innerHeight]
	}
	for i := range lines {
		lines[i] = ansi.Truncate(lines[i], innerWidth, "")
	}
	return paneStyle(active).Width(innerWidth).Height(innerHeight).Render(strings.Join(lines, "\n"))
}

func reviewAndMergeState(pr PRDetails) string {
	switch pr.ReviewDecision {
	case "APPROVED":
		review := okStyle.Render("review: approved")
		open, outdated, _ := threadStatusCounts(pr.Threads)
		if pr.Requirements.RequiresConversation && open+outdated > 0 {
			return review + "  " + warnStyle.Render("merge: unresolved conversations")
		}
		if pr.Requirements.RequiresStatusChecks &&
			(pr.CheckState == "FAILURE" || pr.CheckState == "ERROR") {
			return review + "  " + badStyle.Render("merge: checks failing")
		}
		switch pr.Mergeable {
		case "MERGEABLE":
			return review + "  " + okStyle.Render("merge: ready")
		case "CONFLICTING":
			return review + "  " + badStyle.Render("merge: conflicts")
		default:
			return review + "  " + warnStyle.Render("merge: checking")
		}
	case "CHANGES_REQUESTED":
		return badStyle.Render("review: changes requested")
	case "REVIEW_REQUIRED":
		return warnStyle.Render("review: required")
	default:
		return warnStyle.Render("review: pending")
	}
}

func coloredState(state string) string {
	switch state {
	case "SUCCESS", "EXPECTED", "COMPLETED", "NEUTRAL", "SKIPPED":
		return okStyle.Render(state)
	case "FAILURE", "ERROR", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STALE":
		return badStyle.Render(state)
	default:
		return warnStyle.Render(state)
	}
}

func reviewersText(reviewers []Reviewer) string {
	if len(reviewers) == 0 {
		return "none"
	}
	items := make([]string, 0, len(reviewers))
	for _, reviewer := range reviewers {
		items = append(items,
			authorStyle(reviewer.Login).Render("@"+reviewer.Login)+
				dimStyle.Render(" ("+strings.ToLower(reviewer.State)+")"),
		)
	}
	return strings.Join(items, ", ")
}
func handlesText(items []string) string {
	if len(items) == 0 {
		return "none"
	}
	handles := make([]string, 0, len(items))
	for _, item := range items {
		handles = append(handles, authorStyle(item).Render("@"+item))
	}
	return strings.Join(handles, ", ")
}
func indexPR(items []PullRequest, id string) int {
	for i, item := range items {
		if item.ID == id {
			return i
		}
	}
	return 0
}
func indexThread(items []ReviewThread, id string) int {
	for i, item := range items {
		if item.ID == id {
			return i
		}
	}
	return 0
}
func clamp(value, low, high int) int {
	if high < low {
		return low
	}
	return min(max(value, low), high)
}
func windowStart(index, count, size int) int {
	if count <= size {
		return 0
	}
	return clamp(index-size/2, 0, count-size)
}
func truncate(s string, width int) string {
	if width <= 0 {
		return ""
	}
	return ansi.Truncate(strings.ReplaceAll(s, "\n", " "), width, "…")
}
func truncatePath(path string, width int) string {
	if width <= 0 {
		return ""
	}
	pathWidth := ansi.StringWidth(path)
	if pathWidth <= width {
		return path
	}
	if width == 1 {
		return "…"
	}
	return "…" + ansi.Cut(path, pathWidth-width+1, pathWidth)
}

func scrollingPath(path string, width, step int) string {
	const pauseSteps = 4
	if width <= 0 {
		return ""
	}
	pathWidth := ansi.StringWidth(path)
	if pathWidth <= width {
		return path
	}
	if width == 1 {
		return "…"
	}

	visibleWidth := width - 1
	maxOffset := pathWidth - visibleWidth
	cycle := pauseSteps + maxOffset + pauseSteps
	phase := step % cycle
	offset := 0
	switch {
	case phase < pauseSteps:
		offset = 0
	case phase < pauseSteps+maxOffset:
		offset = phase - pauseSteps
	default:
		offset = maxOffset
	}
	if offset == 0 {
		return ansi.Cut(path, 0, visibleWidth) + "…"
	}
	if offset == maxOffset {
		return "…" + ansi.Cut(path, pathWidth-visibleWidth, pathWidth)
	}
	return "…" + ansi.Cut(path, offset, offset+width-2) + "…"
}

func fuzzyPathScore(path, query string) (int, bool) {
	candidate := []rune(strings.ToLower(path))
	terms := strings.Fields(strings.ToLower(query))
	if len(terms) == 0 {
		return 0, true
	}

	total := 0
	for _, term := range terms {
		score, ok := fuzzyTermScore(candidate, []rune(term))
		if !ok {
			return 0, false
		}
		total += score
	}
	return total, true
}

func fuzzyTermScore(candidate, needle []rune) (int, bool) {
	if start := strings.Index(string(candidate), string(needle)); start >= 0 {
		return 10000 - start*10 - len(candidate), true
	}

	score, candidateIndex, previous := 0, 0, -2
	for _, wanted := range needle {
		found := -1
		for candidateIndex < len(candidate) {
			if candidate[candidateIndex] == wanted {
				found = candidateIndex
				candidateIndex++
				break
			}
			candidateIndex++
		}
		if found < 0 {
			return 0, false
		}
		score += 20
		if found == previous+1 {
			score += 15
		}
		if found == 0 || strings.ContainsRune("/._-", candidate[found-1]) {
			score += 12
		}
		score -= found
		previous = found
	}
	return score - len(candidate), true
}

func pad(s string, width int) string {
	n := width - lipgloss.Width(s)
	if n <= 0 {
		return truncate(s, width)
	}
	return s + strings.Repeat(" ", n)
}
func wrap(text string, width int) string {
	words := strings.Fields(text)
	if len(words) == 0 {
		return ""
	}
	lines, line := []string{}, words[0]
	for _, word := range words[1:] {
		if len([]rune(line))+1+len([]rune(word)) > width {
			lines, line = append(lines, line), word
		} else {
			line += " " + word
		}
	}
	return strings.Join(append(lines, line), "\n")
}