/*
    Copyright (C) 1996-1997  Id Software, Inc.
    Copyright (C) 1997       Greg Lewis

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    See file, 'COPYING', for details.
*/

#include <qbsp/brushbsp.hh>

#include <climits>

#include <common/vectorutils.hh>
#include <qbsp/brush.hh>
#include <qbsp/csg.hh>
#include <qbsp/map.hh>
#include <qbsp/portals.hh>
#include <qbsp/qbsp.hh>
#include <qbsp/tree.hh>

#include <list>
#include <atomic>

#include "tbb/task_group.h"

// if a brush just barely pokes onto the other side,
// let it slide by without chopping
constexpr double PLANESIDE_EPSILON = 0.001;
//0.1

constexpr int PSIDE_FRONT = 1;
constexpr int PSIDE_BACK = 2;
constexpr int PSIDE_BOTH = (PSIDE_FRONT|PSIDE_BACK);
// this gets OR'ed in in the return value of QuickTestBrushToPlanenum if one of the brush sides is on the input plane
constexpr int PSIDE_FACING = 4;

struct bspstats_t {
    std::any leafstats;
    // total number of nodes, includes c_nonvis
    std::atomic<int> c_nodes;
    // number of nodes created by splitting on a side_t which had !visible
    std::atomic<int> c_nonvis;
    // total number of leafs
    std::atomic<int> c_leafs;
};

static twosided<std::unique_ptr<bspbrush_t>> SplitBrush(std::unique_ptr<bspbrush_t> brush, int planenum);

/*
==================
CreateBrushWindings

Currently only used in BrushFromBounds
==================
*/
static void CreateBrushWindings(bspbrush_t *brush)
{
    std::optional<winding_t> w;

    for (int i = 0; i < brush->sides.size(); i++) {
        side_t *side = &brush->sides[i];
        w = BaseWindingForPlane(Face_Plane(side));
        for (int j = 0; j < brush->sides.size() && w; j++) {
            if (i == j)
                continue;
            if (brush->sides[j].bevel)
                continue;
            qplane3d plane = -Face_Plane(&brush->sides[j]);
            w = w->clip(plane, 0, false)[SIDE_FRONT]; // CLIP_EPSILON);
        }

        if (w) {
            side->w = *w;
        } else {
            side->w.clear();
        }
    }

    brush->update_bounds();
}

/*
==================
BrushFromBounds

Creates a new axial brush
==================
*/
std::unique_ptr<bspbrush_t> BrushFromBounds(const aabb3d &bounds)
{
    auto b = std::unique_ptr<bspbrush_t>(new bspbrush_t{});

    b->sides.resize(6);
    for (int i = 0; i < 3; i++)
    {
        {
            qplane3d plane{};
            plane.normal[i] = 1;
            plane.dist = bounds.maxs()[i];

            side_t &side = b->sides[i];
            side.planenum = FindPlane(plane, &side.planeside);
        }

        {
            qplane3d plane{};
            plane.normal[i] = -1;
            plane.dist = -bounds.mins()[i];

            side_t &side = b->sides[3 + i];
            side.planenum = FindPlane(plane, &side.planeside);
        }
    }

    CreateBrushWindings(b.get());

    return b;
}

/*
==================
BrushVolume

==================
*/
static vec_t BrushVolume(const bspbrush_t &brush)
{
    // grab the first valid point as the corner

    bool found = false;
    qvec3d corner;
    for (auto &face : brush.sides) {
        if (face.w.size() > 0) {
            corner = face.w[0];
            found = true;
        }
    }
    if (!found) {
        return 0;
    }

    // make tetrahedrons to all other faces

    vec_t volume = 0;
    for (auto &side : brush.sides) {
        if (!side.w.size()) {
            continue;
        }
        auto plane = Face_Plane(&side);
        vec_t d = -(qv::dot(corner, plane.normal) - plane.dist);
        vec_t area = side.w.area();
        volume += d * area;
    }

    volume /= 3;
    return volume;
}

//========================================================

/*
==============
BoxOnPlaneSide

Returns PSIDE_FRONT, PSIDE_BACK, or PSIDE_BOTH
==============
*/
static int BoxOnPlaneSide(const aabb3d& bounds, const qbsp_plane_t &plane)
{
    // axial planes are easy
    if (static_cast<int>(plane.type) < 3)
    {
        int side = 0;
        if (bounds.maxs()[static_cast<int>(plane.type)] > plane.dist + PLANESIDE_EPSILON)
            side |= PSIDE_FRONT;
        if (bounds.mins()[static_cast<int>(plane.type)] < plane.dist - PLANESIDE_EPSILON)
            side |= PSIDE_BACK;
        return side;
    }

    // create the proper leading and trailing verts for the box
    std::array<qvec3d, 2> corners;
    for (int i = 0; i < 3; i++)
    {
        if (plane.normal[i] < 0)
        {
            corners[0][i] = bounds.mins()[i];
            corners[1][i] = bounds.maxs()[i];
        }
        else
        {
            corners[1][i] = bounds.mins()[i];
            corners[0][i] = bounds.maxs()[i];
        }
    }

    double dist1 = qv::dot(plane.normal, corners[0]) - plane.dist;
    double dist2 = qv::dot(plane.normal, corners[1]) - plane.dist;
    int side = 0;
    if (dist1 >= PLANESIDE_EPSILON)
        side = PSIDE_FRONT;
    if (dist2 < PLANESIDE_EPSILON)
        side |= PSIDE_BACK;

    return side;
}

static int SphereOnPlaneSide(const qvec3d& sphere_origin, double sphere_radius, const qbsp_plane_t &plane)
{
    const double sphere_dist = plane.distAbove(sphere_origin);
    if (sphere_dist > sphere_radius) {
        return PSIDE_FRONT;
    }
    if (sphere_dist < -sphere_radius) {
        return PSIDE_BACK;
    }
    return PSIDE_BOTH;
}

/*
============
QuickTestBrushToPlanenum

Returns PSIDE_BACK, PSIDE_FRONT, PSIDE_BOTH depending on how the brush is split by planenum
============
*/
static int QuickTestBrushToPlanenum(const bspbrush_t &brush, int planenum, int *numsplits)
{
    *numsplits = 0;

    // if the brush actually uses the planenum,
    // we can tell the side for sure
    for (auto& side : brush.sides) {
        int num = side.planenum;
        if (num == planenum && side.planeside == SIDE_FRONT)
            return PSIDE_BACK|PSIDE_FACING;
        if (num == planenum && side.planeside == SIDE_BACK)
            return PSIDE_FRONT|PSIDE_FACING;
    }

    // box on plane side
    const auto lock = std::lock_guard(map_planes_lock);
    auto plane = map.planes[planenum];
    int s = BoxOnPlaneSide(brush.bounds, plane);

    // if both sides, count the visible faces split
    if (s == PSIDE_BOTH)
    {
        *numsplits += 3;
    }

    return s;
}

/*
============
TestBrushToPlanenum

============
*/
static int TestBrushToPlanenum(const bspbrush_t &brush, int planenum, int *numsplits, bool *hintsplit, int *epsilonbrush)
{
    *numsplits = 0;
    *hintsplit = false;

    // if the brush actually uses the planenum,
    // we can tell the side for sure
    for (auto &side : brush.sides) {
        int num = side.planenum;
        if (num == planenum && side.planeside == SIDE_FRONT) {
            return PSIDE_BACK | PSIDE_FACING;
        }
        if (num == planenum && side.planeside == SIDE_BACK) {
            return PSIDE_FRONT | PSIDE_FACING;
        }
    }

    // box on plane side
    qbsp_plane_t plane;
    {
        const auto lock = std::lock_guard(map_planes_lock);
        plane = map.planes[planenum];
    }

    //int s = SphereOnPlaneSide(brush.sphere_origin, brush.sphere_radius, plane);
    int s = BoxOnPlaneSide(brush.bounds, plane);
    if (s != PSIDE_BOTH)
        return s;

    // if both sides, count the visible faces split
    vec_t d_front = 0;
    vec_t d_back = 0;

    for (const side_t &side : brush.sides)
    {
        if (side.onnode)
            continue;		// on node, don't worry about splits
        if (!side.visible)
            continue;		// we don't care about non-visible
        auto &w = side.w;
        if (!w)
            continue;
        int front = 0;
        int back = 0;
        for (auto &point : w)
        {
            const double d = qv::dot(point, plane.normal) - plane.dist;
            if (d > d_front)
                d_front = d;
            if (d < d_back)
                d_back = d;

            if (d > 0.1) // PLANESIDE_EPSILON)
                front = 1;
            if (d < -0.1) // PLANESIDE_EPSILON)
                back = 1;
        }
        if (front && back) {
            if (!(side.get_texinfo().flags.is_hintskip)) {
                (*numsplits)++;
                if (side.get_texinfo().flags.is_hint) {
                    *hintsplit = true;
                }
            }
        }
    }

    if ( (d_front > 0.0 && d_front < 1.0)
        || (d_back < 0.0 && d_back > -1.0) )
        (*epsilonbrush)++;

    return s;
}

//========================================================

/*
================
WindingIsTiny

Returns true if the winding would be crunched out of
existance by the vertex snapping.
================
*/
#define EDGE_LENGTH 0.2
bool WindingIsTiny(const winding_t &w, double size)
{
#if 0
    return w.area() < size;
#else
    int edges = 0;
    for (size_t i = 0; i < w.size(); i++) {
        size_t j = (i + 1) % w.size();
        const qvec3d delta = w[j] - w[i];
        const double len = qv::length(delta);
        if (len > size) {
            if (++edges == 3)
                return false;
        }
    }
    return true;
#endif
}

/*
================
WindingIsHuge

Returns true if the winding still has one of the points
from basewinding for plane
================
*/
bool WindingIsHuge(const winding_t &w)
{
    for (size_t i = 0; i < w.size(); i++) {
        for (size_t  j = 0; j < 3; j++)
            if (fabs(w[i][j]) > options.worldextent.value())
                return true;
    }
    return false;
}

//============================================================================

/*
==================
LeafNode

Creates a leaf node.

Called in parallel.
==================
*/
static void LeafNode(node_t *leafnode, std::vector<std::unique_ptr<bspbrush_t>> brushes, bspstats_t &stats)
{
    leafnode->facelist.clear();
    leafnode->planenum = PLANENUM_LEAF;

    leafnode->contents = options.target_game->create_empty_contents();
    for (auto &brush : brushes) {
        leafnode->contents = options.target_game->combine_contents(leafnode->contents, brush->contents);
    }
    for (auto &brush : brushes) {
        Q_assert(brush->original != nullptr);
        leafnode->original_brushes.push_back(brush->original);
    }

    options.target_game->count_contents_in_stats(leafnode->contents, stats.leafstats);
}

//============================================================

static void CheckPlaneAgainstParents(int pnum, node_t *node)
{
    for (node_t *p = node->parent; p; p = p->parent) {
        if (p->planenum == pnum) {
            Error("Tried parent");
        }
    }
}

static bool CheckPlaneAgainstVolume(int pnum, node_t *node)
{
    auto [front, back] = SplitBrush(node->volume->copy_unique(), pnum);

    bool good = (front && back);

    return good;
}

/*
================
SelectSplitSide

Using a hueristic, choses one of the sides out of the brushlist
to partition the brushes with.
Returns NULL if there are no valid planes to split with..
================
*/
side_t *SelectSplitSide(const std::vector<std::unique_ptr<bspbrush_t>>& brushes, node_t *node)
{
    side_t* bestside = nullptr;
    int bestvalue = -99999;
    int bestsplits = 0;

    // the search order goes: visible-structural, visible-detail,
    // nonvisible-structural, nonvisible-detail.
    // If any valid plane is available in a pass, no further
    // passes will be tried.
    constexpr int numpasses = 4;
    for (int pass = 0 ; pass < numpasses ; pass++) {
        for (auto &brush : brushes) {
            if ( (pass & 1) && !brush->original->contents.is_any_detail(options.target_game) )
                continue;
            if ( !(pass & 1) && brush->original->contents.is_any_detail(options.target_game) )
                continue;
            for (auto &side : brush->sides) {
                if (side.bevel)
                    continue;	// never use a bevel as a spliter
                if (!side.w)
                    continue;	// nothing visible, so it can't split
                if (side.onnode)
                    continue;	// allready a node splitter
                if (side.tested)
                    continue;	// we allready have metrics for this plane
                if (side.get_texinfo().flags.is_hintskip)
                    continue;	// skip surfaces are never chosen
                if ( side.visible ^ (pass<2) )
                    continue;	// only check visible faces on first pass

                int pnum = FindPositivePlane(side.planenum); // always use positive facing plane

                CheckPlaneAgainstParents (pnum, node);

                if (!CheckPlaneAgainstVolume (pnum, node))
                    continue;	// would produce a tiny volume

                int front = 0;
                int back = 0;
                int both = 0;
                int facing = 0;
                int splits = 0;
                int epsilonbrush = 0;
                bool hintsplit = false;

                for (auto &test : brushes)
                {
                    int bsplits;
                    int s = TestBrushToPlanenum(*test, pnum, &bsplits, &hintsplit, &epsilonbrush);

                    splits += bsplits;
                    if (bsplits && (s&PSIDE_FACING) )
                        Error ("PSIDE_FACING with splits");

                    test->testside = s;
                    // if the brush shares this face, don't bother
                    // testing that facenum as a splitter again
                    if (s & PSIDE_FACING)
                    {
                        facing++;
                        for (auto &testside : test->sides) {
                            if (testside.planenum == pnum) {
                                testside.tested = true;
                            }
                        }
                    }
                    if (s & PSIDE_FRONT)
                        front++;
                    if (s & PSIDE_BACK)
                        back++;
                    if (s == PSIDE_BOTH)
                        both++;
                }

                // give a value estimate for using this plane

                int value =  5*facing - 5*splits - abs(front-back);
                //					value =  -5*splits;
                //					value =  5*facing - 5*splits;
                if (static_cast<int>(map.get_plane(pnum).type) < 3)
                    value+=5;		// axial is better
                value -= epsilonbrush*1000;	// avoid!

                // never split a hint side except with another hint
                if (hintsplit && !(side.get_texinfo().flags.is_hint) )
                    value = -9999999;

                // save off the side test so we don't need
                // to recalculate it when we actually seperate
                // the brushes
                if (value > bestvalue) {
                    bestvalue = value;
                    bestside = &side;
                    bestsplits = splits;
                    for (auto &test : brushes) {
                        test->side = test->testside;
                    }
                }
            }
        }

        // if we found a good plane, don't bother trying any
        // other passes
        if (bestside) {
            if (pass > 0)
                node->detail_separator = true;	// not needed for vis
            break;
        }
    }

    //
    // clear all the tested flags we set
    //
    for (auto &brush : brushes) {
        for (auto &side : brush->sides) {
            side.tested = false;
        }
    }

    return bestside;
}

/*
==================
BrushMostlyOnSide

==================
*/
planeside_t BrushMostlyOnSide(const bspbrush_t &brush, const qplane3d &plane)
{
    vec_t max = 0;
    planeside_t side = SIDE_FRONT;
    for (auto &face : brush.sides) {
        for (size_t j = 0; j < face.w.size(); j++) {
            vec_t d = qv::dot(face.w[j], plane.normal) - plane.dist;
            if (d > max) {
                max = d;
                side = SIDE_FRONT;
            }
            if (-d > max) {
                max = -d;
                side = SIDE_BACK;
            }
        }
    }
    return side;
}

/*
================
SplitBrush

Note, it's useful to take/return std::unique_ptr so it can quickly return the
input.

https://github.com/id-Software/Quake-2-Tools/blob/master/bsp/qbsp3/brushbsp.c#L935
================
*/
static twosided<std::unique_ptr<bspbrush_t>> SplitBrush(std::unique_ptr<bspbrush_t> brush, int planenum)
{
    qplane3d split;
    {
        const auto lock = std::lock_guard(map_planes_lock);
        split = map.planes.at(planenum);
    }

    twosided<std::unique_ptr<bspbrush_t>> result;
    
    // check all points
    vec_t d_front = 0;
    vec_t d_back = 0;
    for (auto &face : brush->sides) {
        for (int j = 0; j < face.w.size(); j++) {
            vec_t d = qv::dot(face.w[j], split.normal) - split.dist;
            if (d > 0 && d > d_front)
                d_front = d;
            if (d < 0 && d < d_back)
                d_back = d;
        }
    }
    if (d_front < 0.1) // PLANESIDE_EPSILON)
    { // only on back
        result.back = std::move(brush);
        return result;
    }
    if (d_back > -0.1) // PLANESIDE_EPSILON)
    { // only on front
        result.front = std::move(brush);
        return result;
    }

    // create a new winding from the split plane
    auto w = std::optional<winding_t>{BaseWindingForPlane(split)};
    for (auto &face : brush->sides) {
        if (!w) {
            break;
        }
        auto [frontOpt, backOpt] = w->clip(Face_Plane(&face));
        w = backOpt;
    }

    if (!w || WindingIsTiny(*w)) { // the brush isn't really split
        planeside_t side = BrushMostlyOnSide(*brush, split);
        if (side == SIDE_FRONT)
            result.front = std::move(brush);
        else
            result.back = std::move(brush);
        return result;
    }

    if (WindingIsHuge(*w)) {
        logging::print("WARNING: huge winding\n");
    }

    winding_t midwinding = *w;

    // split it for real

    // start with 2 empty brushes

    for (int i = 0; i < 2; i++) {
        result[i] = std::make_unique<bspbrush_t>();
        result[i]->original = brush->original;
        // fixme-brushbsp: add a bspbrush_t copy constructor to make sure we get all fields
        result[i]->contents = brush->contents;
        result[i]->lmshift = brush->lmshift;
        result[i]->func_areaportal = brush->func_areaportal;
    }

    // split all the current windings

    for (const auto &face : brush->sides) {
        auto cw = face.w.clip(split, 0 /*PLANESIDE_EPSILON*/);
        for (size_t j = 0; j < 2; j++) {
            if (!cw[j])
                continue;
#if 0
			if (WindingIsTiny (cw[j]))
			{
				FreeWinding (cw[j]);
				continue;
			}
#endif

            // add the clipped face to result[j]
            side_t faceCopy = face;
            faceCopy.w = *cw[j];
            
            // fixme-brushbsp: configure any settings on the faceCopy?
            // Q2 does `cs->tested = false;`, why?

            result[j]->sides.push_back(std::move(faceCopy));
        }
    }

    // see if we have valid polygons on both sides

    for (int i = 0; i < 2; i++) {
        result[i]->update_bounds();

        bool bogus = false;
        for (int j = 0; j < 3; j++) {
            if (result[i]->bounds.mins()[j] < -4096 || result[i]->bounds.maxs()[j] > 4096) {
                logging::print("bogus brush after clip\n");
                bogus = true;
                break;
            }
        }

        if (result[i]->sides.size() < 3 || bogus) {
            result[i] = nullptr;
        }
    }

    if (!(result[0] && result[1])) {
        if (!result[0] && !result[1])
            logging::print("split removed brush\n");
        else
            logging::print("split not on both sides\n");
        if (result[0]) {
            result.front = std::move(brush);
        }
        // fixme: use of move here, might move twice. should it be `else`?
        if (result[1]) {
            result.back = std::move(brush);
        }
        return result;
    }

    // add the midwinding to both sides
    for (int i = 0; i < 2; i++) {
        side_t cs{};
        
        const bool brushOnFront = (i == 0);
        
        // for the brush on the front side of the plane, the `midwinding`
        // (the face that is touching the plane) should have a normal opposite the plane's normal
        cs.planenum = FindPlane(brushOnFront ? -split : split, &cs.planeside);
        cs.texinfo = map.skip_texinfo;
        cs.visible = false;
        cs.tested = false;
        cs.onnode = true;
        // fixme-brushbsp: configure any other settings on the face?

        cs.w = brushOnFront ? midwinding.flip() : midwinding;

        result[i]->sides.push_back(std::move(cs));
    }

    {
        vec_t v1;
        int i;

        for (i = 0; i < 2; i++) {
            v1 = BrushVolume(*result[i]);
            if (v1 < 1.0) {
                result[i] = nullptr;
                //			qprintf ("tiny volume after clip\n");
            }
        }
    }

    return result;
}

/*
================
SplitBrushList
================
*/
static std::array<std::vector<std::unique_ptr<bspbrush_t>>, 2> SplitBrushList(std::vector<std::unique_ptr<bspbrush_t>> brushes, const node_t *node)
{
    std::array<std::vector<std::unique_ptr<bspbrush_t>>, 2> result;

    for (auto& brush : brushes) {
        int sides = brush->side;

        if (sides == PSIDE_BOTH) {
            // split into two brushes
            auto [front, back] = SplitBrush(brush->copy_unique(), node->planenum);
            if (front)
            {
                result[0].push_back(std::move(front));
            }
            if (back)
            {
                result[1].push_back(std::move(back));
            }
            continue;
        }

        // if the planenum is actualy a part of the brush
        // find the plane and flag it as used so it won't be tried
        // as a splitter again
        if (sides & PSIDE_FACING) {
            for (auto &side : brush->sides) {
                if (side.planenum == node->planenum) {
                    side.onnode = true;
                }
            }
        }

        if (sides & PSIDE_FRONT) {
            result[0].push_back(std::move(brush));
            continue;
        }
        if (sides & PSIDE_BACK) {
            result[1].push_back(std::move(brush));
            continue;
        }
    }

    return result;
}

/*
==================
BuildTree_r

Called in parallel.
==================
*/
static void BuildTree_r(node_t *node, std::vector<std::unique_ptr<bspbrush_t>> brushes, bspstats_t& stats)
{
    // find the best plane to use as a splitter
    auto *bestside = const_cast<side_t *>(SelectSplitSide(brushes, node));
    if (!bestside) {
        // this is a leaf node
        node->side = nullptr;
        node->planenum = PLANENUM_LEAF;

        stats.c_leafs++;
        LeafNode(node, std::move(brushes), stats);

        return;
    }

    // this is a splitplane node
    stats.c_nodes++;
    if (!bestside->visible) {
        stats.c_nonvis++;
    }

    node->side = bestside;
    node->planenum = FindPositivePlane(bestside->planenum);	// always use front facing

    auto children = SplitBrushList(std::move(brushes), node);

    // allocate children before recursing
    for (int i = 0; i < 2; i++)
    {
        auto* newnode = new node_t{};
        newnode->parent = node;
        node->children[i] = std::unique_ptr<node_t>(newnode);
    }

    auto children_volumes = SplitBrush(node->volume->copy_unique(), node->planenum);
    node->children[0]->volume = std::move(children_volumes[0]);
    node->children[1]->volume = std::move(children_volumes[1]);

    // recursively process children
    tbb::task_group g;
    g.run([&]() { BuildTree_r(node->children[0].get(), std::move(children[0]), stats); });
    g.run([&]() { BuildTree_r(node->children[1].get(), std::move(children[1]), stats); });
    g.wait();
}

/*
==================
BrushBSP
==================
*/
static std::unique_ptr<tree_t> BrushBSP(mapentity_t *entity, std::vector<std::unique_ptr<bspbrush_t>> brushlist)
{
    auto tree = std::unique_ptr<tree_t>(new tree_t{});

    logging::print(logging::flag::PROGRESS, "---- {} ----\n", __func__);

    size_t c_faces = 0;
    size_t c_nonvisfaces = 0;
    size_t c_brushes = 0;
    for (const auto &b : brushlist)
    {
        c_brushes++;

        double volume = BrushVolume(*b);
        if (volume < options.microvolume.value())
        {
            logging::print("WARNING: microbrush");
            // fixme-brushbsp: add entitynum, brushnum in mapbrush_t
//            printf ("WARNING: entity %i, brush %i: microbrush\n",
//                b->original->entitynum, b->original->brushnum);
        }

        for (side_t &side : b->sides)
        {
            if (side.bevel)
                continue;
            if (!side.w)
                continue;
            if (side.onnode)
                continue;
            if (side.visible)
                c_faces++;
            else
                c_nonvisfaces++;
        }

        tree->bounds += b->bounds;
    }

    if (brushlist.empty()) {
        /*
         * We allow an entity to be constructed with no visible brushes
         * (i.e. all clip brushes), but need to construct a simple empty
         * collision hull for the engine. Probably could be done a little
         * smarter, but this works.
         */
        auto headnode = std::unique_ptr<node_t>(new node_t{});
        headnode->bounds = entity->bounds;
        headnode->children[0] = std::unique_ptr<node_t>(new node_t{});
        headnode->children[0]->planenum = PLANENUM_LEAF;
        headnode->children[0]->contents = options.target_game->create_empty_contents();
        headnode->children[0]->parent = headnode.get();
        headnode->children[1] = std::unique_ptr<node_t>(new node_t{});
        headnode->children[1]->planenum = PLANENUM_LEAF;
        headnode->children[1]->contents = options.target_game->create_empty_contents();
        headnode->children[1]->parent = headnode.get();

        tree->bounds = headnode->bounds;
        tree->headnode = std::move(headnode);

        return tree;
    }

    logging::print("{:5} brushes\n", c_brushes);
    logging::print("{:5} visible faces\n", c_faces);
    logging::print("{:5} nonvisible faces\n", c_nonvisfaces);


    auto node = std::unique_ptr<node_t>(new node_t{});

    node->volume = BrushFromBounds(tree->bounds.grow(SIDESPACE));

    tree->headnode = std::move(node);

    bspstats_t stats{};
    stats.leafstats = options.target_game->create_content_stats();
    BuildTree_r(tree->headnode.get(), std::move(brushlist), stats);

    logging::print("{:5} visible nodes\n", stats.c_nodes - stats.c_nonvis);
    logging::print("{:5} nonvis nodes\n", stats.c_nonvis);
    logging::print("{:5} leafs\n", stats.c_leafs);

    return tree;
}

std::unique_ptr<tree_t> BrushBSP(mapentity_t *entity, bool midsplit)
{
    // set the original pointers
    std::vector<std::unique_ptr<bspbrush_t>> brushcopies;
    for (const auto &original : entity->brushes) {
        auto copy = original->copy_unique();
        copy->original = original.get();
        brushcopies.push_back(std::move(copy));
    }

    auto tree = BrushBSP(entity, std::move(brushcopies));

    return tree;
}