// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

// szv#4 S4163

#include <BRep_Builder.hxx>
#include <ShapeExtend_Explorer.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>

//=================================================================================================

ShapeExtend_Explorer::ShapeExtend_Explorer() {}

//=================================================================================================

TopoDS_Shape ShapeExtend_Explorer::CompoundFromSeq(
  const Handle(TopTools_HSequenceOfShape)& seqval) const
{
  BRep_Builder    B;
  TopoDS_Compound C;
  B.MakeCompound(C);
  Standard_Integer i, n = seqval->Length();
  for (i = 1; i <= n; i++)
    B.Add(C, seqval->Value(i));
  return C;
}

//=================================================================================================

static void FillList(const Handle(TopTools_HSequenceOfShape)& list,
                     const TopoDS_Shape&                      comp,
                     const Standard_Boolean                   expcomp)
{
  for (TopoDS_Iterator it(comp); it.More(); it.Next())
  {
    const TopoDS_Shape& sub = it.Value();
    if (sub.ShapeType() != TopAbs_COMPOUND)
      list->Append(sub);
    else if (!expcomp)
      list->Append(sub);
    else
      FillList(list, sub, expcomp);
  }
}

Handle(TopTools_HSequenceOfShape) ShapeExtend_Explorer::SeqFromCompound(
  const TopoDS_Shape&    comp,
  const Standard_Boolean expcomp) const
{
  Handle(TopTools_HSequenceOfShape) list = new TopTools_HSequenceOfShape();
  if (comp.IsNull())
    return list;
  if (comp.ShapeType() != TopAbs_COMPOUND)
  {
    list->Append(comp);
    return list;
  }
  FillList(list, comp, expcomp);
  return list;
}

//=================================================================================================

void ShapeExtend_Explorer::ListFromSeq(const Handle(TopTools_HSequenceOfShape)& seqval,
                                       TopTools_ListOfShape&                    lisval,
                                       const Standard_Boolean                   clear) const
{
  if (clear)
    lisval.Clear();
  if (seqval.IsNull())
    return;
  Standard_Integer i, nb = seqval->Length();
  for (i = 1; i <= nb; i++)
    lisval.Append(seqval->Value(i));
}

//=================================================================================================

Handle(TopTools_HSequenceOfShape) ShapeExtend_Explorer::SeqFromList(
  const TopTools_ListOfShape& lisval) const
{
  Handle(TopTools_HSequenceOfShape)  seqval = new TopTools_HSequenceOfShape();
  TopTools_ListIteratorOfListOfShape it;
  for (it.Initialize(lisval); it.More(); it.Next())
    seqval->Append(it.Value());
  return seqval;
}

//=================================================================================================

TopAbs_ShapeEnum ShapeExtend_Explorer::ShapeType(const TopoDS_Shape&    shape,
                                                 const Standard_Boolean compound) const
{
  if (shape.IsNull())
    return TopAbs_SHAPE;
  TopAbs_ShapeEnum res = shape.ShapeType();
  if (!compound || res != TopAbs_COMPOUND)
    return res;
  res = TopAbs_SHAPE;
  for (TopoDS_Iterator iter(shape); iter.More(); iter.Next())
  {
    const TopoDS_Shape& sh = iter.Value();
    if (sh.IsNull())
      continue;
    TopAbs_ShapeEnum typ = sh.ShapeType();
    if (typ == TopAbs_COMPOUND)
      typ = ShapeType(sh, compound);
    if (res == TopAbs_SHAPE)
      res = typ;
    //   Egalite : OK;  Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
    else if (res == TopAbs_EDGE && typ == TopAbs_WIRE)
      res = typ;
    else if (res == TopAbs_WIRE && typ == TopAbs_EDGE)
      continue;
    else if (res == TopAbs_FACE && typ == TopAbs_SHELL)
      res = typ;
    else if (res == TopAbs_SHELL && typ == TopAbs_FACE)
      continue;
    else if (res != typ)
      return TopAbs_COMPOUND;
  }
  return res;
}

//=================================================================================================

TopoDS_Shape ShapeExtend_Explorer::SortedCompound(const TopoDS_Shape&    shape,
                                                  const TopAbs_ShapeEnum type,
                                                  const Standard_Boolean explore,
                                                  const Standard_Boolean compound) const
{
  if (shape.IsNull())
    return shape;
  TopAbs_ShapeEnum typ = shape.ShapeType();
  TopoDS_Shape     sh, sh0;
  Standard_Integer nb = 0;

  //  Compound : on le prend, soit tel quel, soit son contenu
  if (typ == TopAbs_COMPOUND || typ == TopAbs_COMPSOLID)
  {
    TopoDS_Compound C;
    BRep_Builder    B;
    B.MakeCompound(C);
    for (TopoDS_Iterator it(shape); it.More(); it.Next())
    {
      sh0 = SortedCompound(it.Value(), type, explore, compound);
      if (sh0.IsNull())
        continue;
      sh  = sh0;
      typ = sh.ShapeType();
      if (typ == TopAbs_COMPOUND && !compound)
      {
        for (TopoDS_Iterator it2(sh); it2.More(); it2.Next())
        {
          nb++;
          sh = it2.Value();
          B.Add(C, sh);
        }
      }
      else
      {
        nb++;
        B.Add(C, sh);
      }
    }
    if (nb == 0)
      C.Nullify();
    else if (nb == 1)
      return sh;
    return C;
  }

  //   Egalite : OK;  Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
  if (typ == type)
    return shape;
  if (typ == TopAbs_EDGE && type == TopAbs_WIRE)
  {
    BRep_Builder B;
    TopoDS_Wire  W;
    B.MakeWire(W);
    B.Add(W, shape);
    return W;
  }
  if (typ == TopAbs_FACE && type == TopAbs_SHELL)
  {
    BRep_Builder B;
    TopoDS_Shell S;
    B.MakeShell(S);
    B.Add(S, shape);
    return S;
  }

  //   Le reste : selon exploration
  if (!explore)
  {
    TopoDS_Shape nulsh;
    return nulsh;
  }

  //  Ici, on doit explorer
  //  SOLID + mode COMPOUND : reconduire les SHELLs
  if (typ == TopAbs_SOLID && compound)
  {
    TopoDS_Compound C;
    BRep_Builder    B;
    B.MakeCompound(C);
    for (TopoDS_Iterator it(shape); it.More(); it.Next())
    {
      sh0 = SortedCompound(it.Value(), type, explore, compound);
      if (sh0.IsNull())
        continue;
      sh = sh0;
      nb++;
      B.Add(C, sh);
    }
    if (nb == 0)
      C.Nullify();
    else if (nb == 1)
      return sh;
    return C;
  }

  //  Exploration classique
  TopoDS_Compound CC;
  BRep_Builder    BB;
  BB.MakeCompound(CC);
  // Standard_Integer iena = Standard_False; //szv#4:S4163:12Mar99 unused
  for (TopExp_Explorer aExp(shape, type); aExp.More(); aExp.Next())
  {
    nb++;
    sh = aExp.Current();
    BB.Add(CC, sh);
  }
  if (nb == 0)
    CC.Nullify();
  else if (nb == 1)
    return sh;
  return CC;
}

//=================================================================================================

void ShapeExtend_Explorer::DispatchList(const Handle(TopTools_HSequenceOfShape)& list,
                                        Handle(TopTools_HSequenceOfShape)&       vertices,
                                        Handle(TopTools_HSequenceOfShape)&       edges,
                                        Handle(TopTools_HSequenceOfShape)&       wires,
                                        Handle(TopTools_HSequenceOfShape)&       faces,
                                        Handle(TopTools_HSequenceOfShape)&       shells,
                                        Handle(TopTools_HSequenceOfShape)&       solids,
                                        Handle(TopTools_HSequenceOfShape)&       compsols,
                                        Handle(TopTools_HSequenceOfShape)&       compounds) const
{
  if (list.IsNull())
    return;
  if (vertices.IsNull())
    vertices = new TopTools_HSequenceOfShape();
  if (edges.IsNull())
    edges = new TopTools_HSequenceOfShape();
  if (wires.IsNull())
    wires = new TopTools_HSequenceOfShape();
  if (faces.IsNull())
    faces = new TopTools_HSequenceOfShape();
  if (shells.IsNull())
    shells = new TopTools_HSequenceOfShape();
  if (solids.IsNull())
    solids = new TopTools_HSequenceOfShape();
  if (compsols.IsNull())
    compsols = new TopTools_HSequenceOfShape();
  if (compounds.IsNull())
    compounds = new TopTools_HSequenceOfShape();

  Standard_Integer i, nb = list->Length();
  for (i = 1; i <= nb; i++)
  {
    TopoDS_Shape sh = list->Value(i);
    if (sh.IsNull())
      continue;
    switch (sh.ShapeType())
    {
      case TopAbs_VERTEX:
        vertices->Append(sh);
        break;
      case TopAbs_EDGE:
        edges->Append(sh);
        break;
      case TopAbs_WIRE:
        wires->Append(sh);
        break;
      case TopAbs_FACE:
        faces->Append(sh);
        break;
      case TopAbs_SHELL:
        shells->Append(sh);
        break;
      case TopAbs_SOLID:
        solids->Append(sh);
        break;
      case TopAbs_COMPSOLID:
        compsols->Append(sh);
        break;
      case TopAbs_COMPOUND:
        compounds->Append(sh);
        break;
      default:
        break;
    }
  }
}
