#pragma once

#include <array>

#include <fwd_types.hpp>

template <typename Index>
static inline auto find_subface_by_index(const stl_vector_mp<vert_face_info_t>& faces, Index subface_index)
{
    return std::find_if(faces.begin(), faces.end(), [&](const vert_face_info_t& x) {
        return x.subface_index == subface_index;
    });
}

// compute barycentric coordinate of Point (intersection of three planes)
// Point in tet cell
template <typename Scalar>
static inline std::array<Scalar, 4> compute_barycentric_coords(const std::array<Scalar, 4>& plane1,
                                                               const std::array<Scalar, 4>& plane2,
                                                               const std::array<Scalar, 4>& plane3)
{
    Scalar n1 = plane1[3] * (plane2[2] * plane3[1] - plane2[1] * plane3[2])
                + plane1[2] * (plane2[1] * plane3[3] - plane2[3] * plane3[1])
                + plane1[1] * (plane2[3] * plane3[2] - plane2[2] * plane3[3]);
    Scalar n2 = plane1[3] * (plane2[0] * plane3[2] - plane2[2] * plane3[0])
                + plane1[2] * (plane2[3] * plane3[0] - plane2[0] * plane3[3])
                + plane1[0] * (plane2[2] * plane3[3] - plane2[3] * plane3[2]);
    Scalar n3 = plane1[3] * (plane2[1] * plane3[0] - plane2[0] * plane3[1])
                + plane1[1] * (plane2[0] * plane3[3] - plane2[3] * plane3[0])
                + plane1[0] * (plane2[3] * plane3[1] - plane2[1] * plane3[3]);
    Scalar n4 = plane1[2] * (plane2[0] * plane3[1] - plane2[1] * plane3[0])
                + plane1[1] * (plane2[2] * plane3[0] - plane2[0] * plane3[2])
                + plane1[0] * (plane2[1] * plane3[2] - plane2[2] * plane3[1]);
    Scalar d = n1 + n2 + n3 + n4;
    //
    return {n1 / d, n2 / d, n3 / d, n4 / d};
}

// Point on tet face
template <typename Scalar>
static inline std::array<Scalar, 3> compute_barycentric_coords(const std::array<Scalar, 3>& plane1,
                                                               const std::array<Scalar, 3>& plane2)
{
    Scalar n1 = plane1[2] * plane2[1] - plane1[1] * plane2[2];
    Scalar n2 = plane1[0] * plane2[2] - plane1[2] * plane2[0];
    Scalar n3 = plane1[1] * plane2[0] - plane1[0] * plane2[1];
    Scalar d  = n1 + n2 + n3;
    //
    return {n1 / d, n2 / d, n3 / d};
}

// Point on tet edge
template <typename Scalar>
static inline std::array<Scalar, 2> compute_barycentric_coords(Scalar f1, Scalar f2)
{
    return {f2 / (f2 - f1), -f1 / (f2 - f1)};
}