// Copyright (c) 2013 Technical University Braunschweig (Germany).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// You can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0+
//
//
// Author(s):  Michael Hemmer <michael.hemmer@cgal.org>
//             

#ifndef CGAL_TRIANGULAR_EXPANSION_VISIBILITY_2_H
#define CGAL_TRIANGULAR_EXPANSION_VISIBILITY_2_H

#include <CGAL/license/Visibility_2.h>


#include <CGAL/Arrangement_2.h>
#include <boost/shared_ptr.hpp>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <CGAL/Constrained_Delaunay_triangulation_2.h>
#include <CGAL/Arr_observer.h>
#include <CGAL/assertions.h>
#include <CGAL/use.h>

namespace CGAL {

template<class Arrangement_2_ , class RegularizationCategory = CGAL::Tag_true >
class Triangular_expansion_visibility_2 {
  typedef typename Arrangement_2_::Geometry_traits_2    Geometry_traits_2;
  typedef typename Geometry_traits_2::Kernel            K;

  typedef Triangular_expansion_visibility_2<
    Arrangement_2_, RegularizationCategory>             Self;

public:
  typedef Arrangement_2_                                Arrangement_2;
  typedef typename Arrangement_2::Traits_2              Traits_2;
  typedef typename Arrangement_2::Halfedge              Halfedge;
  typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle;
  typedef typename Arrangement_2::Halfedge_handle       Halfedge_handle;
  typedef typename Arrangement_2::Edge_const_iterator   Edge_const_iterator;
  typedef typename Arrangement_2::Ccb_halfedge_const_circulator
    Ccb_halfedge_const_circulator;
  typedef typename Arrangement_2::Ccb_halfedge_circulator
    Ccb_halfedge_circulator;
  typedef typename Arrangement_2::Face_const_handle     Face_const_handle;
  typedef typename Arrangement_2::Face_handle           Face_handle;
  typedef typename Arrangement_2::Vertex_const_handle   Vertex_const_handle;
  typedef typename Arrangement_2::Vertex_handle         Vertex_handle;

  typedef typename K::Point_2                           Point_2;
  typedef typename Geometry_traits_2::Ray_2             Ray_2;
  typedef typename Geometry_traits_2::Segment_2         Segment_2;
  typedef typename Geometry_traits_2::Line_2            Line_2;
  typedef typename Geometry_traits_2::Vector_2          Vector_2;
  typedef typename Geometry_traits_2::Direction_2       Direction_2;
  typedef typename Geometry_traits_2::FT                Number_type;
  typedef typename Geometry_traits_2::Object_2          Object_2;

  typedef RegularizationCategory                       Regularization_category;
  
  typedef CGAL::Tag_true                      Supports_general_polygon_category;
  typedef CGAL::Tag_true                      Supports_simple_polygon_category;

private:
  typedef CGAL::Triangulation_vertex_base_2<K>                     Vb;
  typedef CGAL::Constrained_triangulation_face_base_2<K>           Fb;
  typedef CGAL::Triangulation_data_structure_2<Vb,Fb>              TDS;
  typedef CGAL::No_intersection_tag                                Itag;
  typedef CGAL::Constrained_Delaunay_triangulation_2<K, TDS, Itag> CDT;

  typedef std::pair<Point_2,Point_2>                               Constraint;

  // Functor to create edge constraints for the CDT out of Halfedges
  struct Make_constraint
  {
      typedef Constraint                                            result_type;

      Constraint operator()(const Halfedge& edge) const {
          return std::make_pair(edge.source()->point(),
                                edge.target()->point());
      }
  };

  // Observer to track any changes of the attached arrangement.
  class Observer : public Arr_observer<Arrangement_2>
  {
      
      typedef Arr_observer<Arrangement_2>                           Base;
      typedef Observer                                              Self;


  public:
      bool has_changed;

      Observer() : Base(), has_changed(false)
      {}

      Observer(const Arrangement_2& arr)
          : Base(const_cast<Arrangement_2&>(arr)), has_changed(false)
      {}

      // Arr_observer interface

      void after_attach() { has_changed = false; }


      void after_global_change() { has_changed = true; }
      void after_create_vertex(Vertex_handle) { has_changed = true; }
      void after_create_boundary_vertex(Vertex_handle) { has_changed = true; }
      void after_create_edge(Halfedge_handle) { has_changed = true; }
      void after_modify_vertex(Vertex_handle) { has_changed = true; }
      void after_modify_edge(Halfedge_handle) { has_changed = true; }
      void after_split_edge(Halfedge_handle, Halfedge_handle) {
          has_changed = true; }
      void after_split_fictitious_edge(Halfedge_handle, Halfedge_handle) {
          has_changed = true; }
      void after_split_face(Face_handle, Face_handle, bool) {
          has_changed = true; }
      void after_split_outer_ccb(Face_handle, Ccb_halfedge_circulator,
                                 Ccb_halfedge_circulator) {
          has_changed = true; }
      void after_split_inner_ccb(Face_handle, Ccb_halfedge_circulator,
                                 Ccb_halfedge_circulator) {
          has_changed = true; }
      void after_add_outer_ccb(Ccb_halfedge_circulator) { has_changed = true; }
      void after_add_inner_ccb(Ccb_halfedge_circulator) { has_changed = true; }
      void after_add_isolated_vertex(Vertex_handle) { has_changed = true; }
      void after_merge_edge(Halfedge_handle) { has_changed = true; }
      void after_merge_fictitious_edge(Halfedge_handle) { has_changed = true; }
      void after_merge_face(Face_handle) { has_changed = true; }
      void after_merge_outer_ccb(Face_handle, Ccb_halfedge_circulator) {
          has_changed = true; }
      void after_merge_inner_ccb(Face_handle, Ccb_halfedge_circulator) {
          has_changed = true; }
      void after_move_outer_ccb(Ccb_halfedge_circulator) { has_changed = true; }
      void after_move_inner_ccb(Ccb_halfedge_circulator) { has_changed = true; }
      void after_move_isolated_vertex(Vertex_handle) { has_changed = true; }
      void after_remove_vertex() { has_changed = true; }
      void after_remove_edge() { has_changed = true; }
      void after_remove_outer_ccb(Face_handle) { has_changed = true; }
      void after_remove_inner_ccb(Face_handle) { has_changed = true; }
  };
  

private:
  const Arrangement_2* p_arr;

  // May change during visibility computation
  mutable Observer observer;
  mutable boost::shared_ptr<CDT> p_cdt;
  mutable std::vector<Segment_2> needles;

  // Copy constructor and assignment not supported
  Triangular_expansion_visibility_2(const Self&);
  Self& operator= (const Self& );


public: 
  Triangular_expansion_visibility_2() : p_arr(NULL){}

  /*! Constructor given an arrangement. */
  Triangular_expansion_visibility_2 (const Arrangement_2& arr)
    : p_arr(&arr), observer(arr)
  {
    init_cdt(); 
  }

  const std::string name() const { return std::string("T_visibility_2"); }


  bool is_attached() const {
    //std::cout << "is_attached" << std::endl;
    return (p_arr != NULL);
  }

  void attach(const Arrangement_2& arr) {
    if(p_arr != &arr){
      p_arr = &arr;
      observer.detach();
      observer.attach(const_cast<Arrangement_2&>(arr));
      init_cdt(); 
    }   
    //std::cout << "attach done" << std::endl;
  }

  void detach() {
    //std::cout << "detach" << std::endl;
    observer.detach();
    p_arr = NULL; 
    p_cdt.reset();
  }

  const Arrangement_2& arrangement_2() const {
    return *p_arr;
  }


  template <typename VARR>
  typename VARR::Face_handle
  compute_visibility(const Point_2& q,
                     const Face_const_handle face,
                     VARR& out_arr )
  const {
    //std::cout << "query in face interior" << std::endl;

    if(observer.has_changed) {
        init_cdt();
    }

    out_arr.clear();
    needles.clear();
    CGAL_USE(face);
    CGAL_assertion(!face->is_unbounded());


    std::vector<Point_2> raw_output;
    typename CDT::Face_handle fh = p_cdt->locate(q);

    raw_output.push_back(fh->vertex(1)->point());
    if(!p_cdt->is_constrained(get_edge(fh,0))){
      //std::cout<< "edge 0 is not constrained" << std::endl;
      expand_edge(
          q,
          fh->vertex(2)->point(),
          fh->vertex(1)->point(),
          fh,0,std::back_inserter(raw_output));
    }

    raw_output.push_back(fh->vertex(2)->point());
    if(!p_cdt->is_constrained(get_edge(fh,1))){
      //std::cout << "edge 1 is not constrained" << std::endl;
      expand_edge(
          q,
          fh->vertex(0)->point(),
          fh->vertex(2)->point(),
          fh,1,std::back_inserter(raw_output));
    }

    raw_output.push_back(fh->vertex(0)->point());
    if(!p_cdt->is_constrained(get_edge(fh,2))){
      //std::cout << "edge 2 is not constrained" << std::endl;
      expand_edge(
          q,
          fh->vertex(1)->point(),
          fh->vertex(0)->point(),
          fh,2,std::back_inserter(raw_output));
    }


    return output(raw_output,out_arr);
  }

  template <typename VARR>
  typename VARR::Face_handle
  compute_visibility(const Point_2& q,
                     const Halfedge_const_handle he,
                     VARR& out_arr)
  const {
    //std::cout << "visibility_region he" << std::endl;

    if(observer.has_changed) {
        init_cdt();
    }

    CGAL_assertion(!he->face()->is_unbounded());
    out_arr.clear();
    needles.clear();

    std::vector<Point_2> raw_output;
    typename CDT::Locate_type location;
    int index;
    typename CDT::Face_handle fh = p_cdt->locate(q,location,index);
    CGAL_assertion(location == CDT::EDGE || location == CDT::VERTEX);
    //the following code tries to figure out which triangle one should start in.


    if(location == CDT::EDGE){
      //std::cout << "query on edge" << std::endl;
      // this is the easy part, there are only two possible faces
      // index indicates the edge = vertex on the other side of the edge
      // the next vertex in cw order should be the target of given edge
      if(fh->vertex(p_cdt->cw(index))->point() != he->target()->point()){
        //std::cout << "need to swap face" << std::endl;
        // take face on the other side if this is not the case
        typename CDT::Face_handle nfh = fh->neighbor(index);
        index = nfh->index(fh);
        fh = nfh;
      }
      CGAL_assertion(fh->vertex(p_cdt->cw(index))->point() == he->target()->point());
      CGAL_assertion(!p_cdt->is_infinite(fh->vertex(index)));


      // output the edge the query lies on
      raw_output.push_back(he->source()->point());
      raw_output.push_back(he->target()->point());

      if(!p_cdt->is_constrained(get_edge(fh,p_cdt->ccw(index)))){
        expand_edge(
            q,
            fh->vertex(index)->point(), //left
            he->target()->point()        , //right
            fh,
            p_cdt->ccw(index),
            std::back_inserter(raw_output));
      }
      raw_output.push_back(fh->vertex(index)->point());

      if(!p_cdt->is_constrained(get_edge(fh,p_cdt->cw(index)))){
        expand_edge(
            q,
            he->source()->point()        , //left
            fh->vertex(index)->point(), //right
            fh,
            p_cdt->cw(index),
            std::back_inserter(raw_output));
      }
    }

    if(location == CDT::VERTEX){
      //std::cout << "query on vertex" << std::endl;

      //bool query_point_on_vertex_is_not_working_yet = false;
      //CGAL_assertion(query_point_on_vertex_is_not_working_yet);

      CGAL_assertion(q  ==  he->target()->point());
      CGAL_assertion(fh->vertex(index)->point() ==  he->target()->point());

      // push points that are seen anyway
      // raw_output.push_back(he->source()->point()); inserted last
      raw_output.push_back(he->target()->point());
      raw_output.push_back(he->next()->target()->point());

      // now start in the triangle that contains he->next()
      while(
            p_cdt->is_infinite(fh->vertex(p_cdt->ccw(index))) ||
            he->next()->target()->point() !=
            fh->vertex(p_cdt->ccw(index))->point()
            )
      {
        typename CDT::Face_handle nfh = fh->neighbor(p_cdt->ccw(index));
        int nindex = nfh->index(fh);
        index = p_cdt->ccw(nindex);
        fh = nfh;
        CGAL_assertion(he->target()->point() == fh->vertex(index)->point());
      }


      CGAL_assertion(he->next()->source()->point() == fh->vertex(index)->point());
      CGAL_assertion(he->next()->target()->point() ==
             fh->vertex(p_cdt->ccw(index))->point());
      CGAL_assertion(!p_cdt->is_infinite(fh));
      CGAL_assertion(p_cdt->is_constrained(get_edge(fh,p_cdt->cw(index))));

      while(he->source()->point() != fh->vertex(p_cdt->ccw(index))->point()){

        if(!p_cdt->is_constrained(get_edge(fh,index))){
          expand_edge(
              q,
              fh->vertex(p_cdt-> cw(index))->point(), //left
              fh->vertex(p_cdt->ccw(index))->point(), //right
              fh,
              index,
              std::back_inserter(raw_output));
        }
        // push left end point of edge into output
        raw_output.push_back(fh->vertex(p_cdt-> cw(index))->point());

        // take the next triangle around q in ccw order
        typename CDT::Face_handle nfh = fh->neighbor(p_cdt->ccw(index));
        int nindex = nfh->index(fh);
        index = p_cdt->ccw(nindex);
        fh = nfh;
        CGAL_assertion(fh->vertex(index)->point() ==  he->target()->point());
      }
    }
    return output(raw_output,out_arr);
  }



private:

  typename CDT::Edge get_edge(typename CDT::Face_handle fh, int i) const {
    return std::make_pair(fh,i);
  }

  Point_2 ray_seg_intersection(
      const Point_2& q, const Point_2& b, // the ray 
      const Point_2& s, const Point_2& t  // the segment
    ) const {

    Ray_2 ray(q,b);
    Segment_2 seg(s,t);
    CGAL_assertion(typename K::Do_intersect_2()(ray,seg));
    CGAL::Object obj = typename K::Intersect_2()(ray,seg); 
    Point_2 result =  object_cast<Point_2>(obj);
    return result; 
  }

  void collect_needle(
      const Point_2& q, 
      const typename CDT::Vertex_handle vh, 
      const typename CDT::Face_handle fh, 
      int index)
  const {

    // the expanded edge should not be constrained 
    CGAL_assertion(!p_cdt->is_constrained(get_edge(fh,index)));
    CGAL_assertion(!p_cdt->is_infinite(fh));
    // go into the new face  
    const typename CDT::Face_handle nfh(fh->neighbor(index)); 
    CGAL_assertion(!p_cdt->is_infinite(nfh));

    // get indices of neighbors 
    int nindex = nfh->index(fh); // index of new vertex and old face 
    int rindex = p_cdt->ccw(nindex); // index of face behind right edge 
    int lindex = p_cdt-> cw(nindex); // index of face behind left edge 
    
    // get vertices seen from entering edge 
    const typename CDT::Vertex_handle nvh(nfh->vertex(nindex));
    const typename CDT::Vertex_handle rvh(nfh->vertex(p_cdt->cw (nindex)));
    const typename CDT::Vertex_handle lvh(nfh->vertex(p_cdt->ccw(nindex)));
    CGAL_assertion(!p_cdt->is_infinite(nvh));
    CGAL_assertion(!p_cdt->is_infinite(lvh));
    CGAL_assertion(!p_cdt->is_infinite(rvh));
    
    // get edges seen from entering edge 
    typename CDT::Edge re = get_edge(nfh,p_cdt->ccw(nindex));
    typename CDT::Edge le = get_edge(nfh,p_cdt-> cw(nindex));
     
    // do orientation computation once for new vertex 
    typename K::Orientation_2 orientation = 
      p_cdt->geom_traits().orientation_2_object();
    CGAL::Orientation orient = orientation(q,vh->point(),nvh->point());
    
    
    //std::cout << "\n collect_needle" <<std::endl;
    //std::cout << "q             "<< q << std::endl ;
    //std::cout << "vh->point()  "<<  vh->point() << std::endl;  
    //std::cout << "lvh->point()  "<< lvh->point() << std::endl ;
    //std::cout << "nvh->point()  "<< nvh->point() << std::endl ;
    //std::cout << "rvh->point()  "<< rvh->point() << std::endl<< std::endl;


    switch ( orient ) {
    case CGAL::COUNTERCLOCKWISE:
      // looking on to the right edge 
      if(p_cdt->is_constrained(re)) {
        if(vh != rvh) {
          Point_2 p = ray_seg_intersection(q, vh->point(),
                                           nvh->point(), rvh->point());
          //std::cout << vh->point() <<" -1- "<< p <<std::endl; 
          needles.push_back(Segment_2(vh->point(),p));
        }
      } else {
        collect_needle(q,vh,nfh,rindex);
      }
      break;
    case CGAL::CLOCKWISE:
      // looking on to the left edge 
      if(p_cdt->is_constrained(le)){
        if(vh != lvh){
          Point_2 p = ray_seg_intersection(q, vh->point(),
                                           nvh->point(), lvh->point());
          //std::cout << vh->point() <<" -2- "<< p <<std::endl; 
          needles.push_back(Segment_2(vh->point(),p));
        }
      } else {
        collect_needle(q,vh,nfh,lindex);
      }      
      break;
    default:
      CGAL_assertion(orient == CGAL::COLLINEAR);
      // looking on nvh, so it must be reported 
      // if it wasn't already (triangles rotate around vh)    
      if(vh != nvh){
        //std::cout << vh->point() <<" -3- "<< nvh->point() <<std::endl; 
        needles.push_back(Segment_2(vh->point(),nvh->point())); 
      }
      // but we may also contiue looking along the vertex 
      if(!p_cdt->is_constrained(re)) {
        collect_needle(q,nvh,nfh,rindex);
      }
      if(!p_cdt->is_constrained(le)) {
        collect_needle(q,nvh,nfh,lindex);
      }
      break;
    }
  }

  template<class OIT> 
  OIT expand_edge(
      const Point_2& q, 
      const Point_2& left, 
      const Point_2& right, 
      typename CDT::Face_handle fh, 
      int index, 
      OIT oit)
  const {

    // the expanded edge should not be constrained 
    CGAL_assertion(!p_cdt->is_constrained(get_edge(fh,index)));
    CGAL_assertion(!p_cdt->is_infinite(fh));
    
    // go into the new face  
    const typename CDT::Face_handle nfh(fh->neighbor(index)); 
    CGAL_assertion(!p_cdt->is_infinite(nfh));

    // get indices of neighbors 
    int nindex = nfh->index(fh); // index of new vertex and old face 
    int rindex = p_cdt->ccw(nindex); // index of face behind right edge 
    int lindex = p_cdt-> cw(nindex); // index of face behind left edge 
    
    // get vertices seen from entering edge 
    const typename CDT::Vertex_handle nvh(nfh->vertex(nindex));
    const typename CDT::Vertex_handle rvh(nfh->vertex(p_cdt->cw (nindex)));
    const typename CDT::Vertex_handle lvh(nfh->vertex(p_cdt->ccw(nindex)));
    CGAL_assertion(!p_cdt->is_infinite(nvh));
    CGAL_assertion(!p_cdt->is_infinite(lvh));
    CGAL_assertion(!p_cdt->is_infinite(rvh));
    
    // get edges seen from entering edge 
    typename CDT::Edge re = get_edge(nfh,p_cdt->ccw(nindex));
    typename CDT::Edge le = get_edge(nfh,p_cdt-> cw(nindex));
     
    // do orientation computation once for new vertex 
    typename K::Orientation_2 orientation = 
      p_cdt->geom_traits().orientation_2_object();
    CGAL::Orientation ro = orientation(q,right,nvh->point());
    CGAL::Orientation lo = orientation(q,left ,nvh->point());
    
    CGAL_assertion(typename K::Orientation_2()(q,left ,lvh->point())
           != CGAL::CLOCKWISE);
    CGAL_assertion(typename K::Orientation_2()(q,right,rvh->point())
           != CGAL::COUNTERCLOCKWISE);

    //std::cout << (ro == CGAL::COUNTERCLOCKWISE) << " " <<
    //(lo == CGAL::CLOCKWISE) << std::endl;
    
    //right edge is seen if new vertex is counter clockwise of right boarder 
    if(ro == CGAL::COUNTERCLOCKWISE){
      if(p_cdt->is_constrained(re)){
        // the edge is constrained
        // report intersection with right boarder ray 
        // if it is not already the right vertex (already reported)
        if(right != rvh->point()){
          *oit++ = ray_seg_intersection(q,right,nvh->point(),rvh->point());
        }
        
        // then report intersection with left boarder if it exists
        if(lo == CGAL::COUNTERCLOCKWISE){
          *oit++ = ray_seg_intersection(q,left,nvh->point(),rvh->point());
        }
      }else{
        // the edge is not a constrained 
        if(lo == CGAL::COUNTERCLOCKWISE){
          // no split needed and return 
          //std::cout<< "h1"<< std::endl;
          oit = expand_edge(q,left,right,nfh,rindex,oit);
          //std::cout<< "h1 done"<< std::endl;
          return oit;          
        }else{
          // spliting at new vertex 
          //std::cout<< "h2"<< std::endl;
          *oit++ = expand_edge(q,nvh->point(),right,nfh,rindex,oit);
          //std::cout<< "h2 done"<< std::endl;
        }        
      }
    }
    

    //std::cout << "q             "<< q << std::endl ;
    //std::cout << "lvh->point()  "<< lvh->point() << std::endl;  
    //std::cout << "left          "<< left << std::endl  ;
    //std::cout << "nvh->point()  "<< nvh->point() << std::endl ;
    //std::cout << "right         "<< right << std::endl ;
    //std::cout << "rvh->point()  "<< rvh->point() << std::endl<< std::endl;
    
    
    // determin whether new vertex needs to be reported 
    if(ro != CGAL::CLOCKWISE && lo != CGAL::COUNTERCLOCKWISE){
      *oit++ = nvh->point(); 
    }
    if(!Regularization_category::value){
      CGAL_assertion(!(ro == CGAL::COLLINEAR && lo == CGAL::COLLINEAR));
      // we have to check whether a needle starts here. 
      if(p_cdt->is_constrained(le) && !p_cdt->is_constrained(re)
              && ro == CGAL::COLLINEAR)
        collect_needle(q,nvh,nfh,rindex);

      if(p_cdt->is_constrained(re) && !p_cdt->is_constrained(le)
              && lo == CGAL::COLLINEAR)
        collect_needle(q,nvh,nfh,lindex);    
    }

    //left edge is seen if new vertex is clockwise of left boarder 
    if(lo == CGAL::CLOCKWISE){
      if(p_cdt->is_constrained(le)){
        // the edge is constrained
        // report interesection with right boarder if exists 
        if(ro == CGAL::CLOCKWISE){
          *oit++ = ray_seg_intersection(q,right,nvh->point(),lvh->point());
        }
        // then report intersection with left boarder ray 
        // if it is not already the left vertex (already reported)
        if(left != lvh->point()){
          *oit++ = ray_seg_intersection(q,left,nvh->point(),lvh->point());          
        }
        return oit; 
      }else{
        // the edge is not a constrained 
        if(ro == CGAL::CLOCKWISE){
          // no split needed and return
          //std::cout<< "h3"<< std::endl;
          oit = expand_edge(q,left,right,nfh,lindex,oit);
          //std::cout<< "h3 done"<< std::endl;
          return oit; 
        }else{
          // spliting at new vertex 
          //std::cout<< "h4"<< std::endl;
          oit = expand_edge(q,left,nvh->point(),nfh,lindex,oit);
          //std::cout<< "h4 done"<< std::endl;
          return oit;          
        }        
      }
    }
    
    return oit;
  }


  template <typename VARR> 
  typename VARR::Face_handle 
  output(std::vector<Point_2>& raw_output, VARR& out_arr) const {

    if(!needles.empty()){
      std::vector<Segment_2> segments(needles.begin(),needles.end()); 
      for(unsigned int i = 0; i < raw_output.size(); i++){
//      //std::cout <<  raw_output[i] << " -- " 
//                <<  raw_output[(i+1)%raw_output.size()] << std::endl; 
        segments.push_back(Segment_2(raw_output[i],
                                     raw_output[(i+1) % raw_output.size()]));
      }

      CGAL::insert_non_intersecting_curves(out_arr,
                                           segments.begin(),
                                           segments.end());

    } else {
      typename VARR::Vertex_handle v_last, v_first;
      v_last = v_first = 
        out_arr.insert_in_face_interior(raw_output[0],out_arr.unbounded_face());
      
      for(unsigned int i = 0; i < raw_output.size()-1; i++){
//      std::cout <<  raw_output[i] << " -- "
//                <<  raw_output[(i+1)%raw_output.size()] << std::endl;
        if(raw_output[i] < raw_output[(i+1)]){
          v_last = out_arr.insert_from_left_vertex (
                             Segment_2(raw_output[i], raw_output[i+1]), v_last
                           )->target();
        } else {
          v_last = out_arr.insert_from_right_vertex(
                             Segment_2(raw_output[i], raw_output[i+1]), v_last
                           )->target();
        }        
      }
      out_arr.insert_at_vertices(
                Segment_2(raw_output.front(), raw_output.back()),
                v_last, v_first
              );
    }

    CGAL_assertion(out_arr.number_of_faces() == 2);

    if(out_arr.faces_begin()->is_unbounded())
      return ++out_arr.faces_begin();
    else
      return out_arr.faces_begin();
  }

  void init_cdt() const {
    //std::cout<< "==============" <<std::endl;
    //std::cout<< "Input Polygon:" <<std::endl;

    typedef typename boost::transform_iterator<Make_constraint,
                                               Edge_const_iterator>        Iter;

    Iter begin = boost::make_transform_iterator(p_arr->edges_begin(),
                                                Make_constraint());

    Iter end = boost::make_transform_iterator(p_arr->edges_end(),
                                              Make_constraint());

    //std::cout << "init_cdt new CDT" << std::endl;
    p_cdt = boost::shared_ptr<CDT>(new CDT(begin, end));
    observer.has_changed = false;
    //std::cout << "init_cdt done" << std::endl;
    //std::cout << std::endl;
  }
};

} // namespace CGAL

#endif // CGAL_TRIANGULAR_EXPANSION_VISIBILITY_2_H
