// Copyright (c) 2020-2025 Advanced Micro Devices, Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#include <thrust/device_vector.h>
#include <thrust/extrema.h>
#include <thrust/pair.h>
#include <thrust/random.h>
#include <thrust/transform_reduce.h>

#include "include/host_device.h"

// This example shows how to compute a bounding box
// for a set of points in two dimensions.

struct point2d
{
  float x, y;

  __host__ __device__ point2d()
      : x(0)
      , y(0)
  {}

  __host__ __device__ point2d(float _x, float _y)
      : x(_x)
      , y(_y)
  {}
};

// bounding box type
struct bbox
{
  // construct an empty box
  __host__ __device__ bbox() {}

  // construct a box from a single point
  __host__ __device__ bbox(const point2d& point)
      : lower_left(point)
      , upper_right(point)
  {}

  // construct a box from a single point
  __host__ __device__ bbox& operator=(const point2d& point)
  {
    lower_left  = point;
    upper_right = point;
    return *this;
  }

  // construct a box from a pair of points
  __host__ __device__ bbox(const point2d& ll, const point2d& ur)
      : lower_left(ll)
      , upper_right(ur)
  {}

  point2d lower_left, upper_right;
};

// reduce a pair of bounding boxes (a,b) to a bounding box containing a and b
struct bbox_reduction
{
  __host__ __device__ bbox operator()(bbox a, bbox b)
  {
    // lower left corner
    point2d ll(thrust::min(a.lower_left.x, b.lower_left.x), thrust::min(a.lower_left.y, b.lower_left.y));

    // upper right corner
    point2d ur(thrust::max(a.upper_right.x, b.upper_right.x), thrust::max(a.upper_right.y, b.upper_right.y));

    return bbox(ll, ur);
  }
};

int main(void)
{
  const size_t N = 40;
  thrust::default_random_engine rng;
  thrust::uniform_real_distribution<float> u01(0.0f, 1.0f);

  // allocate storage for points
  thrust::device_vector<point2d> points(N);

  // generate some random points in the unit square
  for (size_t i = 0; i < N; i++)
  {
    float x   = u01(rng);
    float y   = u01(rng);
    points[i] = point2d(x, y);
  }

  // initial bounding box contains first point
  bbox init = bbox(points[0], points[0]);

  // binary reduction operation
  bbox_reduction binary_op;

  // compute the bounding box for the point set
  bbox result = thrust::reduce(points.begin(), points.end(), init, binary_op);

  // print output
  std::cout << "bounding box " << std::fixed;
  std::cout << "(" << result.lower_left.x << "," << result.lower_left.y << ") ";
  std::cout << "(" << result.upper_right.x << "," << result.upper_right.y << ")" << std::endl;

  return 0;
}
