(function() {
  var height, svg, vis, width, zoom;

  svg = d3.select('svg');

  width = svg.node().getBoundingClientRect().width;

  height = svg.node().getBoundingClientRect().height;

  svg.attr({
    viewBox: "" + (-width / 2) + " " + (-height / 2 - 40) + " " + width + " " + height
  });

  vis = svg.append('g');

  zoom = d3.behavior.zoom().scaleExtent([1, 8]).on('zoom', function() {
    vis.attr({
      transform: "translate(" + (zoom.translate()) + ")scale(" + (zoom.scale()) + ")"
    });
    return vis.selectAll('.semantic_zoom').attr({
      transform: "scale(" + (1 / zoom.scale()) + ")"
    });
  });

  svg.call(zoom);

  d3.json('http://wafi.iit.cnr.it/webvis/tmp/DBpediaClassRelations.json', function(graph_data) {
    var MAX_WIDTH, circular, circular_layout, compute_degree, labels, link_thickness, links, links_layer, list_links, max, new_link_elements, new_node_elements, nodes, nodes_layer, objectify, radius, sankey, tension;

    graph_data.links = graph_data.links.filter(function(l) {
      return l.weight > 0;
    });
    objectify = function(graph) {
      return graph.links.forEach(function(l) {
        return graph.nodes.forEach(function(n) {
          if (l.source === n.id) {
            l.source = n;
          }
          if (l.target === n.id) {
            return l.target = n;
          }
        });
      });
    };
    objectify(graph_data);
    list_links = function(graph) {
      return graph.nodes.forEach(function(n) {
        n.links = graph.links.filter(function(link) {
          return link.source === n || link.target === n;
        });
        return n.links.sort(function(a, b) {
          var a_dir, b_dir, cmp, other_a_id, other_b_id;

          if (a.source === n) {
            other_a_id = a.target.id;
            a_dir = 'target';
          } else {
            other_a_id = a.source.id;
            a_dir = 'source';
          }
          if (b.source === n) {
            other_b_id = b.target.id;
            b_dir = 'target';
          } else {
            other_b_id = b.source.id;
            b_dir = 'source';
          }
          cmp = other_a_id - other_b_id;
          if (cmp === 0) {
            if (a_dir === 'target') {
              return 1;
            } else {
              return -1;
            }
          } else {
            return cmp;
          }
        });
      });
    };
    list_links(graph_data);
    compute_degree = function(graph) {
      return graph.nodes.forEach(function(n) {
        return n.degree = d3.sum(n.links, function(link) {
          return link.weight;
        });
      });
    };
    compute_degree(graph_data);
    MAX_WIDTH = 18;
    max = d3.max(graph_data.nodes, function(n) {
      return n.degree;
    });
    link_thickness = d3.scale.sqrt().domain([0, max]).range([0.2, MAX_WIDTH]);
    sankey = function(graph) {
      return graph.nodes.forEach(function(n) {
        var acc;

        acc = 0;
        n.links.forEach(function(link) {
          if (link.source === n) {
            return link.sankey_source = {
              start: acc,
              middle: acc + link_thickness(link.weight) / 2,
              end: acc += link_thickness(link.weight)
            };
          } else if (link.target === n) {
            return link.sankey_target = {
              start: acc,
              middle: acc + link_thickness(link.weight) / 2,
              end: acc += link_thickness(link.weight)
            };
          }
        });
        return n.sankey_tot = acc;
      });
    };
    sankey(graph_data);
    circular_layout = function() {
      var delta_theta, rho, self, theta, theta_0;

      rho = function(d, i, data) {
        return 100;
      };
      theta_0 = function(d, i, data) {
        return -Math.PI / 2;
      };
      delta_theta = function(d, i, data) {
        return 2 * Math.PI / data.length;
      };
      theta = function(d, i, data) {
        return theta_0(d, i, data) + i * delta_theta(d, i, data);
      };
      self = function(data) {
        data.forEach(function(d, i) {
          d.rho = rho(d, i, data);
          d.theta = theta(d, i, data);
          d.x = d.rho * Math.cos(d.theta);
          return d.y = d.rho * Math.sin(d.theta);
        });
        return data;
      };
      self.rho = function(x) {
        if (x != null) {
          if (typeof x === 'function') {
            rho = x;
          } else {
            rho = function() {
              return x;
            };
          }
          return self;
        }
        return rho;
      };
      self.theta_0 = function(x) {
        if (x != null) {
          if (typeof x === 'function') {
            theta_0 = x;
          } else {
            theta_0 = function() {
              return x;
            };
          }
          return self;
        }
        return theta_0;
      };
      self.delta_theta = function(x) {
        if (x != null) {
          if (typeof x === 'function') {
            delta_theta = x;
          } else {
            delta_theta = function() {
              return x;
            };
          }
          return self;
        }
        return delta_theta;
      };
      self.theta = function(x) {
        if (x != null) {
          if (typeof x === 'function') {
            theta = x;
          } else {
            theta = function() {
              return x;
            };
          }
          return self;
        }
        return theta;
      };
      return self;
    };
    circular = circular_layout().rho(160);
    circular(graph_data.nodes);
    links_layer = vis.append('g');
    nodes_layer = vis.append('g');
    radius = d3.scale.sqrt().domain([
      0, d3.min(graph_data.nodes, function(n) {
        return n.size;
      })
    ]).range([0, MAX_WIDTH / 2]);
    nodes = nodes_layer.selectAll('.node').data(graph_data.nodes);
    new_node_elements = nodes.enter().append('circle').attr({
      "class": 'node',
      r: function(node) {
        return radius(node.size);
      },
      cx: function(node) {
        return node.x + (4 + radius(node.size)) * Math.cos(node.theta);
      },
      cy: function(node) {
        return node.y + (4 + radius(node.size)) * Math.sin(node.theta);
      }
    });
    new_node_elements.append('title').text(function(node) {
      return node.name + ' class\n' + d3.format(',')(node.size) + ' entities';
    });
    labels = nodes_layer.selectAll('.label').data(graph_data.nodes);
    labels.enter().append('g').attr('transform', function(node) {
      return "translate(" + (node.x + (4 + radius(node.size)) * Math.cos(node.theta)) + " " + (node.y + (4 + radius(node.size)) * Math.sin(node.theta)) + ")";
    }).append('text').text(function(node) {
      return node.name;
    }).attr({
      "class": 'label semantic_zoom',
      dy: '0.35em'
    });
    links = links_layer.selectAll('.link').data(graph_data.links);
    tension = 0.3;
    new_link_elements = links.enter().append('path').attr({
      "class": 'link flowline',
      'stroke-width': function(link) {
        return link_thickness(link.weight);
      }
    });
    new_link_elements.append('title').text(function(link) {
      return link.source.name + ' -> ' + link.target.name + '\n' + d3.format(',')(link.weight) + ' links';
    });
    links.attr({
      d: function(link) {
        var cxs, cxt, cys, cyt, sankey_ds, sankey_dt, sankey_dxs, sankey_dxt, sankey_dys, sankey_dyt, xs, xsi, xt, xti, ys, ysi, yt, yti;

        sankey_ds = link.source.sankey_tot / 2 - link.sankey_source.middle;
        sankey_dt = link.target.sankey_tot / 2 - link.sankey_target.middle;
        sankey_dxs = sankey_ds * Math.cos(link.source.theta + Math.PI / 2);
        sankey_dys = sankey_ds * Math.sin(link.source.theta + Math.PI / 2);
        sankey_dxt = sankey_dt * Math.cos(link.target.theta + Math.PI / 2);
        sankey_dyt = sankey_dt * Math.sin(link.target.theta + Math.PI / 2);
        xs = link.source.x + sankey_dxs;
        ys = link.source.y + sankey_dys;
        xt = link.target.x + sankey_dxt;
        yt = link.target.y + sankey_dyt;
        xsi = xs + (4 + radius(link.source.size)) * Math.cos(link.source.theta);
        ysi = ys + (4 + radius(link.source.size)) * Math.sin(link.source.theta);
        xti = xt + (4 + radius(link.target.size)) * Math.cos(link.target.theta);
        yti = yt + (4 + radius(link.target.size)) * Math.sin(link.target.theta);
        cxs = xs - link.source.x * tension;
        cys = ys - link.source.y * tension;
        cxt = xt - link.target.x * tension;
        cyt = yt - link.target.y * tension;
        return "M" + xsi + " " + ysi + " L" + xs + " " + ys + " C" + cxs + " " + cys + " " + cxt + " " + cyt + " " + xt + " " + yt + " L" + xti + " " + yti;
      }
    });
    nodes.on('click', function(n) {
      links.classed('blurred', function(link) {
        return link.source !== n && link.target !== n;
      });
      return d3.event.stopPropagation();
    });
    svg.on('click', function() {
      if (d3.event.defaultPrevented) {
        return;
      }
      return links.classed('blurred', false);
    });
    return links.on('click', function(l) {
      links.classed('blurred', function(link) {
        return link !== l;
      });
      return d3.event.stopPropagation();
    });
  });

}).call(this);