#include "WCPData/DynamicToyPointCloud.h"

bool sortbysec(const std::pair<WCPPID::PR3DCluster*,double> &a,
	       const std::pair<WCPPID::PR3DCluster*,double> &b){
  return (a.second > b.second);
}

bool sortbysec1(const std::pair<WCPPID::ProtoSegment*,double> &a,
	       const std::pair<WCPPID::ProtoSegment*,double> &b){
  return (a.second > b.second);
}

void WCPPID::NeutrinoID::deghosting(){
  // std::cout << "B " << std::endl;
  deghost_clusters();

  //std::cout << "A " << std::endl;
  deghost_segments();
  //std::cout << "C " << std::endl;
  std::set<WCPPID::PR3DCluster*> temp_clusters;
  for (auto it = map_cluster_main_vertices.begin(); it!= map_cluster_main_vertices.end(); it++){
    WCPPID::PR3DCluster *cluster = it->first;
    WCPPID::ProtoVertex *vertex = it->second;
    if (map_vertex_segments.find(vertex)==map_vertex_segments.end()){
      temp_clusters.insert(cluster);
    }
  }
  for (auto it = temp_clusters.begin(); it != temp_clusters.end(); it++){
    map_cluster_main_vertices.erase(*it);
  }
  
}

void WCPPID::NeutrinoID::deghost_segments(){
  // deghost segments ....
  TPCParams& mp = Singleton<TPCParams>::Instance();
  double pitch_u = mp.get_pitch_u();
  double pitch_v = mp.get_pitch_v();
  double pitch_w = mp.get_pitch_w();
  double angle_u = mp.get_angle_u();
  double angle_v = mp.get_angle_v();
  double angle_w = mp.get_angle_w();
  double time_slice_width = mp.get_ts_width();

  DynamicToyPointCloud global_point_cloud(angle_u,angle_v,angle_w);
  DynamicToyPointCloud global_steiner_point_cloud(angle_u,angle_v,angle_w);
  DynamicToyPointCloud global_skeleton_cloud(angle_u,angle_v,angle_w);

  // order cluster from longest to shortest ...
  std::map<int, WCPPID::ProtoSegmentSelection> map_cluster_id_segments;  // ID segments
  std::map<WCPPID::PR3DCluster*, double> cluster_length_map;
  WCPPID::PR3DClusterSelection ordered_clusters;
  order_clusters(ordered_clusters, map_cluster_id_segments, cluster_length_map);


  // std::cout << all_clusters.size() << std::endl;
  for (size_t i=0;i!=all_clusters.size();i++){
    if (cluster_length_map.find(all_clusters.at(i)) != cluster_length_map.end()) continue;
    global_point_cloud.AddPoints(all_clusters.at(i)->get_point_cloud());    
  }
  if (global_point_cloud.get_num_points() ==0) return;
  //  std::cout << global_point_cloud.get_num_points() << std::endl;
  // dist cut ...
  double dis_cut = 1.2*units::cm;
  
  for (size_t i=0;i!= ordered_clusters.size(); i++){
    // order segments from long to low
    WCPPID::ProtoSegmentSelection ordered_segments;
    order_segments(ordered_segments, map_cluster_id_segments[ordered_clusters.at(i)->get_cluster_id()]);


    for (size_t j=0;j!=ordered_segments.size(); j++){
      WCPPID::ProtoSegment *sg = ordered_segments.at(j);
      bool flag_add_seg = true;
      //  std::cout << global_point_cloud.get_num_points() << " " << global_steiner_point_cloud.get_num_points() << " " << global_skeleton_cloud.get_num_points() << std::endl;
      
      std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> pair_vertices = find_vertices(sg);
      double medium_dQ_dx = sg->get_medium_dQ_dx();
      double length = sg->get_length();
      int start_n = map_vertex_segments[pair_vertices.first].size();
      int end_n = map_vertex_segments[pair_vertices.second].size();
      
      if ((start_n==1 || end_n == 1) && medium_dQ_dx < 1.1 * 43e3/units::cm && length > 3.6*units::cm){
	int num_dead[3]={0,0,0};
	int num_unique[3]={0,0,0};
	int num_total_points = 0;
	  
	PointVector& pts = sg->get_point_vec();
	num_total_points += pts.size();
	
	for (size_t k=0;k!=pts.size();k++){
	  Point test_point = pts.at(k);

	  
	  
	  bool flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,0);
	  
	  
	  if (!flag_dead){
	    bool flag_in = false;
	    
	    std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 0);
	    
	   
	    
	    if (std::get<0>(results)<=dis_cut*2./3.) flag_in = true;
	    if (global_steiner_point_cloud.get_num_points()!=0){
	      results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 0);
	      if (std::get<0>(results)<=dis_cut*2./3.) flag_in = true;
	    }
	    if ( global_skeleton_cloud.get_num_points()!=0){
	      results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 0);
	      if (std::get<0>(results)> dis_cut*3./4.) flag_in = true;
	    }
	    if (!flag_in) num_unique[0]++;
	  }else{
	    num_dead[0]++;
	  }
	    

	  // V plane ...
	  flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,1);
	  if (!flag_dead){
	    bool flag_in = false;
	    std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 1);
	    if (std::get<0>(results)<=dis_cut*2./3.) flag_in = true;
	    if (global_steiner_point_cloud.get_num_points()!=0){
	      results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 1);
	      if (std::get<0>(results)<=dis_cut*2/3.) flag_in = true;
	    }
	    if ( global_skeleton_cloud.get_num_points()!=0){
	      results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 1);
	      if (std::get<0>(results)<=dis_cut*3./4.) flag_in = true;
	    }
	    if (!flag_in) num_unique[1]++;
	  }else{
	    num_dead[1]++;
	  }
	    
	  // W plane ...
	  flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,2);
	  if (!flag_dead){
	    bool flag_in = false;
	    std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 2);
	    // std::cout << "A: " << std::get<0>(results)/units::cm << std::endl;
	    if (std::get<0>(results)<=dis_cut*2./3.) flag_in = true;
	    if (global_steiner_point_cloud.get_num_points()!=0){
	      results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 2);
	      //std::cout << "B: " << std::get<0>(results)/units::cm << std::endl;
	      if (std::get<0>(results)<=dis_cut*2./3.) flag_in = true;
	    }
	    if ( global_skeleton_cloud.get_num_points()!=0){
	      results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 2);
	      //std::cout << "C: " << std::get<0>(results)/units::cm << std::endl;
	      if (std::get<0>(results)<=dis_cut*3./4.) flag_in = true;
	    }
	    if (!flag_in) num_unique[2]++;
	  }else{
	    num_dead[2]++;
	  }
	  
	}  
	
	//	std::cout << sg->get_cluster_id() << " " << sg->get_id() << " " <<start_n << " " << end_n << " " << pts.size() << " " << medium_dQ_dx/(43e3/units::cm) << " " << length/units::cm << " " << num_dead[0] << " " << num_dead[1] << " " << num_dead[2] << " " << num_unique[0] << " " << num_unique[1] << " " << num_unique[2] << " " << num_total_points<< std::endl;
	if (num_unique[0] + num_unique[1] + num_unique[2] == 0){
	  flag_add_seg = false;
	}
      }
	
      if (flag_add_seg){
	global_skeleton_cloud.AddPoints(sg->get_point_vec());
      }else{
	// protect main vertex ...
	
	WCPPID::PR3DCluster *tmp_cluster = map_segment_cluster[sg];
	if (map_cluster_main_vertices.find(tmp_cluster) != map_cluster_main_vertices.end()){
	  WCPPID::ProtoVertex *tmp_vtx = map_cluster_main_vertices[tmp_cluster];
	  if (map_vertex_segments[tmp_vtx].find(sg) != map_vertex_segments[tmp_vtx].end() && map_vertex_segments[tmp_vtx].size()==1){
	    flag_add_seg = true;
	  }
	}
	
	if (flag_add_seg){
	  global_skeleton_cloud.AddPoints(sg->get_point_vec());
	}else{
	  std::cout << "Remove Cluster ID " << sg->get_cluster_id() << " segment id " << sg->get_id() << std::endl;
	  // remove segment
	  del_proto_segment(sg);
	}
      }
    }
    
    
    
    // add points in ...
    global_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud());
    global_steiner_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud_steiner());
  }


  
  // remove vertices ...
  WCPPID::ProtoVertexSelection tmp_vertices;
  for (auto it1 = map_vertex_segments.begin(); it1!=map_vertex_segments.end(); it1++){
    if (it1->second.size()==0) tmp_vertices.push_back(it1->first);
  }
  for (auto it1 = tmp_vertices.begin(); it1!=tmp_vertices.end(); it1++){
    del_proto_vertex(*it1);
  }
}


void WCPPID::NeutrinoID::deghost_clusters(){
  std::map<int, WCPPID::ProtoSegmentSelection> map_cluster_id_segments;  // ID segments
  std::map<WCPPID::PR3DCluster*, double> cluster_length_map;
  WCPPID::PR3DClusterSelection ordered_clusters;
  order_clusters(ordered_clusters, map_cluster_id_segments, cluster_length_map);
  
  TPCParams& mp = Singleton<TPCParams>::Instance();
  double pitch_u = mp.get_pitch_u();
  double pitch_v = mp.get_pitch_v();
  double pitch_w = mp.get_pitch_w();
  double angle_u = mp.get_angle_u();
  double angle_v = mp.get_angle_v();
  double angle_w = mp.get_angle_w();
  double time_slice_width = mp.get_ts_width();
  
  DynamicToyPointCloud global_point_cloud(angle_u,angle_v,angle_w);
  DynamicToyPointCloud global_steiner_point_cloud(angle_u,angle_v,angle_w);
  DynamicToyPointCloud global_skeleton_cloud(angle_u,angle_v,angle_w);

  for (size_t i=0;i!=all_clusters.size();i++){
    if (cluster_length_map.find(all_clusters.at(i)) != cluster_length_map.end()) continue;
    global_point_cloud.AddPoints(all_clusters.at(i)->get_point_cloud());
  }
  
  
  std::vector<WCPPID::PR3DCluster*> to_be_removed_clusters;

  for (size_t i=0;i!= ordered_clusters.size(); i++){
    //  std::cout << i << " " << ordered_clusters.size() << std::endl;
    if (i==0){
      // fill anyway ...
      global_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud());
      global_steiner_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud_steiner());
      auto it = map_cluster_id_segments.find(ordered_clusters.at(i)->get_cluster_id());
      if (it != map_cluster_id_segments.end()){
	for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++){
	  global_skeleton_cloud.AddPoints((*it1)->get_point_vec());
	}
      }
    }else{
      WCPPID::PR3DCluster *cluster = ordered_clusters.at(i);
      int num_dead[3]={0,0,0};
      int num_unique[3]={0,0,0};
      int num_total_points = 0;
      // dist cut ...
      double dis_cut = 1.2*units::cm;
      auto it = map_cluster_id_segments.find(ordered_clusters.at(i)->get_cluster_id());

      if (it != map_cluster_id_segments.end()){
	for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++){
	  PointVector& pts = (*it1)->get_point_vec();
	  num_total_points += pts.size();
	  for (size_t j=0;j!=pts.size();j++){
	    Point test_point = pts.at(j);
	    bool flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,0);
	    if (!flag_dead){
	      std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 0);
	      if (std::get<0>(results)<=dis_cut/2.){
	      }else{
		results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 0);
		if (std::get<0>(results)<=dis_cut/3.*2.){
		}else{
		  results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 0);
		  if (std::get<0>(results)<=dis_cut*6/4.){
		  }else{
		    num_unique[0]++;
		  }
		}
	      }
	    }else{
	      num_dead[0]++;
	    }

	  
	    // V plane ...
	    flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,1);
	    if (!flag_dead){
	      std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 1);
	      //std::cout << "A: " << std::get<0>(results)/units::cm << " ";
	      if (std::get<0>(results)<=dis_cut/2.){
	      }else{
		results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 1);
		//std::cout << std::get<0>(results)/units::cm << " ";
		if (std::get<0>(results)<=dis_cut/3.*2.){
		}else{
		  results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 1);
		  //  std::cout  << std::get<0>(results)/units::cm << " ";
		  if (std::get<0>(results)<=dis_cut*6/4.){
		  }else{
		    num_unique[1]++;
		  }
		}
	      }
	      //	      std::cout << std::endl;
	    }else{
	      num_dead[1]++;
	    }

	    // W plane ...
	    flag_dead = ct_point_cloud->get_closest_dead_chs(test_point,2);
	    //std::cout << test_point.z << " " << flag_dead << std::endl;
	    if (!flag_dead){
	      std::tuple<double, WCP::PR3DCluster*, size_t> results = global_point_cloud.get_closest_2d_point_info(test_point, 2);
	      if (std::get<0>(results)<=dis_cut/2.){
	      }else{
		results = global_steiner_point_cloud.get_closest_2d_point_info(test_point, 2);
		if (std::get<0>(results)<=dis_cut/3.*2.){
		}else{
		  results = global_skeleton_cloud.get_closest_2d_point_info(test_point, 2);
		  if (std::get<0>(results)<=dis_cut*6/4.){
		  }else{
		    num_unique[2]++;
		  }
		}
	      }
	    }else{
	      num_dead[2]++;
	    }
	    
	    
	  }
	} // loop over segments
      }else{
	// no segments identified ...
	
      }
      
      bool flag_add = true;
      
      double unique_percent_u = num_unique[0]*1.0/num_total_points;
      double unique_percent_v = num_unique[1]*1.0/num_total_points;
      double unique_percent_w = num_unique[2]*1.0/num_total_points;

      double dead_percent_u = num_dead[0]*1.0/num_total_points;
      double dead_percent_v = num_dead[1]*1.0/num_total_points;
      double dead_percent_w = num_dead[2]*1.0/num_total_points;
      
      double max_unique_percent = std::max(unique_percent_u, unique_percent_v);
      max_unique_percent = std::max(max_unique_percent, unique_percent_w);
      double min_unique_percent = std::min(unique_percent_u, unique_percent_v);
      min_unique_percent = std::min(min_unique_percent, unique_percent_w);
      double ave_unique_percent = (unique_percent_u + unique_percent_v + unique_percent_w)/3.;
      double max_dead_percent = std::max(dead_percent_u, dead_percent_v);
      max_dead_percent = std::max(max_dead_percent, dead_percent_w);
      
      
      
      if (max_dead_percent >= 0.8 && max_unique_percent <= 0.35 && ave_unique_percent <= 0.16 && min_unique_percent <= 0.08 ||
	  max_unique_percent <= 0.1 && ave_unique_percent <= 0.05 && min_unique_percent <= 0.025 ||
	  max_dead_percent < 0.8 && max_dead_percent >=0.7 && max_unique_percent <= 0.2 && ave_unique_percent <= 0.1 && min_unique_percent <= 0.05)
	flag_add = false;

      //      if(!flag_add)
      if ((num_dead[0]==num_total_points || num_dead[1]==num_total_points || num_dead[2]==num_total_points) // one plane must be dead ...
	  &&(num_unique[0]==0 && num_unique[1]==0 || num_unique[0]==0 && num_unique[2]==0 || num_unique[2]==0 && num_unique[1]==0) // two plane's unique are zero
	  && flag_add && max_unique_percent < 0.75) // the rest is smaller than 75% 
	flag_add = false;
      //	std::cout << flag_add << " " << cluster->get_cluster_id() << " " << num_total_points << " " << num_dead[0] << " " << num_dead[1] << " " << num_dead[2] << " " << num_unique[0] << " " << num_unique[1] << " " << num_unique[2] << " " << max_unique_percent << " " << min_unique_percent << " " << ave_unique_percent << " " << max_dead_percent << std::endl;
      
      if (flag_add){
	global_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud());
	global_steiner_point_cloud.AddPoints(ordered_clusters.at(i)->get_point_cloud_steiner());
	auto it = map_cluster_id_segments.find(ordered_clusters.at(i)->get_cluster_id());
	if (it != map_cluster_id_segments.end()){
	  for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++){
	    global_skeleton_cloud.AddPoints((*it1)->get_point_vec());
	  }
	}
      }else{
	to_be_removed_clusters.push_back(cluster);
      }
      
    }
  } // loop over cluster


  //  std::cout << to_be_removed_clusters.size() << std::endl;
  
  for (auto it = to_be_removed_clusters.begin(); it!= to_be_removed_clusters.end(); it++){
    auto it2 = map_cluster_id_segments.find((*it)->get_cluster_id());
    if (it2 != map_cluster_id_segments.end()){
      //  std::cout << it2->second.size() << std::endl;
      for (auto it1 = it2->second.begin(); it1 != it2->second.end(); it1++){
    	del_proto_segment(*it1);
      }
    }
  }
  
  
  WCPPID::ProtoVertexSelection tmp_vertices;
  for (auto it1 = map_vertex_segments.begin(); it1!=map_vertex_segments.end(); it1++){
    if (it1->second.size()==0) tmp_vertices.push_back(it1->first);
  }
  //  std::cout << "A: " << tmp_vertices.size() << std::endl;
  for (auto it1 = tmp_vertices.begin(); it1!=tmp_vertices.end(); it1++){
    //std::cout << (*it1)->get_id() << " " << (*it1)->get_cluster_id() << std::endl;
    del_proto_vertex(*it1);
  }
  
}


void WCPPID::NeutrinoID::order_segments(WCPPID::ProtoSegmentSelection& ordered_segments, WCPPID::ProtoSegmentSelection& segments){
  std::vector<std::pair<WCPPID::ProtoSegment*, double> >  temp_pair_vec;
  for (auto it = segments.begin(); it != segments.end(); it++){
    temp_pair_vec.push_back(std::make_pair(*it, (*it)->get_length()));
  }
  sort(temp_pair_vec.begin(), temp_pair_vec.end(), sortbysec1);
  for (auto it = temp_pair_vec.begin(); it!=temp_pair_vec.end();it++){
    ordered_segments.push_back(it->first);
    //    std::cout << it->first->get_cluster_id() << " " << it->first << " " << it->second/units::cm << std::endl;    
  }
  
}


void WCPPID::NeutrinoID::order_clusters(WCPPID::PR3DClusterSelection& ordered_clusters, std::map<int, WCPPID::ProtoSegmentSelection>& map_cluster_id_segments, std::map<WCPPID::PR3DCluster*, double>& map_cluster_total_length){
  
  for (auto it = map_segment_vertices.begin(); it!= map_segment_vertices.end(); it++){
    WCPPID::ProtoSegment *sg = it->first;
    double length = sg->get_length();

    //std::cout << sg->get_point_vec().size() << " " << sg->get_point_vec().front() << " " << sg->get_point_vec().back() << std::endl;
    
    if (map_cluster_total_length.find(map_id_cluster[sg->get_cluster_id()])==map_cluster_total_length.end()){
      WCPPID::ProtoSegmentSelection segments;
      segments.push_back(sg);
      map_cluster_id_segments[sg->get_cluster_id()] =segments;
      map_cluster_total_length[map_id_cluster[sg->get_cluster_id()]] = length;
    }else{
      map_cluster_id_segments[sg->get_cluster_id()].push_back(sg);
      map_cluster_total_length[map_id_cluster[sg->get_cluster_id()]] += length;
    }
  }
  
 
  //  std::cout << map_cluster_total_length.size() << " " << map_cluster_id_segments.size() << std::endl;
  std::vector<std::pair<WCPPID::PR3DCluster*, double>> temp_pair_vec;
  for (auto it = map_cluster_total_length.begin(); it!=map_cluster_total_length.end(); it++){
    temp_pair_vec.push_back(std::make_pair(it->first, it->second));
  }
  sort(temp_pair_vec.begin(), temp_pair_vec.end(), sortbysec);
  for (auto it = temp_pair_vec.begin(); it!=temp_pair_vec.end();it++){
    ordered_clusters.push_back(it->first);
    //    std::cout << it->first->get_cluster_id() << " " << map_cluster_total_length[it->first] << " " << map_cluster_id_segments[it->first->get_cluster_id()].size() << std::endl;
  }
}
