// Copyright (c) 2018  GeometryFactory Sarl (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h $
// $Id: PLY.h 0779373 2020-03-26T13:31:46+01:00 Sébastien Loriot
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s)     : Simon Giraudot

#ifndef CGAL_SURFACE_MESH_IO_PLY
#define CGAL_SURFACE_MESH_IO_PLY

#include <CGAL/IO/PLY.h>

namespace CGAL {

namespace internal {

#if !defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE) && !defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES)
namespace PLY {

template <typename Point>
class Surface_mesh_filler
{
public:
  typedef typename Kernel_traits<Point>::Kernel Kernel;
  typedef typename Kernel::Vector_3 Vector;
  typedef CGAL::Surface_mesh<Point> Surface_mesh;
  typedef typename Surface_mesh::size_type size_type;
  typedef typename Surface_mesh::Vertex_index Vertex_index;
  typedef typename Surface_mesh::Face_index Face_index;
  typedef typename Surface_mesh::Edge_index Edge_index;
  typedef typename Surface_mesh::Halfedge_index Halfedge_index;

private:

  struct Abstract_ply_property_to_surface_mesh_property
  {
    virtual ~Abstract_ply_property_to_surface_mesh_property() { }
    virtual void assign (PLY_element& element, size_type index) = 0;
  };

  template <typename Simplex, typename Type>
  class PLY_property_to_surface_mesh_property : public Abstract_ply_property_to_surface_mesh_property
  {
    typedef typename Surface_mesh::template Property_map<Simplex, Type> Map;
    Map m_map;
    std::string m_name;
  public:
    PLY_property_to_surface_mesh_property (Surface_mesh& sm, const std::string& name)
      : m_name (name)
    {
      m_map = sm.template add_property_map<Simplex, Type>(prefix(Simplex()) + name).first;
    }

    virtual void assign (PLY_element& element, size_type index)
    {
      Type t{};
      element.assign (t, m_name.c_str());
      put(m_map, Simplex(index), t);
    }

    std::string prefix(Vertex_index) const { return "v:"; }
    std::string prefix(Face_index) const { return "f:"; }
    std::string prefix(Edge_index) const { return "e:"; }
    std::string prefix(Halfedge_index) const { return "h:"; }
  };

  Surface_mesh& m_mesh;
  std::vector<Vertex_index> m_map_v2v;
  bool m_use_floats;
  int m_normals;
  typename Surface_mesh::template Property_map<Vertex_index, Vector> m_normal_map;
  int m_vcolors;
  typename Surface_mesh::template Property_map<Vertex_index, CGAL::Color> m_vcolor_map;
  int m_fcolors;
  typename Surface_mesh::template Property_map<Face_index, CGAL::Color> m_fcolor_map;
  bool m_use_int32_t;
  std::string m_index_tag;
  std::vector<Abstract_ply_property_to_surface_mesh_property*> m_vertex_properties;
  std::vector<Abstract_ply_property_to_surface_mesh_property*> m_face_properties;
  std::vector<Abstract_ply_property_to_surface_mesh_property*> m_edge_properties;
  std::vector<Abstract_ply_property_to_surface_mesh_property*> m_halfedge_properties;

public:

  Surface_mesh_filler (Surface_mesh& mesh)
    : m_mesh (mesh), m_use_floats (false), m_normals(0), m_vcolors(0), m_fcolors(0)
  { }

  ~Surface_mesh_filler()
  {
    for (std::size_t i = 0; i < m_vertex_properties.size(); ++ i)
      delete m_vertex_properties[i];
    for (std::size_t i = 0; i < m_face_properties.size(); ++ i)
      delete m_face_properties[i];
    for (std::size_t i = 0; i < m_edge_properties.size(); ++ i)
      delete m_edge_properties[i];
    for (std::size_t i = 0; i < m_halfedge_properties.size(); ++ i)
      delete m_halfedge_properties[i];
  }

  bool has_simplex_specific_property (internal::PLY::PLY_read_number* property, Vertex_index)
  {
    const std::string& name = property->name();
    if (name == "x" ||
        name == "y" ||
        name == "z")
    {
      if (dynamic_cast<PLY_read_typed_number<float>*>(property))
        m_use_floats = true;
      return true;
    }
    if (name == "nx" ||
        name == "ny" ||
        name == "nz")
    {
      ++ m_normals;
      if (m_normals == 3)
        m_normal_map = m_mesh.template add_property_map<Vertex_index, Vector>("v:normal").first;
      return true;
    }
    if (name == "red" ||
        name == "green" ||
        name == "blue")
    {
      ++ m_vcolors;
      if (m_vcolors == 3)
        m_vcolor_map = m_mesh.template add_property_map<Vertex_index, CGAL::Color>("v:color").first;
      return true;
    }
    return false;
  }

  bool has_simplex_specific_property (internal::PLY::PLY_read_number* property, Face_index)
  {
    const std::string& name = property->name();
    if (name == "vertex_indices" || name == "vertex_index")
    {
      CGAL_assertion (dynamic_cast<PLY_read_typed_list<boost::int32_t>*>(property)
                      || dynamic_cast<PLY_read_typed_list<boost::uint32_t>*>(property));
      m_index_tag  = name;
      m_use_int32_t = dynamic_cast<PLY_read_typed_list<boost::int32_t>*>(property);
      return true;
    }
    if (name == "red" ||
        name == "green" ||
        name == "blue")
    {
      ++ m_fcolors;
      if (m_fcolors == 3)
        m_fcolor_map = m_mesh.template add_property_map<Face_index, CGAL::Color>("f:color").first;
      return true;
    }

    return false;
  }

  bool has_simplex_specific_property (internal::PLY::PLY_read_number* property, Edge_index)
  {
    const std::string& name = property->name();
    if (name == "v0" || name == "v1")
      return true;
    return false;
  }

  bool has_simplex_specific_property (internal::PLY::PLY_read_number* property, Halfedge_index)
  {
    const std::string& name = property->name();
    if (name == "source" || name == "target")
      return true;
    return false;
  }

  void instantiate_vertex_properties (PLY_element& element)
  {
    m_map_v2v.reserve(element.number_of_items());
    instantiate_properties<Vertex_index> (element, m_vertex_properties);
  }

  void instantiate_face_properties (PLY_element& element)
  {
    instantiate_properties<Face_index> (element, m_face_properties);
  }

  void instantiate_edge_properties (PLY_element& element)
  {
    instantiate_properties<Edge_index> (element, m_edge_properties);
  }

  void instantiate_halfedge_properties (PLY_element& element)
  {
    instantiate_properties<Halfedge_index> (element, m_halfedge_properties);
  }

  template <typename Simplex>
  void instantiate_properties  (PLY_element& element,
                                std::vector<Abstract_ply_property_to_surface_mesh_property*>& properties)
  {
    for (std::size_t j = 0; j < element.number_of_properties(); ++ j)
    {
      internal::PLY::PLY_read_number* property = element.property(j);

      if (has_simplex_specific_property (property, Simplex()))
        continue;

      const std::string& name = property->name();

      if (dynamic_cast<PLY_read_typed_number<boost::int8_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::int8_t>(m_mesh,
                                                                             name));
      }
      else if (dynamic_cast<PLY_read_typed_number<boost::uint8_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::uint8_t>(m_mesh,
                                                                              name));
      }
      else if (dynamic_cast<PLY_read_typed_number<boost::int16_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::int16_t>(m_mesh,
                                                                              name));
      }
      else if (dynamic_cast<PLY_read_typed_number<boost::uint16_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::uint16_t>(m_mesh,
                                                                               name));
      }
      else if (dynamic_cast<PLY_read_typed_number<boost::int32_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::int32_t>(m_mesh,
                                                                              name));
      }
      else if (dynamic_cast<PLY_read_typed_number<boost::uint32_t>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, boost::uint32_t>(m_mesh,
                                                                               name));
      }
      else if (dynamic_cast<PLY_read_typed_number<float>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, float>(m_mesh,
                                                                     name));
      }
      else if (dynamic_cast<PLY_read_typed_number<double>*>(property))
      {
        properties.push_back
          (new PLY_property_to_surface_mesh_property<Simplex, double>(m_mesh,
                                                                      name));
      }
    }
  }

  void process_vertex_line (PLY_element& element)
  {
    Vertex_index vi;

    if (m_use_floats)
      process_line<float>(element, vi);
    else
      process_line<double>(element, vi);

    for (std::size_t i = 0; i < m_vertex_properties.size(); ++ i)
      m_vertex_properties[i]->assign (element, vi);
  }

  template <typename FT>
  void process_line (PLY_element& element, Vertex_index& vi)
  {
    FT x = (FT)0.,y = (FT)0., z = (FT)0.,
      nx = (FT)0., ny = (FT)0., nz = (FT)0.;
    element.assign (x, "x");
    element.assign (y, "y");
    element.assign (z, "z");
    Point point (x, y, z);
    vi = m_mesh.add_vertex(point);
    m_map_v2v.push_back(vi);

    if (m_normals == 3)
    {
      element.assign (nx, "nx");
      element.assign (ny, "ny");
      element.assign (nz, "nz");
      Vector normal (nx, ny, nz);
      m_normal_map[vi] = normal;
    }

    if (m_vcolors == 3)
    {
      unsigned char r, g, b;
      element.assign (r, "red");
      element.assign (g, "green");
      element.assign (b, "blue");
      m_vcolor_map[vi] = CGAL::Color (r, g, b);
    }
  }

  bool process_face_line (PLY_element& element)
  {
    Face_index fi = m_mesh.null_face();

    if (m_use_int32_t)
      process_line<boost::int32_t>(element, fi);
    else
      process_line<boost::uint32_t>(element, fi);

    if (fi == Surface_mesh::null_face())
      return false;

    for (std::size_t i = 0; i < m_face_properties.size(); ++ i)
      m_face_properties[i]->assign (element, fi);

    return true;
  }

  template <typename IntType>
  void process_line (PLY_element& element, Face_index& fi)
  {
    std::vector<IntType> indices;
    element.assign (indices, m_index_tag.c_str());
    std::vector<Vertex_index> vertices;
    vertices.reserve(indices.size());
    for (std::size_t i = 0; i < indices.size(); ++ i)
      vertices.push_back (m_map_v2v[std::size_t(indices[i])]);

    fi = m_mesh.add_face(vertices);
    if (fi == m_mesh.null_face())
      return;

    if (m_fcolors == 3)
    {
      unsigned char r, g, b;
      element.assign (r, "red");
      element.assign (g, "green");
      element.assign (b, "blue");
      m_fcolor_map[fi] = CGAL::Color (r, g, b);
    }
  }

  bool process_edge_line (PLY_element& element)
  {
    Edge_index ei = m_mesh.null_edge();

    if (m_use_int32_t)
      process_line<boost::int32_t>(element, ei);
    else
      process_line<boost::uint32_t>(element, ei);

    if (ei == Surface_mesh::null_edge())
      return false;

    for (std::size_t i = 0; i < m_edge_properties.size(); ++ i)
      m_edge_properties[i]->assign (element, ei);

    return true;
  }

  template <typename IntType>
  void process_line (PLY_element& element, Edge_index& ei)
  {
    IntType v0, v1;
    element.assign (v0, "v0");
    element.assign (v1, "v1");

    Halfedge_index hi = m_mesh.halfedge(m_map_v2v[std::size_t(v0)],
                                        m_map_v2v[std::size_t(v1)]);
    if (hi == m_mesh.null_halfedge())
      return;

    ei = m_mesh.edge (hi);
  }

  bool process_halfedge_line (PLY_element& element)
  {
    Halfedge_index hi = m_mesh.null_halfedge();

    if (m_use_int32_t)
      process_line<boost::int32_t>(element, hi);
    else
      process_line<boost::uint32_t>(element, hi);

    if (hi == Surface_mesh::null_halfedge())
      return false;

    for (std::size_t i = 0; i < m_halfedge_properties.size(); ++ i)
      m_halfedge_properties[i]->assign (element, hi);

    return true;
  }

  template <typename IntType>
  void process_line (PLY_element& element, Halfedge_index& hi)
  {
    IntType source, target;
    element.assign (source, "source");
    element.assign (target, "target");
    hi = m_mesh.halfedge(m_map_v2v[std::size_t(source)], m_map_v2v[std::size_t(target)]);
  }

};


template <typename Point>
bool fill_simplex_specific_header
(std::ostream& os, const Surface_mesh<Point>& sm,
 std::vector<Abstract_property_printer<typename Surface_mesh<Point>::Vertex_index>*>& printers,
 const std::string& prop)
{
  typedef Surface_mesh<Point> SMesh;
  typedef typename SMesh::Vertex_index VIndex;
  typedef typename Kernel_traits<Point>::Kernel Kernel;
  typedef typename Kernel::FT FT;
  typedef typename Kernel::Vector_3 Vector;
  typedef typename SMesh::template Property_map<VIndex, Point> Point_map;
  typedef typename SMesh::template Property_map<VIndex, Vector> Vector_map;
  typedef typename SMesh::template Property_map<VIndex, Color> Vcolor_map;

  if (prop == "v:connectivity" ||
      prop == "v:removed")
    return true;

  if (prop == "v:point")
  {
    if (boost::is_same<FT, float>::value)
    {
      os << "property float x" << std::endl
         << "property float y" << std::endl
         << "property float z" << std::endl;
    }
    else
    {
      os << "property double x" << std::endl
         << "property double y" << std::endl
         << "property double z" << std::endl;
    }
    printers.push_back (new Property_printer<VIndex,Point_map>(sm.points()));
    return true;
  }

  bool okay = false;
  if (prop == "v:normal")
  {
    Vector_map pmap;
    boost::tie (pmap, okay) = sm.template property_map<VIndex,Vector>(prop);
    if (okay)
    {
      if (boost::is_same<FT, float>::value)
      {
        os << "property float nx" << std::endl
           << "property float ny" << std::endl
           << "property float nz" << std::endl;
      }
      else
      {
        os << "property double nx" << std::endl
           << "property double ny" << std::endl
           << "property double nz" << std::endl;
      }
      printers.push_back (new Property_printer<VIndex,Vector_map>(pmap));
      return true;
    }
  }

  if (prop == "v:color")
  {
    Vcolor_map pmap;
    boost::tie (pmap, okay) = sm.template property_map<VIndex,Color>(prop);
    if (okay)
    {
      os << "property uchar red" << std::endl
         << "property uchar green" << std::endl
         << "property uchar blue" << std::endl
         << "property uchar alpha" << std::endl;

      printers.push_back (new Property_printer<VIndex,Vcolor_map>(pmap));
      return true;
    }
  }

  return false;
}

template <typename Point>
bool fill_simplex_specific_header
(std::ostream& os, const Surface_mesh<Point>& sm,
 std::vector<Abstract_property_printer<typename Surface_mesh<Point>::Face_index>*>& printers,
 const std::string& prop)
{
  typedef Surface_mesh<Point> SMesh;
  typedef typename SMesh::Face_index FIndex;
  typedef typename SMesh::template Property_map<FIndex, Color> Fcolor_map;

  if (prop == "f:connectivity" ||
      prop == "f:removed")
    return true;

  bool okay = false;
  if (prop == "f:color")
  {
    Fcolor_map pmap;
    boost::tie (pmap, okay) = sm.template property_map<FIndex,Color>(prop);
    if (okay)
    {
      os << "property uchar red" << std::endl
         << "property uchar green" << std::endl
         << "property uchar blue" << std::endl
         << "property uchar alpha" << std::endl;

      printers.push_back (new Property_printer<FIndex,Fcolor_map>(pmap));
      return true;
    }
  }
  return false;
}

template <typename Point>
bool fill_simplex_specific_header
(std::ostream& , const Surface_mesh<Point>& ,
 std::vector<Abstract_property_printer<typename Surface_mesh<Point>::Edge_index>*>& ,
 const std::string& prop)
{
  if (prop == "e:removed")
    return true;
  return false;
}

template <typename Point>
bool fill_simplex_specific_header
(std::ostream& , const Surface_mesh<Point>& ,
 std::vector<Abstract_property_printer<typename Surface_mesh<Point>::Halfedge_index>*>& ,
 const std::string& prop)
{
  if (prop == "h:connectivity")
    return true;
  return false;
}

template <typename Point>
std::string get_property_raw_name (const std::string& prop, typename Surface_mesh<Point>::Vertex_index)
{
  std::string name = prop;
  if (name.rfind("v:",0) == 0)
    name = std::string (prop.begin() + 2, prop.end());
  return name;
}

template <typename Point>
std::string get_property_raw_name (const std::string& prop, typename Surface_mesh<Point>::Face_index)
{
  std::string name = prop;
  if (name.rfind("f:",0) == 0)
    name = std::string (prop.begin() + 2, prop.end());
  return name;
}

template <typename Point>
std::string get_property_raw_name (const std::string& prop, typename Surface_mesh<Point>::Edge_index)
{
  std::string name = prop;
  if (name.rfind("e:",0) == 0)
    name = std::string (prop.begin() + 2, prop.end());
  return name;
}

template <typename Point>
std::string get_property_raw_name (const std::string& prop, typename Surface_mesh<Point>::Halfedge_index)
{
  std::string name = prop;
  if (name.rfind("h:",0) == 0)
    name = std::string (prop.begin() + 2, prop.end());
  return name;
}

template <typename Point, typename Simplex>
void fill_header (std::ostream& os, const Surface_mesh<Point>& sm,
                  std::vector<Abstract_property_printer<Simplex>*>& printers)
{
  typedef Surface_mesh<Point> SMesh;
  typedef typename SMesh::template Property_map<Simplex, boost::int8_t> Int8_map;
  typedef typename SMesh::template Property_map<Simplex, boost::uint8_t> Uint8_map;
  typedef typename SMesh::template Property_map<Simplex, boost::int16_t> Int16_map;
  typedef typename SMesh::template Property_map<Simplex, boost::uint16_t> Uint16_map;
  typedef typename SMesh::template Property_map<Simplex, boost::int32_t> Int32_map;
  typedef typename SMesh::template Property_map<Simplex, boost::uint32_t> Uint32_map;
  typedef typename SMesh::template Property_map<Simplex, boost::int64_t> Int64_map;
  typedef typename SMesh::template Property_map<Simplex, boost::uint64_t> Uint64_map;
  typedef typename SMesh::template Property_map<Simplex, float> Float_map;
  typedef typename SMesh::template Property_map<Simplex, double> Double_map;
  std::vector<std::string> prop = sm.template properties<Simplex>();

  for (std::size_t i = 0; i < prop.size(); ++ i)
  {
    if (fill_simplex_specific_header(os, sm, printers, prop[i]))
      continue;

    // Cut the "v:" prefix
    std::string name = get_property_raw_name<Point> (prop[i], Simplex());

    bool okay = false;
    {
      Int8_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::int8_t>(prop[i]);
      if (okay)
      {
        os << "property char " << name << std::endl;
        printers.push_back (new internal::PLY::Char_property_printer<Simplex,Int8_map>(pmap));
        continue;
      }
    }
    {
      Uint8_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::uint8_t>(prop[i]);
      if (okay)
      {
        os << "property uchar " << name << std::endl;
        printers.push_back (new internal::PLY::Char_property_printer<Simplex,Uint8_map>(pmap));
        continue;
      }
    }
    {
      Int16_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::int16_t>(prop[i]);
      if (okay)
      {
        os << "property short " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Int16_map>(pmap));
        continue;
      }
    }
    {
      Uint16_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::uint16_t>(prop[i]);
      if (okay)
      {
        os << "property ushort " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Uint16_map>(pmap));
        continue;
      }
    }
    {
      Int32_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::int32_t>(prop[i]);
      if (okay)
      {
        os << "property int " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Int32_map>(pmap));
        continue;
      }
    }
    {
      Uint32_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::uint32_t>(prop[i]);
      if (okay)
      {
        os << "property uint " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Uint32_map>(pmap));
        continue;
      }
    }
    {
      Int64_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::int64_t>(prop[i]);
      if (okay)
      {
        os << "property int " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Int64_map,boost::int32_t>(pmap));
        continue;
      }
    }
    {
      Uint64_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,boost::uint64_t>(prop[i]);
      if (okay)
      {
        os << "property uint " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Uint64_map,boost::uint32_t>(pmap));
        continue;
      }
    }
    {
      Float_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,float>(prop[i]);
      if (okay)
      {
        os << "property float " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Float_map>(pmap));
        continue;
      }
    }
    {
      Double_map pmap;
      boost::tie (pmap, okay) = sm.template property_map<Simplex,double>(prop[i]);
      if (okay)
      {
        os << "property double " << name << std::endl;
        printers.push_back (new internal::PLY::Simple_property_printer<Simplex,Double_map>(pmap));
        continue;
      }
    }
  }
}

} // namespace PLY
#endif

} // namespace internal

} // namespace CGAL


#endif // CGAL_SURFACE_MESH_IO_PLY