#pragma once
#include <data/data_center.hpp>
#include <base/primitive.hpp>
#include "subface/simple/extrude_polyline_side_face.hpp"
#include "subface/simple/extrude_helixline_side_face.hpp"
#include <subface/simple/plane.hpp>

namespace internal
{
inline void expand_aabb_for_bulge_segment(const vector2d& A,
                                          const vector2d& B,
                                          double          bulge,
                                          vector2d&       aabb_min,
                                          vector2d&       aabb_max)
{
    // 端点始终纳入（无论是直线还是圆弧，端点必在 AABB 内）
    aabb_min.x = std::min({aabb_min.x, A.x, B.x});
    aabb_min.y = std::min({aabb_min.y, A.y, B.y});
    aabb_max.x = std::max({aabb_max.x, A.x, B.x});
    aabb_max.y = std::max({aabb_max.y, A.y, B.y});

    if (std::abs(bulge) < 1e-12) return; // 直线段，端点已处理完毕

    // 计算圆心与半径
    Eigen::Vector2d Av(A.x, A.y), Bv(B.x, B.y);
    Eigen::Vector2d chord     = Bv - Av;
    double          chord_len = chord.norm();
    if (chord_len < 1e-12) return;

    Eigen::Vector2d chord_dir = chord / chord_len;
    Eigen::Vector2d chord_perp(-chord_dir.y(), chord_dir.x()); // 左法向

    // d = chord/2 * (1/bulge - bulge) / 2  = chord*(1-b²)/(4b)
    double          d      = 0.5 * chord_len * (1.0 / bulge - bulge) * 0.5;
    Eigen::Vector2d M      = 0.5 * (Av + Bv);
    Eigen::Vector2d center = M + chord_perp * d;
    double          radius = std::sqrt(d * d + 0.25 * chord_len * chord_len);

    // 计算端点对应的极角
    double angle_A = std::atan2(A.y - center.y(), A.x - center.x());
    double angle_B = std::atan2(B.y - center.y(), B.x - center.x());

    // 判断某极角是否在弧段内
    //    bulge > 0 → CCW（从 angle_A 逆时针到 angle_B）
    //    bulge < 0 → CW （从 angle_A 顺时针到 angle_B）
    auto angle_in_arc = [&](double theta) -> bool {
        // 将所有角度归一化到 [0, 2π)
        auto norm2pi = [](double a) -> double {
            a = std::fmod(a, 2.0 * pi);
            return a < 0.0 ? a + 2.0 * pi : a;
        };
        double sa = norm2pi(angle_A);
        double ea = norm2pi(angle_B);
        double ta = norm2pi(theta);

        if (bulge > 0.0) { // CCW: sa → ea，增角方向
            if (sa <= ea)
                return ta >= sa && ta <= ea;
            else
                return ta >= sa || ta <= ea; // 跨过 0°/360°
        } else {                             // CW:  sa → ea，减角方向
            if (sa >= ea)
                return ta <= sa && ta >= ea;
            else
                return ta <= sa || ta >= ea; // 跨过 0°/360°
        }
    };

    // 检查四个坐标轴极值方向（0°, 90°, 180°, 270°）
    struct {
        double angle;
        double dx;
        double dy;
    } extrema[] = {
        {0.0,              radius,  0.0    },
        {pi / 2.0,       0.0,     radius },
        {pi,             -radius, 0.0    },
        {3.0 * pi / 2.0, 0.0,     -radius},
    };

    for (const auto& e : extrema) {
        if (angle_in_arc(e.angle)) {
            aabb_min.x = std::min(aabb_min.x, center.x() + e.dx);
            aabb_min.y = std::min(aabb_min.y, center.y() + e.dy);
            aabb_max.x = std::max(aabb_max.x, center.x() + e.dx);
            aabb_max.y = std::max(aabb_max.y, center.y() + e.dy);
        }
    }
}

// 计算单段 bulge 圆弧的 AABB 扩展
// bulge = tan(θ/4), θ = 圆弧包角
// 圆心: c = M + perp * d, 其中 perp 为弦的单位法向, d = (chord/2)(1/bulge - bulge)/2
inline vector2d compute_profile_aabb_min(const polyline_descriptor_t* profile)
{
    if (!profile || profile->point_number == 0) return {0.0, 0.0};

    vector2d min_val{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
    vector2d max_val{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest()};

    for (uint32_t i = 0; i < profile->point_number; ++i) {
        min_val.x = std::min(min_val.x, profile->points[i].x);
        min_val.y = std::min(min_val.y, profile->points[i].y);
        max_val.x = std::max(max_val.x, profile->points[i].x);
        max_val.y = std::max(max_val.y, profile->points[i].y);
    }

    if (profile->bulges) {
        uint32_t n = profile->point_number;
        for (uint32_t i = 0; i < n; ++i) {
            double bulge = profile->bulges[i];
            if (std::abs(bulge) < 1e-12) continue;
            uint32_t j = (i + 1) % n;

            vector2d A_2d = {profile->points[i].x, profile->points[i].y};
            vector2d B_2d = {profile->points[j].x, profile->points[j].y};
            expand_aabb_for_bulge_segment(A_2d, B_2d, bulge, min_val, max_val);
        }
    }

    constexpr double margin = 1e-6;
    min_val.x               -= margin;
    min_val.y               -= margin;
    return min_val;
}

inline vector2d compute_profile_aabb_max(const polyline_descriptor_t* profile)
{
    if (!profile || profile->point_number == 0) return {0.0, 0.0};

    vector2d min_val{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
    vector2d max_val{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest()};

    for (uint32_t i = 0; i < profile->point_number; ++i) {
        min_val.x = std::min(min_val.x, profile->points[i].x);
        min_val.y = std::min(min_val.y, profile->points[i].y);
        max_val.x = std::max(max_val.x, profile->points[i].x);
        max_val.y = std::max(max_val.y, profile->points[i].y);
    }

    if (profile->bulges) {
        uint32_t n = profile->point_number;
        for (uint32_t i = 0; i < n; ++i) {
            double bulge = profile->bulges[i];
            if (std::abs(bulge) < 1e-12) continue;
            uint32_t j = (i + 1) % n;

            // 修改处：从vector3d转换为vector2d
            vector2d A_2d = {profile->points[i].x, profile->points[i].y};
            vector2d B_2d = {profile->points[j].x, profile->points[j].y};
            expand_aabb_for_bulge_segment(A_2d, B_2d, bulge, min_val, max_val);
        }
    }

    constexpr double margin  = 1e-6;
    max_val.x               += margin;
    max_val.y               += margin;
    return max_val;
}

/**
 * @brief 从 polyline descriptor 计算底盖 matrix
 * @param desc polyline descriptor
 * @return 底盖的 paired_model_matrix
 */
inline paired_model_matrix compute_polyline_bottom_cap_matrix(const polyline_descriptor_t& desc)
{
    Eigen::Vector3d origin      = Eigen::Map<const Eigen::Vector3d>(&desc.points[0].x);
    Eigen::Vector3d p1          = Eigen::Map<const Eigen::Vector3d>(&desc.points[1].x);
    Eigen::Vector3d tangent     = (p1 - origin).normalized();
    Eigen::Vector3d axis_normal = Eigen::Map<const Eigen::Vector3d>(&desc.reference_normal.x);
    axis_normal.normalize();

    return build_polyline_cap_matrix(origin, tangent, axis_normal, false);
}

/**
 * @brief 从 polyline descriptor 计算顶盖 matrix
 * @param desc polyline descriptor
 * @return 顶盖的 paired_model_matrix
 */
inline paired_model_matrix compute_polyline_top_cap_matrix(const polyline_descriptor_t& desc)
{
    uint32_t        last_idx    = desc.point_number - 1;
    Eigen::Vector3d origin      = Eigen::Map<const Eigen::Vector3d>(&desc.points[last_idx].x);
    Eigen::Vector3d p_prev      = Eigen::Map<const Eigen::Vector3d>(&desc.points[last_idx - 1].x);
    Eigen::Vector3d tangent     = (origin - p_prev).normalized();
    Eigen::Vector3d axis_normal = Eigen::Map<const Eigen::Vector3d>(&desc.reference_normal.x);
    axis_normal.normalize();

    return build_polyline_cap_matrix(origin, tangent, axis_normal, true);
}

/**
 * @brief 从螺旋线几何数据计算端盖变换矩阵
 * @param ag 螺旋线几何数据
 * @param t 参数化位置 (0.0 表示起点, 1.0 表示终点)
 * @return 端盖的 paired_model_matrix
 *
 * 这个函数计算螺旋线在参数 t 处的 Frenet 标架（切线、法线、副法线），
 * 并构建从局部坐标系到世界坐标系的变换矩阵。
 * 切线方向作为平面的法向，指向几何体内部。
 */
inline paired_model_matrix make_helixline_cap_matrix(const helixline_geometry_data& ag, double t)
{
    // 计算曲线端点处的切线 / 法线 / 副法线
    const Eigen::Vector3d T = ag.calculate_tangent(t);
    const Eigen::Vector3d N = ag.calculate_normal(t);
    const Eigen::Vector3d B = N.cross(T);

    // 计算曲线端点的世界坐标
    const double          angle = t * ag.total_theta;
    const Eigen::Vector3d P(ag.radius * std::cos(angle), ag.radius * std::sin(angle), t * ag.height);

    paired_model_matrix m;
    auto&               mat = m.local_to_world.matrix();
    mat.setIdentity();
    mat.col(0).head<3>() = T; // 平面法向 = 切线方向（指向几何体内部）
    mat.col(1).head<3>() = N; // 平面内轴
    mat.col(2).head<3>() = B; // 平面内轴
    mat.col(3).head<3>() = P;
    m.world_to_local     = m.local_to_world.inverse();
    return m;
}


inline paired_model_matrix compute_helixline_bottom_cap_matrix(const helixline_geometry_data& ag)
{
    return make_helixline_cap_matrix(ag, 0.0);
}

/**
 * @brief 从 helixline descriptor 计算顶盖 matrix
 * @param ag 螺旋线几何数据
 * @return 顶盖的 paired_model_matrix
 */
inline paired_model_matrix compute_helixline_top_cap_matrix(const helixline_geometry_data& ag)
{
    return make_helixline_cap_matrix(ag, 1.0);
}

// ==================== Polyline 拉伸体 ====================

/**
 * @brief Polyline 路径的拉伸体
 */
struct extrude_polyline_t final : primitive {
    extrude_polyline_t(primitive_data_center_t* data_center_ptr) : primitive(data_center_ptr)
    {
        // 使用默认 descriptor 初始化
        extrude_polyline_descriptor_t full_desc{};
        full_desc.profile_number = 1;
        full_desc.profiles       = const_cast<polyline_descriptor_t*>(&descriptor_defaults::unit_square_profile);
        full_desc.axis           = descriptor_defaults::unit_polyline_axis;

        initialize_from_descriptor(data_center_ptr, full_desc);
    }

    primitive_type get_type() const override { return PRIMITIVE_TYPE_EXTRUDE_POLYLINE; }

    stl_vector_mp<const void*> get_subface_geometries() const override;

    span<marked_subface_ptr_t<subface>> get_subfaces() const override
    {
        return {const_cast<marked_subface_ptr_t<subface>*>(subfaces.data()), subfaces.size()};
    }

    stl_vector_mp<surface_type> get_subface_types() const override
    {
        return {
            surface_type::extrude_polyline_side,
            surface_type::plane, // 底盖
            surface_type::plane  // 顶盖
        };
    }

    /**
     * @brief 从 descriptor 初始化（内部方法，类似 cylinder 的 initialize）
     * @details 先准备好所有参数，然后一次性调用基类的 initialize
     */
    PE_API void initialize_from_descriptor(primitive_data_center_t* dc, const extrude_polyline_descriptor_t& desc);

    /**
     * @brief 使用 Profile 和 Axis 初始化拉伸体
     */
    PE_API void initialize_with_components(primitive_data_center_t* dc, const extrude_polyline_descriptor_t& desc)
    {
        initialize_from_descriptor(dc, desc);
    }

    /**
     * @brief 替换 Profile
     * @details 保持 Axis 不变,仅更新 Profile
     */
    PE_API void replace_profile(const profile_descriptor_t& new_profile);

    /**
     * @brief 替换 Axis
     * @details 保持 Profile 不变,仅更新 Axis
     */
    PE_API void replace_axis(const axis_descriptor_t& new_axis);

    // 3个子面：侧面 + 底盖 + 顶盖
    std::array<marked_subface_ptr_t<subface>, 3> subfaces{};
};

// ==================== Helixline 拉伸体 ====================

/**
 * @brief Helixline 路径的拉伸体
 */
struct extrude_helixline_t final : primitive {
    extrude_helixline_t(primitive_data_center_t* data_center_ptr) : primitive(data_center_ptr)
    {
        // 使用默认 descriptor 初始化
        extrude_helixline_descriptor_t full_desc{};
        full_desc.profile_number = 1;
        full_desc.profiles       = const_cast<polyline_descriptor_t*>(&descriptor_defaults::unit_square_profile);
        full_desc.axis           = descriptor_defaults::unit_helix;
        initialize_from_descriptor(data_center_ptr, full_desc);
    }

    primitive_type get_type() const override { return PRIMITIVE_TYPE_EXTRUDE_HELIXLINE; }

    stl_vector_mp<const void*> get_subface_geometries() const override;

    span<marked_subface_ptr_t<subface>> get_subfaces() const override
    {
        return {const_cast<marked_subface_ptr_t<subface>*>(subfaces.data()), 3};
    }

    stl_vector_mp<surface_type> get_subface_types() const override
    {
        return {surface_type::extrude_helixline_side, surface_type::plane, surface_type::plane};
    }

    PE_API void initialize_from_descriptor(primitive_data_center_t* dc, const extrude_helixline_descriptor_t& desc);

    PE_API void initialize_with_components(primitive_data_center_t* dc, const extrude_helixline_descriptor_t& desc)
    {
        initialize_from_descriptor(dc, desc);
    }

    PE_API void replace_profile(const profile_descriptor_t& new_profile);
    PE_API void replace_axis(const axis_descriptor_t& new_axis);

    std::array<marked_subface_ptr_t<subface>, 3> subfaces{};
};

} // namespace internal