#include "AppUtil.hpp"
#include "CGMApp.hpp"
#include "GeometryQueryTool.hpp"
#include "FacetModifyEngine.hpp"
#include "FacetQueryEngine.hpp"
#include "CubitFacetData.hpp"
#include "CubitPointData.hpp"
#include "CubitQuadFacetData.hpp"
#include "DLIList.hpp"
#include "Surface.hpp"
#include "ShellSM.hpp"
#include "Lump.hpp"
#include "Body.hpp"
#include "BodySM.hpp"
#include "RefFace.hpp"
#include "RefVertex.hpp"

#include <iostream>

bool generateFacetModel(
  DLIList<TopologyBridge*>& model)
{
  FacetModifyEngine* fme = FacetModifyEngine::instance();

  CubitStatus stat;
  int i;

  DLIList <CubitPoint*> plist;
  double pts[4][3] = {
      { 0., 0., 0. },
      { 1., 0., 0. },
      { 1., 1., 0. },
      { 0., 1., 1. },
  };
  for (i = 0; i < (int)(sizeof(pts)/sizeof(pts[0])); ++i)
    plist.append(new CubitPointData(pts[i][0], pts[i][1], pts[i][2]));

  // Build a tetrahedron, with 1 triangular facet per faceted-surface:
  int tconn[4][3] = {
      {0, 2, 1},
      {0, 3, 2},
      {0, 1, 3},
      {1, 2, 3}
  };
  DLIList<Surface*> all_surfs;
  DLIList<CubitFacet*> tflist;
  DLIList<CubitQuadFacet*> qflist;
  DLIList<CubitPoint*> facet_plist;
  for (i = 0; i < (int)(sizeof(tconn)/sizeof(tconn[0])); ++i)
    tflist.append(
      new CubitFacetData(
        plist[tconn[i][0]], plist[tconn[i][1]], plist[tconn[i][2]]));
  // Attempt to build a faceted surface:
  stat = fme->build_facet_surface(
    qflist,       // Quadrilateral facets
    tflist,       // Triangular facets
    facet_plist,  // Points used by facets (or empty list)
    1.,           // feature_angle
    0,            // interpolation order
    false,        // smooth_non_manifold
    true,         // split_surfaces
    all_surfs);   // (output) surface list
  if (all_surfs.size() <= 0 || stat != CUBIT_SUCCESS)
    return false;

  std::cout << "Created " << all_surfs.size() << " surface, expecting 4\n";

  // Now create a shell, lump, and body to make saving/loading easier.
  ShellSM* shell;
  stat = fme->make_facet_shell(all_surfs, shell);
  if (!shell || stat != CUBIT_SUCCESS) return false;

  DLIList<ShellSM*> shlist;
  shlist.append(shell);
  Lump* lump;
  stat = fme->make_facet_lump(shlist, lump);
  if (!lump || stat != CUBIT_SUCCESS) return false;

  DLIList<Lump*> llist;
  BodySM* bodySM;
  Body* body;
  llist.append(lump);
  stat = fme->make_facet_body(llist, bodySM);
  body = GeometryQueryTool::instance()->make_Body(bodySM);
  if (!body || stat != CUBIT_SUCCESS) return false;

  model.append(bodySM);
  return true;
}

int main(int argc, char* argv[])
{
  if (argc < 2)
    {
    std::cout
      << "Usage:\n"
      << "  " << argv[0] << " output_filename\n"
      << "where\n"
      << "  output_filename is the path to a CGM facet model to write\n"
      ;
      return 1;
    }

  // Initialize CGM
  AppUtil::instance()->startup(argc, argv);
  CGMApp::instance()->startup(argc, argv);
  FacetQueryEngine* fqe = FacetQueryEngine::instance();

  DLIList<TopologyBridge*> model;
  if (generateFacetModel(model))
    {
    ModelExportOptions opts;
    fqe->export_solid_model(
      model, argv[1], FACET_TYPE,
      CubitString(), opts);
    std::cout << "Wrote \"" << argv[1] << "\"\n";
    }

  return 0;
}