#include "device/Nurbs/loop_detection.cuh"
#include "device/Nurbs/nurbs_curve.cuh"
#include "device/Nurbs/nurbs_surface.cuh"
#include "device/warmup.cuh"
#include <cstdio>
#include <iostream>

int main() {
  int level = 10;
  //    NurbsSurface::Surface nurbsSurfaceEvaluator({
  //                                                          {{-1,   0,   0,
  //                                                          0.3},   {0,   1,
  //                                                          6, 0.8},  {1,  0,
  //                                                          4, 0.5},   {2,
  //                                                          0.5,  3, 0.8}, {3,
  //                                                          3,   1, 0.6}, {4,
  //                                                          -5,    0, 0.7}},
  //                                                          {{-2,   1,   1.2,
  //                                                          0.2}, {1,   2, 3,
  //                                                          0.3},  {2,  2, 3,
  //                                                          0.6},   {-1, -0.3,
  //                                                          2, 0.4},    {-1,
  //                                                          2,   0, 0.9}, {7,
  //                                                          -8,    2, 0.3}},
  //                                                          {{-3.4, 2,   3,
  //                                                          0.8},   {2,   3,
  //                                                          0, 0.6},  {4,  3,
  //                                                          7, 0.3},   {-2, 0,
  //                                                          -0.2, 0.4},
  //                                                          {1,    1.7, 5,
  //                                                          0.6},   {9, -10.3,
  //                                                          6, 0.7}},
  //                                                          {{-1.5, 3.2, 1,
  //                                                          0.5},   {2.6, 7,
  //                                                          -2, 0.7}, {5,
  //                                                          0.8, 4.2, 0.8},
  //                                                          {-4, 1,    4,
  //                                                          0.7},    {2.1,  4,
  //                                                          -2, 0.3},  {11,
  //                                                          -6,    4, 0.6}},
  //                                                          {{-0.2, 2,   0,
  //                                                          0.7},   {5,   3,
  //                                                          2, 0.4},
  //                                                          {5,  1.5, 1.4,
  //                                                          0.6}, {-3, 2, 5,
  //                                                          0.8}, {0.8,  1.3,
  //                                                          0, 0.5},   {15,
  //                                                          -2,    0.9, 0.6}},
  //                                                          {{3,    1.4, -1,
  //                                                          0.4},  {6,   2, 4,
  //                                                          0.6},  {-1, 0, -2,
  //                                                          0.4},  {0,  2.8,
  //                                                          2, 0.6},    {-0.5,
  //                                                          2,   1.2, 0.9},
  //                                                          {7,  -3,    -2,
  //                                                          0.3}},},
  //                                                  {0, 0, 0, 0.1, 0.5, 0.8,
  //                                                  1, 1, 1}, {0, 0, 0, 0.2,
  //                                                  0.7, 0.8, 1, 1, 1});
  //    NurbsSurface::Evaluator nurbsSurfaceEvaluator({
  //                                                          {{-1,   0,   0,
  //                                                          1},   {0,   1, 6,
  //                                                          1},  {1,  0,   4,
  //                                                          1},   {2,  0.5, 3,
  //                                                          1},    {3,    3,
  //                                                          1, 1},   {4,  -5,
  //                                                          0, 1}},
  //                                                          {{-2,   1,   1.2,
  //                                                          1}, {1,   2, 3,
  //                                                          1},  {2,  2,   3,
  //                                                          1},   {-1, -0.3,
  //                                                          2, 1},    {-1, 2,
  //                                                          0, 1},   {7,  -8,
  //                                                          2, 1}},
  //                                                          {{-3.4, 2,   3,
  //                                                          1},   {2,   3, 0,
  //                                                          1},  {4,  3,   7,
  //                                                          1},   {-2, 0,
  //                                                          -0.2, 1},
  //                                                          {1,    1.7, 5, 1},
  //                                                          {9,  -10.3, 6,
  //                                                          1}},
  //                                                          {{-1.5, 3.2, 1,
  //                                                          1},   {2.6, 7, -2,
  //                                                          1}, {5,  0.8, 4.2,
  //                                                          1}, {-4, 1,    4,
  //                                                          1},    {2.1,  4,
  //                                                          -2, 1},  {11, -6,
  //                                                          4, 1}},
  //                                                          {{-0.2, 2,   0,
  //                                                          1},   {5,   3, 2,
  //                                                          1}, {5,  1.5, 1.4,
  //                                                          1}, {-3, 2,    5,
  //                                                          1},    {0.8,  1.3,
  //                                                          0, 1},   {15, -2,
  //                                                          0.9, 1}},
  //                                                          {{3,    1.4, -1,
  //                                                          1},  {6,   2, 4,
  //                                                          1},  {-1, 0,   -2,
  //                                                          1},  {0,  2.8,  2,
  //                                                          1},    {-0.5,
  //                                                          2,   1.2, 1}, {7,
  //                                                          -3,    -2, 1}},},
  //                                                  {0, 0, 0, 0.1, 0.5, 0.8,
  //                                                  1, 1, 1}, {0, 0, 0, 0.2,
  //                                                  0.7, 0.8, 1, 1, 1});

  //    NurbsSurface::Surface nurbsSurfaceEvaluator({
  //                                                        {{-0.57, -0.48,
  //                                                        -0.31, 1}, {-0.17,
  //                                                        -0.49, -0.43, 1},
  //                                                        {0.3,  -0.53, -0.27,
  //                                                        1}, {0.66, -0.42,
  //                                                        -0.36, 1}},
  //                                                        {{-0.53, -0.15,
  //                                                        -0.03, 1}, {-0.21,
  //                                                        -0.12, 0.09, 1},
  //                                                        {0.10, -0.18, 0.03,
  //                                                        1},  {0.49, -0.15,
  //                                                        -0.03, 1}},
  //                                                        {{-0.61, 0.22, 0.09,
  //                                                        1},  {-0.21, 0.20,
  //                                                        0.09, 1},  {0.13,
  //                                                        0.20,  0.12, 1},
  //                                                        {0.49, 0.19,  -0.03,
  //                                                        1}},
  //                                                        {{-0.52, 0.51, 0.13,
  //                                                        1},  {-0.20, 0.32,
  //                                                        0.36, 1},  {0.18,
  //                                                        0.29,  0.28, 1},
  //                                                        {0.51, 0.53,  0.12,
  //                                                        1}}
  //                                                }, {0, 0, 0, 0, 1, 1, 1, 1},
  //                                                {0, 0, 0, 0, 1, 1, 1, 1});
  //    NurbsSurface::Surface nurbsSurfaceEvaluator({
  //                                                        {{2, -2,  -2, 1},
  //                                                        {-2.5, -2.2, -1.5,
  //                                                        3}, {-2, -2,  -0.5,
  //                                                        4}, {-2, -2,  1.5,
  //                                                        2}},
  //                                                        {{2, -1,  -2, 2},
  //                                                        {-2.5, -1.2, -1.5,
  //                                                        1}, {-2, -1,  -0.5,
  //                                                        1}, {-2, -1,  1.5,
  //                                                        1}},
  //                                                        {{3, 1.2, -2, 9},
  //                                                        {-2.5, 1.2,  -1.5,
  //                                                        1}, {-2, 1.5, -0.5,
  //                                                        7}, {-2, 1.5, 1.5,
  //                                                        4}},
  //                                                        {{2, 2,   -2, 1},
  //                                                        {-2.5, 2,    -1.5,
  //                                                        1}, {-2, 2.5, -0.5,
  //                                                        7}, {-2, 2,   1.5,
  //                                                        1}}
  //                                                }, {0, 0, 0, 0, 1, 1, 1, 1},
  //                                                {0, 0, 0, 0, 1, 1, 1, 1});
  //    NurbsSurface::Surface nurbsSurfaceEvaluator({
  //                                                               {{-0.5, -0.5,
  //                                                               -0.2, 1},
  //                                                               {-0.2, -0.5,
  //                                                               -0.1, 1},
  //                                                               {0.2, -0.5,
  //                                                               -0.1, 1},
  //                                                               {0.5, -0.5,
  //                                                               -0.2, 1}},
  //                                                               {{-0.5, -0.2,
  //                                                               -0.1, 1},
  //                                                               {-0.2, -0.2,
  //                                                               0., 1}, {0.2,
  //                                                               -0.2, 0., 1},
  //                                                               {0.5, -0.2,
  //                                                               -0.1, 1}},
  //                                                               {{-0.5, 0.2,
  //                                                               -0.1, 1},
  //                                                               {-0.2, 0.2,
  //                                                               0., 1}, {0.2,
  //                                                               0.2, 0., 1},
  //                                                               {0.5, 0.2,
  //                                                               -0.1, 1}},
  //                                                               {{-0.5, 0.5,
  //                                                               -0.2, 1},
  //                                                               {-0.2, 0.5,
  //                                                               -0.1, 1},
  //                                                               {0.2, 0.5,
  //                                                               -0.1, 1},
  //                                                               {0.5, 0.5,
  //                                                               -0.2, 1}}
  //                                                       }, {0, 0, 0, 0, 1, 1,
  //                                                       1, 1}, {0, 0, 0, 0,
  //                                                       1, 1, 1, 1});
  NurbsSurface::Surface nurbsSurfaceEvaluator(
      {{{0, 0, 0.2, 1.1},
        {0, 0.2, 0.3, 0.9},
        {0, 0.4, 0.25, 1.1},
        {0, 0.6, 0.12, 0.9},
        {0, 0.8, 0.22, 1},
        {0, 1, 0.12, 1}},
       {{0.2, 0, 0.22, 1},
        {0.2, 0.2, -0.3, 1},
        {0.2, 0.4, 0.4, 1},
        {0.2, 0.6, -0.1, 1.1},
        {0.2, 0.8, -0.1, 1},
        {0.2, 1, 0.2, 0.9}},
       {{0.4, 0, 0.18, 0.9},
        {0.4, 0.2, -0.3, 1},
        {0.4, 0.4, 0.4, 1.1},
        {0.4, 0.6, -0.1, 1},
        {0.4, 0.8, -0.1, 0.9},
        {0.4, 1, 0.23, 1}},
       {{0.6, 0, 0.2, 0.9},
        {0.6, 0.2, 0.4, 0.9},
        {0.6, 0.4, 0.4, 1},
        {0.6, 0.6, 0.4, 0.9},
        {0.6, 0.8, 0.4, 1},
        {0.6, 1, 0.2, 1}},
       {{0.8, 0, 0.19, 1.1},
        {0.8, 0.2, -0.4, 1},
        {0.8, 0.4, 0.4, 1.1},
        {0.8, 0.6, -0.27, 1},
        {0.8, 0.8, -0.27, 1},
        {0.8, 1, 0.2, 0.9}},
       {{1, 0, 0.2, 1.1},
        {1, 0.2, 0.12, 1},
        {1, 0.4, 0.22, 1},
        {1, 0.6, 0.32, 1},
        {1, 0.8, 0.22, 1.2},
        {1, 1, 0.12, 1.1}}},
      {0, 0, 0, 0, 0, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 1, 1, 1, 1, 1}, level);
  nurbsSurfaceEvaluator.setRecordTime(true);

  //    nurbsSurfaceEvaluator.buildGaussMap(6); // 构建曲面的Gauss map
  //    nurbsSurfaceEvaluator.gauss_map.printQuadTree(); // 打印整棵Gauss map树
  //    auto overlappedLeafNodes =
  //    NurbsSurface::getOverlappedLeafNodes(nurbsSurfaceEvaluator.gauss_map,
  //                                                                    nurbsSurfaceEvaluator.gauss_map);
  //    printf("overlapped leafNodes cnt: %llu\n", overlappedLeafNodes.size());

  // 判定两个Surface构造的GaussMap在指定u、v范围内是否有重合
  //    auto isRegionallyOverlapped =
  //    NurbsSurface::isGaussMapsOverlapped(nurbsSurfaceEvaluator.gauss_map,
  //                                                                      nurbsSurfaceEvaluator.gauss_map,
  //                                                                      {0.2,
  //                                                                      0.3},
  //                                                                      {0.2,
  //                                                                      0.3},
  //                                                                      {0.28,
  //                                                                      0.38},
  //                                                                      {0.28,
  //                                                                      0.38},
  //                                                                      {0,
  //                                                                      1},
  //                                                                      {0,
  //                                                                      1},
  //                                                                      {0,
  //                                                                      1},
  //                                                                      {0,
  //                                                                      1});
  //    printf("is guass map overlapped: %d\n", isRegionallyOverlapped);

  gpuWarmUp();

  int edgeSampleCnt = pow(2, level - 1) + 1;
  nurbsSurfaceEvaluator.evaluate();
  nurbsSurfaceEvaluator.derivative();
  // 如果buildBVH需要曲率K，这里需要再先:
  // nurbsSurfaceEvaluator.curvature(edgeSampleCnt, edgeSampleCnt);
  // 同时buildBVH传入第二个参数
  nurbsSurfaceEvaluator.buildBVH(false);                   // 构建曲面的BVH
  auto derInfo = nurbsSurfaceEvaluator.getDerivativeVec(); // 求值

  printf("==============================\n");
  //
  //    NurbsCurve::Curve nurbsCurveEvaluator(
  //            {{0.721068, 0, 0, 1},
  //             {1.05152, 0, 0, 1},
  //             {0.346353, 0, 0, 1},
  //             {0.351813, 0, 0, 1},
  //             {0.375972, 0, 0, 1},
  //             {0.363015, 0, 0, 1},
  //             {0.368758, 0, 0, 1},
  //             {0.368222, 0, 0, 1},
  //             {0.371302, 0, 0, 1},
  //             {0.374657, 0, 0, 1},
  //             {0.377866, 0, 0, 1},
  //             {0.380762, 0, 0, 1},
  //             {0.382451, 0, 0, 1},
  //             {0.383466, 0, 0, 1},
  //             {0.383948, 0, 0, 1},
  //             {0.384242, 0, 0, 1},
  //             {0.384156, 0, 0, 1},
  //             {0.383659, 0, 0, 1},
  //             {0.382616, 0, 0, 1},
  //             {0.381428, 0, 0, 1},
  //             {0.379223, 0, 0, 1},
  //             {0.379492, 0, 0, 1},
  //             {0.372487, 0, 0, 1},
  //             {0.384305, 0, 0, 1},
  //             {0.357789, 0, 0, 1},
  //             {0.34936, 0, 0, 1},
  //             {1.0537, 0, 0, 1},
  //             {0.717109, 0, 0, 1}},
  //            {0, 0, 0, 0, 0.103448, 0.137931, 0.172414, 0.206897, 0.241379,
  //            0.275862, 0.310345, 0.344828, 0.37931, 0.413793, 0.448276,
  //            0.482759, 0.517241, 0.551724, 0.586207, 0.62069, 0.655172,
  //            0.689655, 0.724138, 0.758621, 0.793103, 0.827586, 0.862069,
  //            0.896552, 1, 1, 1, 1});
  //    nurbsCurveEvaluator.setRecordTime(true);
  //
  //    auto res = nurbsCurveEvaluator.evaluate(30);
  //    for (auto &re: res) {
  //        printf("%f, %f, %f\n", re[0], re[1], re[2]);
  //    }
  //    printf("\n");
  return 0;
}