/*
 * Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION
 * SPDX-License-Identifier: Apache-2.0
 */

#include <glm/gtc/matrix_access.hpp>

namespace nvh {

/* @DOC_START

```nvh::Bbox``` is a class to create bounding boxes.
It grows by adding 3d vector, can combine other bound boxes.
And it returns information, like its volume, its center, the min, max, etc..

@DOC_END */
struct Bbox
{
  Bbox() = default;
  Bbox(glm::vec3 _min, glm::vec3 _max)
      : m_min(_min)
      , m_max(_max)
  {
  }
  Bbox(const std::vector<glm::vec3>& corners)
  {
    for(auto& c : corners)
    {
      insert(c);
    }
  }

  void insert(const glm::vec3& v)
  {
    m_min = {std::min(m_min.x, v.x), std::min(m_min.y, v.y), std::min(m_min.z, v.z)};
    m_max = {std::max(m_max.x, v.x), std::max(m_max.y, v.y), std::max(m_max.z, v.z)};
  }

  void insert(const Bbox& b)
  {
    insert(b.m_min);
    insert(b.m_max);
  }

  inline Bbox& operator+=(float v)
  {
    m_min -= v;
    m_max += v;
    return *this;
  }

  inline bool isEmpty() const
  {
    return m_min == glm::vec3{std::numeric_limits<float>::max()} || m_max == glm::vec3{std::numeric_limits<float>::lowest()};
  }

  inline uint32_t rank() const
  {
    uint32_t result{0};
    result += m_min.x < m_max.x;
    result += m_min.y < m_max.y;
    result += m_min.z < m_max.z;
    return result;
  }
  inline bool      isPoint() const { return m_min == m_max; }
  inline bool      isLine() const { return rank() == 1u; }
  inline bool      isPlane() const { return rank() == 2u; }
  inline bool      isVolume() const { return rank() == 3u; }
  inline glm::vec3 min() { return m_min; }
  inline glm::vec3 max() { return m_max; }
  inline glm::vec3 extents() { return m_max - m_min; }
  inline glm::vec3 center() { return (m_min + m_max) * 0.5f; }
  inline float     radius() { return glm::length(m_max - m_min) * 0.5f; }

  Bbox transform(glm::mat4 mat)
  {
    // Make sure this is a 3D transformation + translation:
    auto        r       = glm::row(mat, 3);
    const float epsilon = 1e-6f;
    assert(fabs(r.x) < epsilon && fabs(r.y) < epsilon && fabs(r.z) < epsilon && fabs(r.w - 1.0f) < epsilon);

    std::vector<glm::vec3> corners(8);
    corners[0] = glm::vec3(mat * glm::vec4(m_min.x, m_min.y, m_min.z, 1.f));
    corners[1] = glm::vec3(mat * glm::vec4(m_min.x, m_min.y, m_max.z, 1.f));
    corners[2] = glm::vec3(mat * glm::vec4(m_min.x, m_max.y, m_min.z, 1.f));
    corners[3] = glm::vec3(mat * glm::vec4(m_min.x, m_max.y, m_max.z, 1.f));
    corners[4] = glm::vec3(mat * glm::vec4(m_max.x, m_min.y, m_min.z, 1.f));
    corners[5] = glm::vec3(mat * glm::vec4(m_max.x, m_min.y, m_max.z, 1.f));
    corners[6] = glm::vec3(mat * glm::vec4(m_max.x, m_max.y, m_min.z, 1.f));
    corners[7] = glm::vec3(mat * glm::vec4(m_max.x, m_max.y, m_max.z, 1.f));

    Bbox result(corners);
    return result;
  }

private:
  glm::vec3 m_min{std::numeric_limits<float>::max()};
  glm::vec3 m_max{-std::numeric_limits<float>::max()};
};

template <typename T, typename TFlag>
inline bool hasFlag(T a, TFlag flag)
{
  return (a & flag) == flag;
}

}  // namespace nvh