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
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90

use crate::ctx::Ctx;

/// Represents the data present in a quad-tree node.
/// May be the base-level repr, or a node with 4 children.
pub enum Quad<A: Default, B: Copy> {
    /// Base cell in grid.
    /// May actually be a chunk of cells for performance.
    Base(A),
    /// Node with 4 children.
    Node(Box<[Node<A, B>;4]>),
    /// Children may be generated from Node.
    Cached,
}

/// Represends a node in a quadtree.
/// Has a depth denoting the number of nodes below it.
/// The base node has a depth of 0
/// Nodes should only be siblings of nodes with the same depth.
/// Data stored inside a quadtree node, including children, are in `data`.
pub struct Node<A: Default, B: Copy> {
    pub depth: usize,
    pub compr: B,
    pub data:  Quad<A, B>,
}

impl<A: Default, B: Copy> Node<A, B> {
    /// Bytes must be of size (2**depth)**2 * 4
    pub fn write_rgba8(
        self,
        ctx: &mut Ctx,
        bytes: &mut [u8],
        depth: usize,
        x: usize,
        y: usize,
    ) -> Self {
        let mut expanded = ctx.expand(self);
        expanded.data = match expanded.data {
            // Base cell in grid.
            Quad::Base(base) => {
                let mut color = ctx.color_base(&base);
                let idx = ((1 << depth) * y + x) * 4;
                bytes[idx..(idx + 4)].swap_with_slice(&mut color);
                Quad::Base(base)
            },
            // Node with 4 children.
            Quad::Node(children) => {
                let size = 1 << expanded.depth;
                let half = size / 2;
                let c = [
                    children[0].write_rgba8(ctx, bytes, depth, x,        y       ),
                    children[1].write_rgba8(ctx, bytes, depth, x + half, y       ),
                    children[2].write_rgba8(ctx, bytes, depth, x,        y + half),
                    children[3].write_rgba8(ctx, bytes, depth, x + half, y + half),
                ];
                todo!()
            },
            // Children may be generated from Node.
            Cached => { unreachable!(); },
        };
        expanded
    }

    /// Creates a new tree from a single base node
    pub fn new_base(base: A, ctx: &mut Ctx) -> Self {
        Node {
            depth: 0,
            compr: ctx.compress_base(&base),
            data:  Quad::Base(base),
        }
    }

    /// Creates a new tree with a single empty base node
    pub fn new_empty(ctx: &mut Ctx) -> Self {
        Self::new_base(Default::default(), ctx)
    }

    pub fn new_cached(compr: B, depth: usize) -> Self {
        Node {
            depth,
            compr,
            data: Quad::Cached,
        }
    }

    /// Creates a new node double the size by centering the current node
    /// on a node double the size.
    pub fn pad_empty(self, ctx: &mut Ctx) -> Self {
        todo!()
    }
}