#include "test_common.h"
#include "./utils/utils.h"

using utils::Vf; using utils::Vd; using utils::Vi;

// ---------- helpers ----------
template <typename T>
static bool vec_equal_exact(const utils::Vector<T>& a, const utils::Vector<T>& b) {
    if (a.size() != b.size()) return false;
    for (std::uint64_t i=0;i<a.size();++i) if (a[i]!=b[i]) return false;
    return true;
}


// ---------- tests ----------

TEST_CASE(Vector_Construct_Size_Fill) {
    utils::Vd v0;
    CHECK(v0.size()==0, "default size should be 0");

    utils::Vd v1(5, 3.5);
    CHECK(v1.size()==5, "size 5");
    for (std::uint64_t i=0;i<5;++i) CHECK(v1[i]==3.5, "filled value 3.5");
}

TEST_CASE(Vector_PushBack_Resize) {
    utils::Vi v;
    v.push_back(1); v.push_back(2);
    CHECK(v.size()==2, "push_back size");
    CHECK(v[0]==1 && v[1]==2, "push_back contents");

    v.resize(5, 7);
    CHECK(v.size()==5, "resize size");
    CHECK(v[2]==7 && v[3]==7 && v[4]==7, "resize fill value");
}

TEST_CASE(Vector_Data_ReadWrite) {
    utils::Vd v(4, 0.0);
    double* p = v.data();
    for (std::uint64_t i=0;i<4;++i) p[i] = double(i+1);
    CHECK(v[0]==1.0 && v[3]==4.0, "write via data()");

    const utils::Vd& cv = v;
    const double* cp = cv.data();
    double s=0.0; for (std::uint64_t i=0;i<cv.size();++i) s += cp[i];
    CHECK(std::fabs(s-10.0) < 1e-12, "read via const data()");
}

TEST_CASE(Vector_Equality_and_NearlyEqual) {
    utils::Vd a(3, 1.0), b(3, 1.0);
    CHECK(a==b, "operator== equal");
    b[1] += 5e-7;
    CHECK(a==b, "operator== within eps (1e-6)");
    b[1] += 2e-6;
    CHECK(!(a==b), "operator== beyond eps");

    utils::Vd c = a;
    c[2] += 1e-10;
    CHECK(c.nearly_equal_vec(a, 1e-9), "nearly_equal_vec within tol");
    c[2] += 1e-6;
    CHECK(!c.nearly_equal_vec(a, 1e-9), "nearly_equal_vec beyond tol");
}

TEST_CASE(Vector_Scalar_Arithmetic) {
    utils::Vi v(3, 10); // [10,10,10]

    auto vadd = v + 2;              // [12,12,12]
    CHECK(vadd[0]==12 && vadd[2]==12, "scalar +");

    v += 3;                          // [13,13,13]
    CHECK(v[1]==13, "scalar +=");

    auto vsub = v - 5;               // [8,8,8]
    CHECK(vsub[2]==8, "scalar -");

    v -= 3;                          // [10,10,10]
    CHECK(v[0]==10, "scalar -=");

    auto vmul = v * 2;               // [20,20,20]
    CHECK(vmul[0]==20 && vmul[1]==20, "scalar *");

    v *= 3;                          // [30,30,30]
    CHECK(v[2]==30, "scalar *=");

    auto vdiv = v / 3;               // [10,10,10]
    CHECK(vdiv[0]==10 && vdiv[1]==10, "scalar /");

    v /= 2;                          // [15,15,15]
    CHECK(v[0]==15 && v[2]==15, "scalar /=");
}

TEST_CASE(Vector_Vector_Arithmetic) {
    utils::Vi a(4, 1), b(4, 2);

    auto c = a + b;  // [3,3,3,3]
    CHECK(c[0]==3 && c[3]==3, "v+v");

    a += b;          // [3,3,3,3]
    CHECK(a[1]==3, "v+=v");

    auto d = a - b;  // [1,1,1,1]
    CHECK(d[2]==1, "v-v");

    a -= b;          // [1,1,1,1]
    CHECK(a[0]==1, "v-=v");

    auto e = a * b;  // [2,2,2,2]
    CHECK(e[1]==2, "v*v (elemwise)");

    a *= b;          // [2,2,2,2]
    CHECK(a[3]==2, "v*=v");

    auto f = e / b;  // [1,1,1,1]
    CHECK(f[0]==1 && f[3]==1, "v/v (elemwise)");

    e /= b;          // [1,1,1,1]
    CHECK(e[2]==1, "v/=v");
}

TEST_CASE(Vector_Friend_Scalar_Left) {
    utils::Vd v(3, 2.0);  // [2,2,2]
    auto s1 = 3.0 + v;    // [5,5,5]
    CHECK(s1[0]==5.0 && s1[2]==5.0, "left scalar +");

    auto s2 = 4.0 * v;    // [8,8,8]
    CHECK(s2[1]==8.0, "left scalar *");
}

TEST_CASE(Vector_Power_and_Sqrt) {
    utils::Vd v(3, 4.0);         // [4,4,4]
    auto p = v.power(2.0);       // [16,16,16]
    CHECK(p[0]==16.0 && p[2]==16.0, "power scalar");

    v.inplace_sqrt();            // sqrt([4,4,4]) -> [2,2,2]
    CHECK(v[0]==2.0 && v[1]==2.0, "inplace_sqrt");
}

TEST_CASE(Vector_Dot_Sum_Norm) {
    utils::Vd a(3, 0.0), b(3, 0.0);
    a[0]=1.0; a[1]=2.0; a[2]=3.0;      // a = [1,2,3]
    b[0]=4.0; b[1]=5.0; b[2]=6.0;      // b = [4,5,6]

    double dot = a.dot(b);             // 1*4 + 2*5 + 3*6 = 32
    CHECK(std::fabs(dot - 32.0) < 1e-12, "dot");

    double s = a.sum();                // 6
    CHECK(std::fabs(s - 6.0) < 1e-12, "sum");

    double n = a.norm();               // sqrt(14)
    CHECK(std::fabs(n - std::sqrt(14.0)) < 1e-12, "norm");
}

TEST_CASE(Vector_Normalize_and_Throws) {
    utils::Vd v(3, 0.0);
    v[0]=3.0; v[1]=4.0; v[2]=0.0;           // norm = 5
    auto u = v.normalize();                  // returns new vector
    CHECK(std::fabs(u.norm() - 1.0) < 1e-12, "normalize() unit length");

    v.inplace_normalize();
    CHECK(std::fabs(v.norm() - 1.0) < 1e-12, "inplace_normalize unit length");

    utils::Vd z(3, 0.0);
    bool threw=false;
    try { z.inplace_normalize(); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "normalize should throw on zero vector");
}

// Size mismatch throws (elementwise ops)
TEST_CASE(Vector_Size_Mismatch_Throws) {
    utils::Vi a(3,1), b(4,2);

    bool threw=false;
    try { (void)a.dot(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "dot size mismatch should throw");

    threw=false;
    try { a.inplace_add(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "add size mismatch should throw");

    threw=false;
    try { a.inplace_subtract(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "subtract size mismatch should throw");

    threw=false;
    try { a.inplace_multiply(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "multiply size mismatch should throw");

    threw=false;
    try { a.inplace_divide(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "divide size mismatch should throw");

    threw=false;
    try { a.inplace_power(b); } catch(const std::runtime_error&) { threw=true; }
    CHECK(threw, "power size mismatch should throw");
}