#include <string>
#include <vector>
#include <iostream>
#include <map>

#include <math.h>
#include <gtk/gtk.h>
#include <goocanvas.h>

class residue_spec_t {
public:
   std::string res_name;
   std::string chain_id;
   int res_no;
   std::string ins_code;
   residue_spec_t(const std::string &chain_id_in, int res_no_in, const std::string &ins_code_in) :
      chain_id(chain_id_in), res_no(res_no_in), ins_code(ins_code_in) { }
   bool operator<(const residue_spec_t &matcher) const{
      if (matcher.chain_id == chain_id) {
         if (matcher.res_no == res_no) {
            if (matcher.ins_code == ins_code) {
               return false;
            } else {
               if (matcher.ins_code < ins_code)
                  return false;
               else
                  return true;
            }
         } else {
            if (matcher.res_no < res_no)
               return false;
            else
               return true;
         } 
      } else {
         if (matcher.chain_id < chain_id)
            return false;
         else
            return true;
      } 
      // return 0; we can't here
   }
};

class phi_psi_t {
public:
   float phi;
   float psi;
   std ::string label;
   std ::string residue_name;
   // phi_psi_t(const float &phi_in, const float &psi_in) : phi(phi_in), psi(psi_in) { }
   float get_phi() const { return phi; }
   float get_psi() const { return psi; }
   std::string get_label() const { return label; }
   std::string get_residue_name() const { return residue_name; }
};

class phi_psis_for_model_t {

public:
   int model_number;
   std::map<residue_spec_t, phi_psi_t> phi_psi;
   explicit phi_psis_for_model_t(int model_number_in) : model_number(model_number_in) { }
   void add_phi_psi(const residue_spec_t &spec, const phi_psi_t &phi_psi_in) {
      phi_psi[spec] = phi_psi_in;
   }
   phi_psi_t operator[](const residue_spec_t &spec) {
      return phi_psi[spec];
   }
   unsigned int size() { return phi_psi.size(); } 
};

class canvas_tick_t {
public:
   double x, y;
   short int axis;
   // i==0 for x axis, i==1 for y axis.
   canvas_tick_t(int i, double a, double b) {
      x = a;
      y = b;
      axis = i;
   }
   double start_x() {return x;};
   double start_y() {return y;};
   double end_x() { if (axis == 0) return x; else return x - 10;};
   double end_y() { if (axis == 1) return y; else return y + 10;}; 
};

GtkWidget *close_yourself() {

   gtk_main_quit();
   return 0;
}

GtkWidget *create_window_get_canvas() {

   GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   GtkWidget *label  = gtk_label_new("  Plot  ");
   GtkWidget *button = gtk_button_new_with_label("  Close  ");
   GtkWidget *canvas = goo_canvas_new();

   GtkWidget *vbox;
#if (GTK_MAJOR_VERSION > 2)
   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
#else
   vbox = gtk_vbox_new (FALSE, 5);
#endif

   gtk_window_set_title(GTK_WINDOW (window), "Problems");
   gtk_container_set_border_width(GTK_CONTAINER (window), 0);
   gtk_container_set_border_width(GTK_CONTAINER (vbox), 10);
   gtk_container_add(GTK_CONTAINER (window), vbox);

   gtk_widget_set_size_request(canvas, 500, 460);

   gtk_widget_show(vbox);
   gtk_widget_show(label);
   gtk_widget_show(window);
   gtk_widget_show(canvas);
   gtk_widget_show(button);
   gtk_box_pack_start(GTK_BOX(vbox), canvas, TRUE,  TRUE,  5);
   gtk_box_pack_start(GTK_BOX(vbox), label,  FALSE, FALSE, 5);
   gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5);

   g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(close_yourself), NULL);

   return canvas;
}

void
draw_axes(GtkWidget *canvas) {

   // First do the text for the axes labels.
   //
#if (GTK_MAJOR_VERSION > 2)
   GooCanvasAnchorType anchor_orientation = GOO_CANVAS_ANCHOR_WEST;
#else
   GtkAnchorType anchor_orientation = GTK_ANCHOR_WEST;
#endif

   GooCanvasItem *item;
   GooCanvasItem *axis_grp;

   float shift = 0, shift_label = 0;
   GooCanvasItem *root = goo_canvas_get_root_item (GOO_CANVAS(canvas));
   std::string fixed_font_str = "Sans 9";

   axis_grp = goo_canvas_group_new(root, NULL);
   item = goo_canvas_text_new(axis_grp,
                              "Phi",
                              -10.0,
                              230.0 + shift,
                              -1,
                              anchor_orientation,
                              "font", fixed_font_str.c_str(),
                              "fill-color", "black",
                              NULL);

   item = goo_canvas_text_new(axis_grp,
                              "Psi",
                              -230.0,
                              15.0 + shift_label,
                              -1,
                              anchor_orientation,
                              "font", fixed_font_str.c_str(),
                              "fill-color", "black",
                              NULL);



//   // Ticks
   std::vector<canvas_tick_t> pnts;

   // x axis
   float tick_pos = 180.0;
   pnts.push_back(canvas_tick_t(0,-180.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,-120.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,-60.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,0.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,60.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,120.0,tick_pos));
   pnts.push_back(canvas_tick_t(0,180.0,tick_pos));
   

   // y axis
   tick_pos = -180.0;
   pnts.push_back(canvas_tick_t(1,tick_pos,180.0));

   pnts.push_back(canvas_tick_t(1,tick_pos,-180.0));
   pnts.push_back(canvas_tick_t(1,tick_pos,-120.0));
   pnts.push_back(canvas_tick_t(1,tick_pos,-60.0));
   pnts.push_back(canvas_tick_t(1,tick_pos,0.0));
   pnts.push_back(canvas_tick_t(1,tick_pos,60.0));
   pnts.push_back(canvas_tick_t(1,tick_pos,120.0));

   for (unsigned int i=0; i<pnts.size(); i++) { 

      item = goo_canvas_polyline_new_line(axis_grp,
                                          pnts[i].start_x(), pnts[i].start_y(),
                                          pnts[i].end_x(), pnts[i].end_y(),
                                          "line-width", 1.,
                                          "fill-color", "black",
                                          NULL);
   }

   //   // Ticks text

//   // x axis

   std::vector<int> tick_text_phi;
   std::vector<int> tick_text_psi;

   tick_text_psi.push_back(-180);

   tick_text_psi.push_back(-120);
   tick_text_psi.push_back(-60);
   tick_text_psi.push_back(0);
   tick_text_psi.push_back(60);
   tick_text_psi.push_back(120);
   tick_text_psi.push_back(180);

   tick_text_phi.push_back(0);
   tick_text_phi.push_back(60);
   tick_text_phi.push_back(120);
   tick_text_phi.push_back(180);
   tick_text_phi.push_back(-180);
   tick_text_phi.push_back(-120);
   tick_text_phi.push_back(-60);

   char text[20];

   for (unsigned int i=0; i<tick_text_phi.size(); i++) {

      snprintf(text,19,"%d",tick_text_psi[i]);
   
      item = goo_canvas_text_new(axis_grp,
                                 text,
                                 -230.0,
                                 -tick_text_psi[i] +0.0,
                                 -1,
                                 anchor_orientation,
                                 "font", fixed_font_str.c_str(),
                                 "fill-color", "black",
                                 NULL);


      
      ////    y axis

      snprintf(text,19,"%d",tick_text_phi[i]);

      item = goo_canvas_text_new(axis_grp,
                                 text,
                                 tick_text_phi[i] - 10.0,
                                 200.0 + shift,
                                 -1,
                                 anchor_orientation,
                                 "font", fixed_font_str.c_str(),
                                 "fill-color", "black",
                                 NULL);

   }
}

void
draw_black_border(GtkWidget *canvas) {

   GooCanvasPoints *points = goo_canvas_points_new(4);
   GooCanvasItem *root = goo_canvas_get_root_item (GOO_CANVAS(canvas));
   GooCanvasItem *border_group = goo_canvas_group_new(root, NULL);
   GooCanvasItem *item;

   float psi_start, psi_end;
   // now we make the black box around the canvas.
   float line_thickness = 2.0;
   
   psi_start = -180.0;
   psi_end = 180.0;
   
   points->coords[0] = -180.0;
   points->coords[1] = psi_start; 

   points->coords[2] = -180.0;
   points->coords[3] = psi_end; 

   points->coords[4] = 180.0;
   points->coords[5] = psi_end; 

   points->coords[6] = 180.0;
   points->coords[7] = psi_start; 

   item = goo_canvas_polyline_new(border_group,
                                  TRUE, 0,
                                  "points", points,
                                  "stroke-color", "black",
                                  "line-width", line_thickness,
                                  NULL);
   goo_canvas_points_unref (points);
}


void
draw_zero_lines(GtkWidget *canvas) {

   GooCanvasItem *item;
   GooCanvasItem *zero_grp;
   GooCanvasItem *root = goo_canvas_get_root_item (GOO_CANVAS(canvas));
   zero_grp = goo_canvas_group_new(root, NULL);
   float start, end;
   start = -180.0;
   end = 180.0;

   item = goo_canvas_polyline_new_line(zero_grp,
                                       0.0, start,
                                       0.0, end,
                                       "stroke-color", "grey",
                                       "line-width", 1.0,
                                       NULL);

   item = goo_canvas_polyline_new_line(zero_grp,
                                       -180.0, 0.0,
                                       180.0, 0.0,
                                       "line-width", 1.0,
                                       "stroke-color", "grey",
                                       NULL);

}

std::map<residue_spec_t, phi_psi_t>
generate_phi_psis() {

   std::map<residue_spec_t, phi_psi_t> m;

   const unsigned int n_spots = 100;
   for (unsigned int i=0; i<n_spots; i++) {
      residue_spec_t rs("A", i+1, "");
      float f = static_cast<float>(i)/static_cast<float>(n_spots);
      float pi = 3.14159265;
      float phi = -40.0 * sinf(2.0 * pi * f) + 100.0 * sin(1000.0 * f);
      float psi = 180.0 * cosf(2.0 * pi * f);
      phi_psi_t pp;
      pp.phi = phi;
      pp.psi = psi;
      pp.label = std::string("A ") + std::to_string(i+1) + " GLN";
      m[rs] = pp;
   }

   return m;
}

gboolean rama_item_button_press (GooCanvasItem *item,
                                 GooCanvasItem *target,
                                 GdkEventButton *event,
                                 gpointer data) {

   std::string *id = static_cast<std::string *> (g_object_get_data(G_OBJECT(item), "id"));
   std::cout << "button press id: " << *id << std::endl;
   return TRUE;
}

gboolean rama_item_button_release (GooCanvasItem *item,
                      GooCanvasItem *target,
                      GdkEventButton *event,
                      gpointer data) {

   // std::cout << "button release" << std::endl;
   return TRUE;
}

gboolean rama_item_enter_event (GooCanvasItem *item,
                                GooCanvasItem *target,
                                GdkEventCrossing *event,
                                gpointer data) {

   std::string *id = static_cast<std::string *> (g_object_get_data(G_OBJECT(item), "id"));
   std::cout << "button item enter " << *id << std::endl;
   return TRUE;
}


gboolean rama_item_motion_event (GooCanvasItem *item,
                                GooCanvasItem *target,
                                GdkEventMotion *event,
                                gpointer data) {

   // std::cout << "button item motion event" << std::endl; // noisy
   return TRUE;
}


void
draw_phi_psi_point_internal(GooCanvasItem *residues_grp,
                            const phi_psi_t &phi_psi) {

   std::string outline_color("#333333");
   std::string colour = "DodgerBlue";
   
   GooCanvasItem *item = goo_canvas_ellipse_new(residues_grp,
                                                phi_psi.get_phi(), -phi_psi.get_psi(),
                                                10.0, 10.0,
                                                "fill-color", colour.c_str(),
                                                "stroke-color", outline_color.c_str(),
                                                "line-width", 1.,
                                                "tooltip", phi_psi.get_label().c_str(),
                                                NULL);
   std::string *s = new std::string(phi_psi.get_label());
   g_object_set_data(G_OBJECT(item), "id", s);
   g_signal_connect (item, "button_press_event",
                     G_CALLBACK (rama_item_button_press), NULL);
   g_signal_connect (item, "button_release_event",
                     G_CALLBACK (rama_item_button_release), NULL);
   g_signal_connect (item, "enter_notify_event",
                     G_CALLBACK (rama_item_enter_event), NULL);
   g_signal_connect (item, "motion_notify_event",
                     G_CALLBACK (rama_item_motion_event), NULL);

}
   

void
draw_phi_psi_points(GtkWidget *canvas, const std::map<residue_spec_t, phi_psi_t> &m) {

   GooCanvasItem *root = goo_canvas_get_root_item (GOO_CANVAS(canvas));
   GooCanvasItem *residues_grp = goo_canvas_group_new(root, NULL);
   std::map<residue_spec_t, phi_psi_t>::const_iterator it;
   for(it=m.begin(); it!=m.end(); ++it) {
      draw_phi_psi_point_internal(residues_grp, it->second);
   }
}


void
setup_canvas(GtkWidget *canvas) {
   goo_canvas_set_bounds(GOO_CANVAS(canvas), -240.0, -220.0, 210.0, 240.0);
   gtk_widget_set_can_focus(canvas, TRUE);
   gtk_widget_grab_focus(canvas);
}

int main(int argc, char **argv) {

   gtk_init (&argc, &argv);
   GtkWidget *canvas = create_window_get_canvas();

   setup_canvas(canvas);

   draw_black_border(canvas);
   draw_axes(canvas);
   draw_zero_lines(canvas);

   std::map<residue_spec_t, phi_psi_t> m = generate_phi_psis();
   draw_phi_psi_points(canvas, m);

   gtk_main();
   return 0;
}