#include "../ClipperUtils.hpp"
#include "../ExPolygon.hpp"
#include "../Surface.hpp"
#include "../ShortestPath.hpp"

#include "Bridge.hpp"

//#include <utility>
//#include <algorithm>
//
//#include <boost/geometry/algorithms/buffer.hpp>
//#include <boost/geometry/algorithms/intersects.hpp>
//#include <boost/geometry/algorithms/correct.hpp>
//#include <boost/range/algorithm_ext/erase.hpp>
//#include <random>
//namespace mpd = boost::multiprecision::decimal;
namespace Slic3r {
// 为 std::pair<size_t, size_t> 定义哈希函数
//template<>
//struct std::hash<std::pair<size_t, size_t>> {
//    std::size_t operator()(const std::pair<size_t, size_t>& p) const noexcept {
//        return std::hash<size_t>()(p.first) ^ (std::hash<size_t>()(p.second) << 1);
//    }
//};
    Polylines Bridge::fill_surface(const Surface* surface, const FillParams& params)
    {
        Polylines polylines_out;

        //BoundingBox bounding_box = surface->expolygon.contour.bounding_box();
        Points points = surface->expolygon.contour.points;
        Point first = points[0];
        points.push_back(first);
        //Polygon outPolygon = bounding_box.polygon();
        Polygon_t polygon;
        std::vector<Point_t> outerBoundary;
        outerBoundary.reserve(points.size());
        int precision = 1e7;
        for (Point one : points) {
            double x = one.x();
            double y = one.y();
            //double x_result =  x / 1000000.0 + 200;
            //double y_result = y / 1000000.0 + 200;
            //double  stored_x = std::round(x_result * precision) / precision;
            //double  stored_y = std::round(y_result * precision) / precision;
            //Point_t temp = { stored_x ,stored_y };
            Point_t temp = { x ,y };
            outerBoundary.push_back(temp);
        }
        bg::append(polygon.outer(), outerBoundary);

        //std::vector<Point_t> innerBoundary;

        //Polygons inPolygons = surface->expolygon.holes;
        //for (Polygon one : inPolygons) {
        //    Ring innerRing;
        //    innerRing.reserve(one.points.size());
        //    for (Point two : one.points) {
        //        double x = two.x();
        //        double y = two.y();
        //        Point_t temp = { x,y };
        //        innerRing.push_back(temp);
        //    }
        //    polygon.inners().push_back(innerRing);
        //}
       //int inSize = polygon.inners().size();
       // Bridge bridge(polygon, float(scale_(this->overlap - 0.5 * this->spacing)));
        this->polygon = polygon;
        auto abc = float(scale_(this->overlap - 0.5 * this->spacing));
        if (abc < 0) {
            abc = -abc;
        }
        //this->offset = abc/ 1000000.0;
        this->offset = 4000000;
        printTree();
        int size = ringNodes.begin()->second.size();
        //第一个桥接边
       int b_size =  bridges.size();
        BridgeMap bm = bridges[0];
        IdIndex parent(1, 1);
        //遍历
        traverseRing(findNode(bm.from_ii), parent, bm.from, bm.from2, true);
        //outputPaths();
        Point_t last = { bm.from.x(),bm.from.y() };
        path.emplace_back(last);

        for (size_t i = 0; i + 1 < path.size(); ++i) {

            //Point p1 = { (path[i].x()+200)* 1000000.0,(path[i].y()+200) * 1000000.0 };
            //Point p2 = { (path[i + 1].x()+200) * 1000000.0,(path[i + 1].y()+200) * 1000000.0 };
            Point p1 = { path[i].x(),path[i].y()  };
            Point p2 = { path[i + 1].x() ,path[i + 1].y() };
            Polyline line = { p1, p2 };
            polylines_out.push_back(line);
        }

        return polylines_out;
    }

    //void Bridge::_fill_surface_single(const FillParams& params, unsigned int thickness_layers, const std::pair<float, Point>& direction, ExPolygon expolygon, Polylines& polylines_out)
    //{
    //    expolygon.rotate(-direction.first);
    //
    //    this->_min_spacing = scale_(this->spacing);
    //    assert(params.density > 0.0001f && params.density <= 1.f);
    //    this->_line_spacing = coord_t(coordf_t(this->_min_spacing) / params.density);
    //    this->_diagonal_distance = this->_line_spacing * 2;
    //    this->_line_oscillation = this->_line_spacing - this->_min_spacing; // only for Line infill
    //    BoundingBox bounding_box = expolygon.contour.bounding_box();
    //
    //    // define flow spacing according to requested density
    //    if (params.density > 0.9999f && !params.dont_adjust) {
    //        this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size()(0), this->_line_spacing);
    //        this->spacing = unscale<double>(this->_line_spacing);
    //    }
    //    else {
    //        // extend bounding box so that our pattern will be aligned with other layers
    //        // Transform the reference point to the rotated coordinate system.
    //        bounding_box.merge(align_to_grid(
    //            bounding_box.min,
    //            Point(this->_line_spacing, this->_line_spacing),
    //            direction.second.rotated(-direction.first)));
    //    }
    //    Polygon outPolygon = bounding_box.polygon();
    //    Polygon_t polygon;
    //    std::vector<Point_t> outerBoundary;
    //    outerBoundary.reserve(outPolygon.points.size());
    //    for (Point one : outPolygon.points) {
    //        double x = one.x();
    //        double y = one.y();
    //        Point_t temp = { x,y };
    //        outerBoundary.push_back(temp);
    //    }
    //    bg::append(polygon.outer(), outerBoundary);
    //   
    //    //std::vector<Point_t> innerBoundary;
    //   
    //    Polygons inPolygons = expolygon.holes;
    //    for (Polygon one :inPolygons) {
    //        Ring innerRing;
    //        for (Point two: one.points) {
    //            double x = two.x();
    //            double y = two.y();
    //            Point_t temp = { x,y };
    //            innerRing.push_back(temp);
    //        }
    //        polygon.inners().push_back(innerRing);
    //    }
    //   this->polygon = polygon;
    //   this->offset = float(scale_(this->overlap - 0.5 * this->spacing));
    //   printTree();
    //       for (size_t i = 0; i + 1 < path.size(); ++i) {
    //
    //        Point p1 = { path[i].x(),path[i].y()};
    //        Point p2 = { path[i + 1].x(),path[i + 1].y()};
    //        Polyline line = { p1, p2 };
    //        polylines_out.push_back(line);
    //    }
    //}

    /*void Bridge::_fill_surface_single(const FillParams& params, unsigned int thickness_layers, const std::pair<float, Point>& direction, ExPolygon expolygon, Polylines& polylines_out)
    {


        //this->_min_spacing = scale_(this->spacing);
        //assert(params.density > 0.0001f && params.density <= 1.f);
        //this->_line_spacing = coord_t(coordf_t(this->_min_spacing) / params.density);
        //this->_diagonal_distance = this->_line_spacing * 2;
        //this->_line_oscillation = this->_line_spacing - this->_min_spacing; // only for Line infill
        //BoundingBox bounding_box = expolygon.contour.bounding_box();

        //// define flow spacing according to requested density
        ////根据要求的密度定义流间距
        //if (params.density > 0.9999f && !params.dont_adjust) {
        //    this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size()(0), this->_line_spacing);
        //    this->spacing = unscale<double>(this->_line_spacing);
        //}
        //else {
        //    // extend bounding box so that our pattern will be aligned with other layers
        //    // Transform the reference point to the rotated coordinate system.
        //    //扩展边界框，使我们的图案与其他层对齐
        //    //将参考点变换到旋转坐标系。
        //    bounding_box.merge(align_to_grid(
        //        bounding_box.min,
        //        Point(this->_line_spacing, this->_line_spacing),
        //        direction.second.rotated(-direction.first)));
        //}

            BoundingBox bounding_box = expolygon.contour.bounding_box();
            Polygon outPolygon = bounding_box.polygon();
            Polygon_t polygon;
            std::vector<Point_t> outerBoundary;
            outerBoundary.reserve(outPolygon.points.size());
            for (Point one : outPolygon.points) {
                double x = one.x();
                double y = one.y();
                Point_t temp = { x,y };
                outerBoundary.push_back(temp);
            }
            bg::append(polygon.outer(), outerBoundary);

            //std::vector<Point_t> innerBoundary;

            Polygons inPolygons = expolygon.holes;
            for (Polygon one : inPolygons) {
                Ring innerRing;
                innerRing.reserve(one.points.size());
                for (Point two : one.points) {
                    double x = two.x();
                    double y = two.y();
                    Point_t temp = { x,y };
                    innerRing.push_back(temp);
                }
                polygon.inners().push_back(innerRing);
            }
           int inSize = polygon.inners().size();
           // Bridge bridge(polygon, float(scale_(this->overlap - 0.5 * this->spacing)));
            this->polygon = polygon;
            this->offset = float(scale_(this->overlap - 0.5 * this->spacing));
            printTree();
            //outputPaths();

            for (size_t i = 0; i + 1 < path.size(); ++i) {

                Point p1 = { path[i].x(),path[i].y()};
                Point p2 = { path[i + 1].x(),path[i + 1].y()};
                Polyline line = { p1, p2 };
                polylines_out.push_back(line);
            }
    }*/


bool is_point_on_segment(const Point_t& p, const Segment& seg, double tolerance = 1e-6) {
    // 计算点到线段的距离
    double dist = bg::distance(p, seg);

    // 检查距离是否在容差范围内
    if (dist > tolerance) {
        return false;
    }

    // 获取线段端点
    const Point_t& p1 = seg.first;
    const Point_t& p2 = seg.second;

    // 检查点是否在线段的边界框内
    double min_x = std::min(p1.x(), p2.x());
    double max_x = std::max(p1.x(), p2.x());
    double min_y = std::min(p1.y(), p2.y());
    double max_y = std::max(p1.y(), p2.y());

    // 考虑容差
    return (p.x() >= min_x - tolerance) && (p.x() <= max_x + tolerance) &&
        (p.y() >= min_y - tolerance) && (p.y() <= max_y + tolerance);
}

// 计算点到原点的距离平方
double distance_to_origin_sq(const Point_t& p) {
    return bg::get<0>(p) * bg::get<0>(p) + bg::get<1>(p) * bg::get<1>(p);
}

// 找到环中距离原点最近的点作为起点
void reorder_ring_start_point(Ring& ring) {

    // 找到距离原点最近的点
    auto min_it = std::min_element(ring.begin(), ring.end(),
        [](const Point_t& a, const Point_t& b) {
            return distance_to_origin_sq(a) < distance_to_origin_sq(b);
        });

    // 旋转环使最近的点成为起点
    std::rotate(ring.begin(), min_it, ring.end() - 1); // end()-1 保留闭合点

    // 确保环保持闭合
    if (!bg::equals(ring.front(), ring.back())) {
        ring.back() = ring.front();
    }
}



//将节点加入处理节点集合中
RingNode Bridge::formatNode(const size_t id, const size_t index, const Ring& ring, const int orientation) {
    Ring ringNode;
    ringNode.assign(ring.begin(), ring.end());
    RingNode node({ id, index }, ringNode, orientation);
    return node;
}
void Bridge::addNode(RingNode& node) {
    reorder_ring_start_point(node.ring);
    // 检查键是否存在
    const auto it = ringNodes.find(node.id.id);
    if (it != ringNodes.end()) {
        // 键已存在，将新节点添加到对应向量的末尾
        it->second.emplace_back(node);
    }
    else {
        // 键不存在，创建一个新的向量并插入到 map 中
        ringNodes[node.id.id] = { node };
    }
}

void Bridge::removeNode(IdIndex id) {
    auto it = ringNodes.find(id.id);
    if (it != ringNodes.end()) {
        std::vector<RingNode>& nodes = it->second;
        nodes.erase(std::remove_if(nodes.begin(), nodes.end(),
            [id](RingNode x) { return x.id.id == id.id && x.id.index == id.index; }),
            nodes.end());
    }
}

//查找节点
RingNode& Bridge::findNode(const IdIndex ii) {
    const auto it = ringNodes.find(ii.id);
    std::vector<RingNode>& nodes = it->second;
    const auto it1 = std::find_if(nodes.begin(), nodes.end(), [ii](const RingNode& node) {
        return node.id.index == ii.index;
    });
    return *it1;
}


//计算多边形的外边界和内边界
void Bridge::computePolygonBoundaries(const Polygon_t& polygon) {
    // 提取外边界
    boundaries.outerBoundary = bg::exterior_ring(polygon);
    // 获取内边界
    const auto& interiors = bg::interior_rings(polygon);
    for (const auto & inner : interiors) {
        boundaries.innerBoundaries.push_back(inner);
    }
}

// 判断两个环是否相交（不包括包含关系）
bool Bridge::ringsIntersect(const Ring& ring1, const Ring& ring2)
{
    // 首先检查是否相交（包括边界相交）
    if (!bg::intersects(ring1, ring2)) {
        return false;
    }

    // 然后排除包含关系
    bool ring1_inside_ring2 = bg::within(ring1, ring2);
    bool ring2_inside_ring1 = bg::within(ring2, ring1);

    // 如果存在包含关系，则不算作相交
    if (ring1_inside_ring2 || ring2_inside_ring1) {
        return false;
    }

    return true;
}


//获取环偏移后的环（可能为空）
std::vector<Ring> Bridge::offsetRing(const Ring& ring, const double distance) {
    // 将环包装成多边形
    Polygon_t inputPolygon;
    inputPolygon.outer() = ring;
    // 修复几何数据
    bg::correct(inputPolygon);

    // 使用 multi_polygon 作为 buffer 的输出类型
    bg::model::multi_polygon<Polygon_t> result;
    // 使用对称距离策略
    bg::buffer(inputPolygon, result,
        bg::strategy::buffer::distance_symmetric<double>(distance),
        bg::strategy::buffer::side_straight(),
        bg::strategy::buffer::join_round(),
        bg::strategy::buffer::end_round(),
        bg::strategy::buffer::point_circle());
    // 提取偏移后的环
    std::vector<Ring> offsetRing;
    for (const auto& poly : result) {
        offsetRing.emplace_back(poly.outer());
    }
    return offsetRing;
}

// 查找环非邻边的相交点
std::vector<Point_t> Bridge::findNonAdjacentIntersections(const Ring& ring) {
    Polygon_t poly;
    bg::append(poly.outer(), ring);
    std::vector<Point_t> intersections;
    std::vector<bg::model::segment<Point_t>> segments;
    const size_t num_points = bg::num_points(poly.outer());

    // 构建所有边的线段
    for (int i = 0; i < num_points - 1; ++i) {
        segments.emplace_back(poly.outer()[i], poly.outer()[i + 1]);
    }

    // 遍历所有非邻边对
    for (size_t i = 0; i < segments.size(); ++i) {
        for (size_t j = i + 2; j < segments.size(); ++j) {
            if ((i == 0 && j == segments.size() - 1)) continue; // 排除相邻边
            std::vector<Point_t> intersection_points;
            bg::intersection(segments[i], segments[j], intersection_points);

            for (const auto& point : intersection_points) {
                // 检查相交点是否为多边形的顶点
                bool is_vertex = false;
                for (const auto& vertex : polygon.outer()) {
                    if (bg::equals(point, vertex)) {
                        is_vertex = true;
                        break;
                    }
                }
                if (!is_vertex) {
                    intersections.push_back(point);
                }
            }
        }
    }
    return intersections;
}

// 将环拆分成多个环
std::vector<Ring> Bridge::split(const Ring& ring, const std::vector<Point_t>& intersections) {
    std::vector<Ring> rings;
    std::vector<bool> visited(ring.size(), false);
    Ring extendedRing = ring;

    // 插入相交点到环中
    for (const auto& intersection : intersections) {
        for (size_t i = 0; i < ring.size(); ++i) {
            Segment seg(ring[i], ring[(i + 1) % ring.size()]);
            if (bg::within(intersection, seg)) {
                extendedRing.insert(extendedRing.begin() + i + 1, intersection);
                break;
            }
        }
    }

    std::vector<bool> newVisited(extendedRing.size(), false);
    for (size_t i = 0; i < extendedRing.size(); ++i) {
        if (newVisited[i]) continue;

        Ring newRing;
        size_t current = i;
        do {
            newRing.push_back(extendedRing[current]);
            newVisited[current] = true;
            current = (current + 1) % extendedRing.size();
        } while (current != i);

        if (newRing.size() > 2) {
            rings.push_back(newRing);
        }
    }
    return rings;
}


// 在环的指定位置插入点
void insert_point_in_ring(Ring& ring, const Point_t& point, size_t after_index) {
    auto it = ring.begin();
    std::advance(it, after_index + 1);
    ring.insert(it, point);
}

// 找到环上应该插入交点的位置
std::vector<std::pair<size_t, Point_t>> find_insertion_points(const Ring& ring, const std::vector<Point_t>& intersections) {
    std::vector<std::pair<size_t, Point_t>> insertion_points;

    for (const auto& p : intersections) {
        double min_dist = std::numeric_limits<double>::max();
        size_t best_segment = 0;

        for (size_t i = 0; i < ring.size() - 1; ++i) {
            Point_t seg_start = ring[i];
            Point_t seg_end = ring[i + 1];

            // 计算点到线段的距离
            double dist = bg::distance(p, bg::model::segment<Point_t>(seg_start, seg_end));

            if (dist < min_dist) {
                min_dist = dist;
                best_segment = i;
            }
        }

        if (min_dist < 1e-6) { // 使用小的容差值
            insertion_points.emplace_back(best_segment, p);
        }
    }

    // 按插入位置排序，从后往前插入
    std::sort(insertion_points.begin(), insertion_points.end(),
        [](const auto& a, const auto& b) { return a.first > b.first; });

    return insertion_points;
}

// 合并两个环
std::vector<Ring> Bridge::merge(const RingNode& ring1, const RingNode& ring2) {

    // 将环转换为多边形
    Polygon_t poly1, poly2;
    bg::append(poly1.outer(), ring1.ring);
    bg::append(poly2.outer(), ring2.ring);

    bg::correct(poly1); // 确保多边形是有效的
    bg::correct(poly2); // 确保多边形是有效的

    std::vector<Point_t> intersection_points;
    bg::intersection(poly1, poly2, intersection_points); 

    // 将交点插入到两个多边形中
    auto insertions1 = find_insertion_points(poly1.outer(), intersection_points);
    for (const auto& ins : insertions1) {
        insert_point_in_ring(poly1.outer(), ins.second, ins.first);
    }

    auto insertions2 = find_insertion_points(poly2.outer(), intersection_points);
    for (const auto& ins : insertions2) {
        insert_point_in_ring(poly2.outer(), ins.second, ins.first);
    }


    // 计算多边形交、差布尔运算
   /* MultiPolygon mp0;
    bg::intersection(poly1, poly2, mp0);*/

    MultiPolygon mp1;
    bg::difference(poly1, poly2, mp1);

    MultiPolygon mp2;
    bg::difference(poly2,poly1, mp2);

    // 合并所有结果多边形
    MultiPolygon result;
    //result.insert(result.end(), mp0.begin(), mp0.end());
    if (ring1.orientation == -1 && ring2.orientation == 1) {
        result.insert(result.end(), mp1.begin(), mp1.end());
    }
    else if(ring1.orientation == 1 && ring2.orientation == -1){
        result.insert(result.end(), mp2.begin(), mp2.end());
    }
    else {
        result.insert(result.end(), mp1.begin(), mp1.end());
        result.insert(result.end(), mp2.begin(), mp2.end());
    }
    
    std::vector<Ring> allRings;

    for (const auto& poly : result) {
        allRings.emplace_back(poly.outer());
    }

    //for (const auto& poly : result) {
    //    allRings.push_back(poly.outer());
    //    for (const auto& inner : poly.inners()) {
    //        allRings.push_back(inner);
    //    }
    //}

    //// 过滤掉被其他环完全包含的环
    std::vector<Ring> disjointRings;
    for (size_t i = 0; i < allRings.size(); ++i) {
        bool isContained = false;
        for (size_t j = 0; j < allRings.size(); ++j) {
            if (i != j && bg::within(allRings[i], allRings[j])) {
                isContained = true;
                break;
            }
        }
        if (!isContained) {
            disjointRings.push_back(allRings[i]);
        }
    }
    return allRings;
}

//生成环集
void Bridge::generateRings() {
    //获取多边形的外边界和内边界
    computePolygonBoundaries(polygon);

    //外边界
    std::vector<Ring> rings = offsetRing(boundaries.outerBoundary, -offset / 2);
    for (auto& r : rings) {
        RingNode node = formatNode(maxRid++, 1, r, -1);
        nodeHandles.emplace_back(node);
        addNode(node);
    }

    //内边界 偏移
    std::map<IdIndex,Ring> offRings; //存放待偏移的环
    for (auto& inner : boundaries.innerBoundaries) {
        offRings.insert({{maxRid++,1},inner });
    }
    std::vector<RingNode> tempRings;
    for (auto& r : offRings) {
        std::vector<Ring> _rings = offsetRing(r.second, offset / 2);
        if (_rings.size() == 1) {
            RingNode node1 = formatNode(r.first.id, r.first.index + 1, _rings[0], 1);
            if (bg::area(node1.ring) > area_threshold) {
                addNode(node1);
                tempRings.emplace_back(node1);
            }
        }
        else if (_rings.size() > 1) {
            std::vector<IdIndex> id_indices;
            for (auto& r1 : _rings) {
                RingNode node0 = formatNode(++maxRid, 1, r1, 1);
                if (bg::area(node0.ring) > area_threshold) {
                    addNode(node0);
                    tempRings.emplace_back(node0);
                    IdIndex ii(maxRid, 1);
                    id_indices.emplace_back(ii);
                }
            }
            //分裂映射
            offsetMap.insert(std::pair<IdIndex, std::vector<IdIndex>>({ r.first.id,r.first.index }, id_indices));
        }
    }
    nodeHandles.insert(nodeHandles.end(), tempRings.begin(), tempRings.end());
    
    //遍历当前用于判断自/互交的节点集
    while (!nodeHandles.empty()) {  
        std::vector<RingNode> interNodes; //产生互交的节点集
        std::vector<RingNode> nodes; //互交后产生的节点
        for (auto it1 = nodeHandles.begin(); it1 != nodeHandles.end(); ++it1) {
            //互交判断&处理
            auto it2 = std::next(it1);
            for (;it2 != nodeHandles.end(); ++it2) {
                if (ringsIntersect(it1->ring, it2->ring)) {
                    //合并
                    std::vector<Ring> rings = merge(*it1, *it2);
                    std::vector<IdIndex> id_indices;
                    for (const auto& ring2 : rings) {
                        // 外与内  外与外 -> 向内; 内与内 -> 向外
                        const int orientation = (it1->orientation + it2->orientation) <= 0 ? -1 : 1;
                        RingNode node1 = formatNode(++maxRid, 1, ring2, orientation);
                        if (bg::area(node1.ring) > area_threshold) {
                            nodes.emplace_back(node1);
                            addNode(node1);
                            IdIndex _ii(maxRid, 1);
                            id_indices.emplace_back(_ii);
                        }
                    }
                    MergeMap mm(it1->id, it2->id, id_indices);
                    mergeMap.emplace_back(mm);
                    interNodes.emplace_back(*it1);
                    interNodes.emplace_back(*it2);
                    it1++;
                    break;
                }
            }
        }
        //删除互交节点
        for (auto& n : interNodes) {
            nodeHandles.erase(std::remove(nodeHandles.begin(), nodeHandles.end(), n), nodeHandles.end());
        }

        //是否存在互交
        if (!nodes.empty()) {
            for (auto& n : nodes) {
                nodeHandles.emplace_back(n);
            }
        }
        std::vector<RingNode> offsetNodes;
        //偏移
        for (auto& node : nodeHandles) {
            //if (node.orientation == 1) continue;
            std::vector<Ring> ring0 = offsetRing(node.ring, static_cast<double>(node.orientation) * offset);
            if (ring0.size() == 1) {
                RingNode node0 = formatNode(node.id.id, ++node.id.index, ring0[0], node.orientation);
                if (bg::area(node0.ring) > area_threshold) {
                    addNode(node0);
                    offsetNodes.emplace_back(node0);
                }
            }
            else if (ring0.size() > 1) {
                std::vector<IdIndex> id_indices;
                for (auto& r : ring0) {
                    RingNode node0 = formatNode(++maxRid, 1, r, node.orientation);
                    if (bg::area(node0.ring) > area_threshold) {
                        addNode(node0);
                        offsetNodes.emplace_back(node0);
                        IdIndex ii(maxRid, 1);
                        id_indices.emplace_back(ii);
                    }
                }
                //分裂映射
                offsetMap.insert(std::pair<IdIndex, std::vector<IdIndex>>({node.id.id,node.id.index }, id_indices));
            }
        }
        //清空
        nodeHandles.clear();
        if (!offsetNodes.empty()) {
            //重填
            nodeHandles.insert(nodeHandles.end(), offsetNodes.begin(), offsetNodes.end());
        }
    }
}

//形成树
void Bridge::formatTree() {
    //遍历不同环类型的节点集合
    for (auto& ringNode : ringNodes) {
        // 使用反向迭代器进行反序遍历
        std::vector<RingNode>& vec = ringNode.second;
        const auto it0 = ringNode.second.begin();
        if (it0->orientation == 1) { // 向外  倒序
            for (int i = ringNode.second.size() - 1; i > 0; i--) {
                ringNode.second[i].children.emplace_back(ringNode.second[i - 1]);
                ringNode.second[i - 1].parent = &ringNode.second[i];
            }
        }
        else { //向内 正序
            for (int i = 0; i < vec.size() - 1; i++) {
                ringNode.second[i].children.emplace_back(ringNode.second[i + 1]);
                ringNode.second[i + 1].parent = &ringNode.second[i];
            }
        }
    }

    //遍历分裂/合并映射
    for (auto& map : offsetMap) { //偏移产生的分裂
        RingNode& it1 = findNode(map.first);
        for (const auto& ii : map.second) {
            RingNode& it2 = findNode(ii);
            it1.children.emplace_back(it2);
        }
    }
    for (auto& map : mergeMap) { //合并
        RingNode& it1 = findNode(map.ii1);
        RingNode& it2 = findNode(map.ii2);
        for (const auto& ii : map.nodes) {
            RingNode& it = findNode(ii);

            if (it.orientation == -1) { //向内
                //内  外
                if (it1.orientation == -1 && it2.orientation == 1) {
                    it1.parent->children.emplace_back(it);
                    it.parent = it1.parent;
                    IdIndex _ii = it1.id;

                    //将it1从父节点的子节点集中移除
                    it1.parent->children.erase(std::remove_if(it1.parent->children.begin(), it1.parent->children.end(),
                        [_ii](RingNode x) { return x.id.id == _ii.id && x.id.index == _ii.index; }),
                        it1.parent->children.end());
                    //it作为it2子节点的父节点
                    for (auto& c : it2.children) {
                        c.parent = &it;
                    }
                    it.children.insert(it.children.end(), it2.children.begin(), it2.children.end());
                }
                else if (it1.orientation == 1 && it2.orientation == -1) //外 内
                {
                    it2.parent->children.emplace_back(it);
                    it.parent = it2.parent;
                    IdIndex _ii = it2.id;
                    //将it2从父节点的子节点集中移除
                    it2.parent->children.erase(std::remove_if(it2.parent->children.begin(), it2.parent->children.end(),
                        [_ii](RingNode x) { return x.id.id == _ii.id && x.id.index == _ii.index; }),
                        it2.parent->children.end());
                    //it作为it1子节点的父节点
                    for (auto& c : it1.children) {
                        c.parent = &it;
                    }
                    it.children.insert(it.children.end(), it1.children.begin(), it1.children.end());
                }
                else if (it1.orientation == 1 && it2.orientation == 1) { //外  外
                    //it作为it1子节点的父节点
                    for (auto& c : it1.children) {
                        c.parent = &it;
                    }
                    it.children.insert(it.children.end(), it1.children.begin(), it1.children.end());
                    //it作为it2子节点的父节点
                    for (auto& c : it2.children) {
                        c.parent = &it;
                    }
                    it.children.insert(it.children.end(), it2.children.begin(), it2.children.end());
                }
                else if (it1.orientation == -1 && it2.orientation == -1) {// 内  内
                    it1.parent->children.emplace_back(it);
                    //it.parent = it1.parent;
                    IdIndex _ii = it1.id;
                    //将it1从父节点的子节点集中移除
                    it1.parent->children.erase(std::remove_if(it1.parent->children.begin(), it1.parent->children.end(),
                        [_ii](RingNode x) { return x.id.id == _ii.id && x.id.index == _ii.index; }),
                        it1.parent->children.end());

                    it2.parent->children.emplace_back(it);
                    //it.parent = it2.parent;
                    IdIndex _ii2 = it2.id;
                    //将it2从父节点的子节点集中移除
                    it2.parent->children.erase(std::remove_if(it2.parent->children.begin(), it2.parent->children.end(),
                        [_ii2](RingNode x) { return x.id.id == _ii2.id && x.id.index == _ii2.index; }),
                        it2.parent->children.end());
                }
            }
            else { //向外
                //it1.parent = &it;
                //将it1的子节点作为it的子节点
                it.children.insert(it.children.end(), it1.children.begin(), it1.children.end());
                it1.children.clear(); //清空it1的子节点集
                //it2.parent = &it;
                it.children.insert(it.children.end(), it2.children.begin(), it2.children.end());
                it2.children.clear();
            }
 
            RingNode* it_parent = it.parent;
            //判断是否互交
            if (ringsIntersect(it.ring, it_parent->ring)) {
                //合并
                std::vector<Ring> rings = merge(it1, *it1.parent);
                const int orientation = (it1.orientation + it1.parent->orientation) <= 0 ? -1 : 1;
                RingNode node1 = formatNode(++maxRid, 1, rings[0], orientation);
                if (bg::area(node1.ring) > area_threshold) {
                    addNode(node1);

                    findNode(node1.id).children.insert(findNode(node1.id).children.end(), it1.children.begin(), it1.children.end());
                    if (it_parent->parent != nullptr) {
                        IdIndex ii = it_parent->id;
                        it_parent->parent->children.erase(std::remove_if(it_parent->parent->children.begin(), it_parent->parent->children.end(),
                            [ii](RingNode x) { return x.id.id == ii.id && x.id.index == ii.index; }),
                            it_parent->parent->children.end());
                        it_parent->parent->children.emplace_back(node1);
                    }
                }
            }
        }
    }
}

//树遍历
//void Bridge::dfs(RingNode& node, std::unordered_set<std::pair<size_t, size_t>>& visited, size_t& edge) {
//    if (visited.find({ node.id.id, node.id.index }) != visited.end()) {
//        return;
//    }
//    visited.insert({ node.id.id, node.id.index });
//    edge++;
//    // 处理当前节点
//    std::cout << "rId: " << node.id.id << ", rIndex: " << node.id.index
//        << ", orientation: " << node.orientation
//        << ", isHide: " << (node.isHide ? "true" : "false") << std::endl;
//
//    Polygon poly;
//    bg::assign(poly, node.ring);
//    verteies.push_back(convertToSFML(poly, sf::Color::Red));
//
//    // 递归遍历子节点
//    for (auto& child : node.children) {
//        handleBridge(node.id, child.id, child.ring.size(),edge);
//        dfs(findNode(child.id), visited, edge);
//    }
//}
void Bridge::dfs(RingNode& node, std::vector<IdIndex>& visited, size_t& edge) {
    auto& it = std::find_if(visited.begin(), visited.end(), [node](const IdIndex& ii) {
        return ii.id == node.id.id && ii.index == node.id.index;
        });
    if (it != visited.end()) {
        return;
    }
    visited.emplace_back(node.id);
    edge++;
    // 处理当前节点
    std::cout << "rId: " << node.id.id << ", rIndex: " << node.id.index
        << ", orientation: " << node.orientation
        << ", isHide: " << (node.isHide ? "true" : "false") << std::endl;

    Polygon_t poly;
    bg::assign(poly, node.ring);
    //verteies.push_back(convertToSFML(poly, sf::Color::Red));

    // 递归遍历子节点
    for (auto& child : node.children) {
        handleBridge(node.id, child.id, child.ring.size(), edge);
        dfs(findNode(child.id), visited, edge);
    }
}


//找到多边形环第 N 条边的中心点
Point_t Bridge::findCenterPointOnEdge(Ring& ring, size_t N) {

    // 获取第 N 条边的两个端点
    const Point_t start = ring[N];
    const Point_t end = ring[N + 1];
    // 计算中点
    const double mid_x = (start.x() + end.x()) / 2;
    const double mid_y = (start.y() + end.y()) / 2;

    Point_t p(mid_x, mid_y);
    const auto insertPos = ring.begin() + N + 1;
    ring.insert(insertPos, p);

    bg::correct(ring); //调整方向为顺时针
    return p;
}

// 计算点到线段的最近点
Point_t closest_point_on_segment(const Point_t& p, const Point_t& seg_start, const Point_t& seg_end) {
    const double x = bg::get<0>(p);
    const double y = bg::get<1>(p);
    const double x1 = bg::get<0>(seg_start);
    const double y1 = bg::get<1>(seg_start);
    const double x2 = bg::get<0>(seg_end);
    const double y2 = bg::get<1>(seg_end);

    // 线段向量
    const double dx = x2 - x1;
    const double dy = y2 - y1;

    // 如果线段长度为零，返回起点
    if (dx == 0 && dy == 0) {
        return seg_start;
    }

    // 计算投影参数t
    const double t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);

    // 根据t值确定最近点
    if (t <= 0.0) {
        return seg_start;
    }
    else if (t >= 1.0) {
        return seg_end;
    }
    else {
        return Point_t(x1 + t * dx, y1 + t * dy);
    }
}

// 在环的边上查找离给定点最近的点
Point_t find_closest_point_on_ring_edges(Ring& ring, const Point_t& p0) {
    // 验证环是否闭合
    if (ring.size() < 2 || !bg::equals(ring.front(), ring.back())) {
        throw std::runtime_error("Ring is not closed");
    }

    Point_t closest_point;
    double min_distance = std::numeric_limits<double>::max();

    size_t e_index = 0;
    // 遍历环的所有边
    for (size_t i = 0; i < ring.size() - 1; ++i) {
        const Point_t& p1 = ring[i];
        const Point_t& p2 = ring[i + 1];

        // 计算线段上的最近点
        Point_t projected_point = closest_point_on_segment(p0, p1, p2);

        // 计算距离
        double distance = bg::distance(p0, projected_point);

        // 更新最近点
        if (distance < min_distance) {
            min_distance = distance;
            closest_point = projected_point;
            e_index = i;
        }
    }
    //插入
    ring.insert(ring.begin()+e_index+1, closest_point);

    bg::correct(ring); //调整方向为顺时针
    return closest_point;
}

// 找到点所在的边（返回边起点索引）
std::pair<size_t, double> find_edge_containing_point(const Ring& ring, const Point_t& point) {
    for (size_t i = 0; i < ring.size() - 1; ++i) {
        const Point_t& p1 = ring[i];
        const Point_t& p2 = ring[i + 1];

        // 计算点到线段的距离
        double seg_length = bg::distance(p1, p2);
        if (seg_length == 0) continue; // 忽略零长度边

        // 计算点在边上的投影参数t
        double t = ((bg::get<0>(point) - bg::get<0>(p1)) * (bg::get<0>(p2) - bg::get<0>(p1)) +
            (bg::get<1>(point) - bg::get<1>(p1)) * (bg::get<1>(p2) - bg::get<1>(p1))) /
            (seg_length * seg_length);

        // 如果点在当前边上
        if (t >= 0.0 && t <= 1.0) {
            Point_t proj(
                bg::get<0>(p1) + t * (bg::get<0>(p2) - bg::get<0>(p1)),
                bg::get<1>(p1) + t * (bg::get<1>(p2) - bg::get<1>(p1))
            );

            // 检查投影点与实际点的距离是否足够近
            if (bg::distance(point, proj) < 1e-6) {
                return { i, t };
            }
        }
    }
}


Point_t Bridge::find_point_at_distance_clockwise(Ring& ring, const Point_t& start_point, double d)
{
    // 1. 找到起点所在的边
    std::pair<size_t, double> p = find_edge_containing_point(ring, start_point);
    size_t edge_index = p.first;
    double t = p.second;
    // 计算从起点到当前边终点的剩余距离
    const Point_t& p1 = ring[edge_index];
    const Point_t& p2 = ring[(edge_index + 1) % ring.size() ];
    double remaining_on_edge = (1.0 - t) * bg::distance(p1, p2);

    // 3. 如果剩余距离足够
    if (remaining_on_edge >= d) {
        double new_t = t + d / bg::distance(p1, p2);
        Point_t p(bg::get<0>(p1) + new_t * (bg::get<0>(p2) - bg::get<0>(p1)),
            bg::get<1>(p1) + new_t * (bg::get<1>(p2) - bg::get<1>(p1)));
        auto insertPos = ring.begin() + edge_index + 1;
        ring.insert(insertPos, p);
        bg::correct(ring); //调整方向为顺时针
        return p;
    }

    // 4. 否则继续遍历后续边
    double accumulated_distance = remaining_on_edge;
    size_t current_index = (edge_index + 1) % (ring.size() - 1);

    while (accumulated_distance < d) {
        const Point_t& p1 = ring[current_index];
        const Point_t& p2 = ring[(current_index + 1) % (ring.size() - 1)];
        double segment_length = bg::distance(p1, p2);

        if (accumulated_distance + segment_length >= d) {
            double ratio = (d - accumulated_distance) / segment_length;
            //在current_index 插入
            Point_t p(bg::get<0>(p1) + ratio * (bg::get<0>(p2) - bg::get<0>(p1)),
                bg::get<1>(p1) + ratio * (bg::get<1>(p2) - bg::get<1>(p1)));
            auto insertPos = ring.begin() + current_index + 1;
            ring.insert(insertPos, p);
            bg::correct(ring); //调整方向为顺时针
            return p;
        }
        accumulated_distance += segment_length;
        current_index = (current_index + 1) % (ring.size() - 1);
    }
    return Point_t();
}


// 判断点是否在线段内部（非端点）
bool is_point_inside_segment(const Point_t& p, const Segment& seg) {
    double x = bg::get<0>(p);
    double y = bg::get<1>(p);
    double x1 = bg::get<0>(seg.first);
    double y1 = bg::get<1>(seg.first);
    double x2 = bg::get<0>(seg.second);
    double y2 = bg::get<1>(seg.second);

    // 检查点是否在线段的包围盒内
    if ((x < std::min(x1, x2) - 1e-6) || (x > std::max(x1, x2) + 1e-6) ||
        (y < std::min(y1, y2) - 1e-6) || (y > std::max(y1, y2) + 1e-6)) {
        return false;
    }

    // 向量叉积判断共线（可跳过，因为 intersects 已保证相交）
    double cross = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1);
    if (std::abs(cross) > 1e-6) return false;

    return true;
}

// 判断两线段是否在内部相交（排除端点接触）
bool segments_cross(const Segment& seg1, const Segment& seg2) {
    if (!bg::intersects(seg1, seg2)) return false;

    std::vector<Point_t> points;
    bg::intersection(seg1, seg2, points);

    if (points.empty()) return false;

    // 检查交点是否在两条线段的内部
    for (const auto& p : points) {
        if (is_point_inside_segment(p, seg1) && is_point_inside_segment(p, seg2)) {
            return true;
        }
    }
    return false;
}

//在环上寻找长度最大的边索引
size_t Bridge::findLongestEdgeIndex(const Ring& ring) {
    if (ring.size() < 4) {
        throw std::invalid_argument("Ring must have at least 4 points");
    }

    std::vector<size_t> max_indices;
    double max_length = 0.0;
    const size_t n = ring.size();

    // 遍历所有边，收集最大长度边的索引
    for (size_t i = 0; i < n - 1; ++i) {
        const auto& p1 = ring[i];
        const auto& p2 = ring[i + 1];
        const double current_length = bg::distance(p1, p2);

        if (current_length > max_length) {
            max_length = current_length;
            max_indices.clear();
            max_indices.push_back(i);
        }
        else if (current_length == max_length) {
            max_indices.push_back(i);
        }
    }
    isFront = !isFront;
    if (max_indices.size() > 1) {
        sel_edge_index = isFront ? max_indices[0] : max_indices[max_indices.size() - 1];
    }
    else {
        /*std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(1, n);*/

        sel_edge_index = isFront?(max_indices[0] + 1) % (n - 1):(max_indices[0]-1+n)%(n-1);
    }
    return sel_edge_index;
     
}

//判断两个点是否相等
bool equal(Point_t p1, Point_t p2) {
    return p1.x() == p2.x() && p1.y() == p2.y();
}

//在第N条边上进行内外环桥接，并插入桥接点
void Bridge::handleBridge(IdIndex o_ii, IdIndex i_ii,const size_t ring_size, const size_t N)
{
    //随机选择桥接的边
    RingNode& inner = findNode(i_ii);
    RingNode& outer = findNode(o_ii);
    //从内到外
    size_t edge_index = findLongestEdgeIndex(inner.ring);
    Point_t p0 = findCenterPointOnEdge(inner.ring, edge_index);
    Point_t p1 = find_point_at_distance_clockwise(inner.ring, p0, offset);
    Point_t p2 = find_closest_point_on_ring_edges(outer.ring, p0);
    Point_t p3 = find_point_at_distance_clockwise(outer.ring, p2, offset);

    //从外到内
    edge_index = findLongestEdgeIndex(outer.ring);
    Point_t p2_1 = findCenterPointOnEdge(outer.ring, edge_index);
    Point_t p3_1 = find_point_at_distance_clockwise(outer.ring, p2_1, offset);
    Point_t p0_1 = find_closest_point_on_ring_edges(inner.ring, p2_1);
    Point_t p1_1 = find_point_at_distance_clockwise(inner.ring, p0_1, offset);


    //判断环上是否存在桥接
    bool isExist = false;
    for (auto& b : bridges) {
        if (b.to_ii == i_ii) {
            isExist = true;
            break;
        }
    }
    if (isExist) return;

    if (bg::distance(p1, p2) < bg::distance(p1_1, p2_1)) {
        Segment seg1(p2, p1);
        Segment seg2(p3, p0);
        if (bg::intersects(seg1, seg2)) {
            BridgeMap edge(p2, p1, p3, p0, o_ii, i_ii);
            bridges.push_back(edge);
        }
        else {
            BridgeMap edge(p2, p0, p3, p1, o_ii, i_ii);
            bridges.push_back(edge);
        }
    }
    else {
        Segment seg1(p2_1, p1_1);
        Segment seg2(p3_1, p0_1);
        if (bg::intersects(seg1, seg2)) {
            BridgeMap edge(p2_1, p1_1, p3_1, p0_1, o_ii, i_ii);
            bridges.push_back(edge);
        }
        else {
            BridgeMap edge(p2_1, p0_1, p3_1, p1_1, o_ii, i_ii);
            bridges.push_back(edge);
        }
    }

   
}


//输出所有环
void Bridge::printRings() {
    generateRings();
    // 输出环中的点信息
    std::cout << "Points in the ring:" << std::endl;
    for (const auto& map : ringNodes) {
        std::cout << "(" << map.first << std::endl;
        for (const auto& node : map.second) {
            std::cout << "{" << node.id.id << "," << node.id.index << "," << node.orientation << std::endl;
            for (const auto& point : node.ring) {
                std::cout << "(" << bg::get<0>(point) << "," << bg::get<1>(point) << ")";
            }
            std::cout << "}" << std::endl;
        }
        std::cout << ")" << std::endl;
    }
}

//输出树结构
void Bridge::printTree() {
    generateRings();
    formatTree();
    // 用于记录已访问的节点
    //std::unordered_set<std::pair<size_t, size_t>> visited;
    std::vector<IdIndex> visited;
    size_t edge = 1;
    dfs(findNode({ 1,1 }), visited,edge);

}


//点在环上的位置索引
int findPointIndex(const Ring& ring, const Point_t& p0) {
    for (size_t i = 0; i < ring.size(); ++i) {
        if (ring[i].x() == p0.x() && ring[i].y() == p0.y()) {
            return static_cast<int>(i);
        }
    }
    return -1; // 未找到
}

int findIndex(std::vector<Point_t> points, const Point_t& p0) {
    for (int i = 0; i < points.size(); ++i) {
        if (equal(points[i], p0)){
            return static_cast<int>(i);
        }
    }
    return -1; // 未找到
}



//递归遍历环
void Bridge::traverseRing(
    RingNode& node,
    IdIndex parent,
    Point_t& start,
    Point_t& end,
    bool isOutermostLayer
) {
    //得到start点在环ring上的索引位置
    int size = node.ring.size();
    int s_index = findPointIndex(node.ring, start);
    int e_index = findPointIndex(node.ring, end);
    std::vector<Point_t> c_points;
    std::vector<Point_t> cc_points;
    std::vector<Point_t> points;
    for (int i = s_index; !equal(node.ring[i], end); i = (i + 1) % size) {
        c_points.emplace_back(node.ring[i]);
    }
    c_points.emplace_back(end);
    for (int i = s_index; !equal(node.ring[i], end); i = (i - 1 + size) % size) {
        cc_points.emplace_back(node.ring[i]);
    }
    cc_points.emplace_back(end);

    if (cc_points.size() > c_points.size()) {
        points.assign(cc_points.begin(), cc_points.end());
    }
    else
    {
        points.assign(c_points.begin(), c_points.end());
    }
    int index = 0;
    do {
        //转换成SFML 顶点
       /* path.emplace_back(sf::Vertex(
            sf::Vector2f(static_cast<float>(points[index].x()),
                static_cast<float>(points[index].y())),
            sf::Color::Red
        ));*/
        path.emplace_back(points[index]);

        BridgeMap* bridge = nullptr;
        //判断该点是否为桥接点
        for (auto& bm : bridges) {
            if (equal(bm.from, points[index]) || equal(bm.from2, points[index])) {
                bridge = &bm;
                break;
            }
        }
        if (bridge != nullptr) {
            RingNode& rn = findNode(bridge->to_ii); //to 环
            if (equal(bridge->from, points[index])) {
                traverseRing(rn, node.id, bridge->to, bridge->to2, false);
                index = findIndex(points, bridge->from2);
            }
            else if (equal(bridge->from2, points[index])) {
                traverseRing(rn, node.id, bridge->to2, bridge->to, false);
                index = findIndex(points, bridge->from);
            }
            if (index == -1)
                break;
         /*   path.emplace_back(sf::Vertex(
                sf::Vector2f(static_cast<float>(points[index].x()),
                    static_cast<float>(points[index].y())),
                sf::Color::Red
            ));*/
            path.emplace_back(points[index]);
        }
        index += isOutermostLayer ? -1 : 1;
    } while (index > 0 && index < points.size());

  
}

//画路径  SFML顶点数组集
//std::vector<sf::Vertex>  Bridge::outputPaths()
//{
//    printTree();
//    //第一个桥接边
//    BridgeMap bm = bridges[0];
//    IdIndex parent(1,1);
//    //遍历
//    traverseRing(findNode(bm.from_ii), parent, bm.from, bm.from2, true);
//    //形成闭环
//    path.emplace_back(sf::Vertex(
//        sf::Vector2f(static_cast<float>(bm.from.x()),
//            static_cast<float>(bm.from.y())),
//        sf::Color::Red
//    ));
//    return path;
//
//}
 





} // namespace Slic3r