1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69

// Copyright 2026 Shota FUJI <pockawoooh@gmail.com>
// SPDX-License-Identifier: MIT

package git

// ringBuffer is a buffer focusing on pushing an item to end and retrieving
// the sorted slice at once, without popping or removing.
//
// As git (git-go) does not have a way to load N commits until commit X, we
// have to read from a tip till we find the commit X in order to retrieve
// commits for "?after=X" query. std has no suitable container for that.
//   - container/list ... Have to remember both ends then call PushBack and
//     Remove.
//   - container/ring ... Has no beggining or end, heavily relies on
//     reassignment / shadowing. From document, it's
//     unclear what'll happen to unused slots.
//
// I just want "a buffer holds last N pushed items." This is a naive implemention
// that solves the problem.
type ringBuffer[T any] struct {
	buffer []T
	size   uint32
	cursor uint32
}

func newRingBuffer[T any](size uint32) ringBuffer[T] {
	return ringBuffer[T]{
		buffer: make([]T, 0, size),
		size:   size,
		cursor: 0,
	}
}

func (r *ringBuffer[T]) push(item T) {
	if uint32(len(r.buffer)) < r.size {
		// Until buffer is filled up, just append an item as usual.
		//
		//   [1|2|3| | | ]
		//    ^
		//
		//   [1|2|3|4| | ]
		//    ^
		r.buffer = append(r.buffer, item)
	} else {
		// When buffer is full, we have to move the cursor and put an item behind
		// the cursor.
		//
		//   [1|2|3|4|5|6]
		//    ^
		//
		//   [7|2|3|4|5|6]
		//      ^
		r.buffer[r.cursor] = item
		r.cursor += 1
		if r.cursor >= r.size {
			r.cursor = 0
		}
	}
}

// toSlice returns sorted slice of last (size) items.
func (r ringBuffer[T]) toSlice() []T {
	s := make([]T, len(r.buffer))
	for i := range len(r.buffer) {
		idx := (uint32(i) + r.cursor) % r.size
		s[i] = r.buffer[idx]
	}
	return s
}