/******************************************************************/
/* This file is part of the homework assignments for CSCI-427/527 */
/* at The College of William & Mary and authored by Pieter Peers. */
/* No part of this file, whether altered or in original form, can */
/* be distributed or used outside the context of CSCI-427/527     */
/* without consent of either the College of William & Mary or     */
/* Pieter Peers.                                                  */
/******************************************************************/
#include <cassert>
#include <algorithm>

#include "boundedCompound.h"
#include "intersector_factory_base.h"

/////////////////
// Constructor //
/////////////////
boundedCompound::boundedCompound(void)
  : boundedPrimitive()
{
  _transform = transformation3d();
  _intersector = nullptr;
}


boundedCompound::boundedCompound(const transformation3d& transform, const std::shared_ptr<const shader_base>& shader)

  : boundedPrimitive(boundingBox(), shader)
{
  _transform = transform;
  _intersector = nullptr;
}


/////////////
// Methods //
/////////////
intersectionPoint boundedCompound::intersect(const ray& r) const
{
  // sanity check
  assert(_intersector);
  intersectionPoint ip;

  // HW5: Modify this to correctly apply the transformation '_transform' in
  //      the intersection computations. The actualy intersection is performed
  //      by the _intersector (as shown below). NOTE: do not modify the lines
  //      above this.
  // Modifies: nothing.
  // Returns: intersection point.

  ray r_trans = r;                        // create copy of ray r
  r_trans.inverseTransform(_transform);   // transform ray by inverse of matrix
  ip = _intersector->intersect(r_trans);  // intersect ray with primitives
  ip.transform(_transform);               // transform intersection by matrix

  // Done ***do not modify below***
  if(!ip.hasShader()) ip.setShader(_shader);
  return ip;
}


void boundedCompound::initialize(const intersector_factory_base& ifb)
{
  // create the _intersector
  _intersector = ifb(*this);
}


void boundedCompound::initializeBoundingBox(void)
{
  // compute the bounding box in world coordinates
  _bb = boundingBox();
  for_each(compounds().begin(), compounds().end(), [&](const std::shared_ptr<const boundedPrimitive>& prim)
  {
    _bb += transform(prim->boundingbox(), _transform);
  });
}


bool boundedCompound::hasShader(void) const
{
  // check if this has a shader
  if(boundedPrimitive::hasShader()) return true;

  // check if each child has a shader
  for(auto itr = compounds().begin(); itr != compounds().end(); itr++)
  {
    if(!(*itr)->hasShader()) return false;
  }

  // Done.
  return true;
}


void boundedCompound::_print(std::ostream& s) const
{
  s << "boundedCompound (" << _bb << ", " << compounds().size() << " compounds)";
}