/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#include "OdaCommon.h"
#include "SrGeometryHelpers.h"

namespace OdSrGeometryHelpers
{
  const double acadPointTol = 1e-10;
  const double acadVectorTol = 1e-12;
  const OdGeTol acadTolerance(acadPointTol, acadVectorTol);

  bool arePointsCollinear(const OdGePoint3dArray& points)
  {
    if (points.size() < 3) return true;

    const double EPSILON = 1e-12; //Acad's tolerance for vector operations
    OdGeVector3d baseVector = points[1] - points[0];

    double len = baseVector.length();
    if (len < EPSILON) return true;
    baseVector /= len;
    for (OdUInt32 i = 2; i < points.size(); ++i)
    {
      OdGeVector3d testVector = points[i] - points[0];
      double lenTest = testVector.length();
      if (lenTest < EPSILON) continue;
      testVector /= lenTest;

      if (baseVector.crossProduct(testVector).length() > EPSILON)
        return false;
    }

    return true;
  }

  std::pair<OdGePoint3d, OdGePoint3d> findExtremePoints(const OdGePoint3dArray& points)
  {
    if (points.size() < 2)
      return { points[0], points[0] };

    // Find two points with maximum distance
    OdGePoint3d minPt = points[0], maxPt = points[0];
    double maxDist = 0.0;

    for (OdUInt32 i = 0; i < points.size(); ++i)
      for (OdUInt32 j = i + 1; j < points.size(); ++j)
      {
        double dist = points[i].distanceTo(points[j]);
        if (dist > maxDist)
        {
          maxDist = dist;
          minPt = points[i];
          maxPt = points[j];
        }
      }

    return { minPt, maxPt };
  }

};