func saveGraph(g *gographviz.Graph) {
	f, err := os.Create("out/" + g.Name + ".dot")
	check(err)
	defer f.Close()

	_, err = f.WriteString(g.String())
	check(err)
}

func (n *Node) addToGraphViz(g *gographviz.Graph, parentGraph, parent string) {
	nodeName := fmt.Sprintf("\"%v\"", n.SimpleString())
	g.AddNode(parentGraph, nodeName, nil)
	if "" != parent {
		g.AddEdge(parent, nodeName, true, nil)
	}

	for _, child := range n.children {
		child.addToGraphViz(g, parentGraph, nodeName)
	}
}

func DrawPool(graph *ggv.Graph, name string, p Pool) {
	fpath := poolPath + "/" + name
	attr := map[string]string{}
	lbl := " | <f1> HealthCheckEvery : " + p.HealthCheckEvery + " | <f2> Degraded : " + p.Degraded +
		" | <f3> Critical : " + p.Critical + " | <f4> Healthz : " + p.Healthz + " | <f5> Request : " + p.Request

	attr["shape"] = "record"
	attr["label"] = "\"{ <f0>" + name + lbl + "} \""
	attr["color"], attr["fillcolor"], attr["fontcolor"] = GetColorAttr(fpath)
	attr["fontname"] = font
	attr["style"] = "\"filled\""
	graph.AddNode(graphName, "\""+fpath+"\"", attr)
}

// Render turns *github.com/awalterschulze/gographviz.Graph into the desired format.
// It requires the dot command to be available in the system.
func Render(g *gographviz.Graph, fmt Format) (string, error) {
	if _, err := exec.LookPath("dot"); err != nil {
		return "", ErrNoDot
	}

	cmd := exec.Command("dot", "-T"+string(fmt))
	var outBuf, errBuf bytes.Buffer
	cmd.Stdin, cmd.Stdout, cmd.Stderr = strings.NewReader(g.String()), &outBuf, &errBuf
	if err := cmd.Run(); err != nil {
		return "", err
	}

	return outBuf.String(), nil
}

func DrawTrie(graph *ggv.Graph, name string, t Trie) {
	fpath := triePath + "/" + name
	attr := map[string]string{}
	lbl := " | <f1> Rules : "
	for _, v := range t.Rules {
		lbl = lbl + v + ", "
	}
	lbl = lbl[0 : len(lbl)-2]
	attr["shape"] = "record"
	attr["label"] = "\"{ <f0>" + name + lbl + "} \""
	attr["color"], attr["fillcolor"], attr["fontcolor"] = GetColorAttr(fpath)
	attr["fontname"] = font
	attr["style"] = "\"filled\""
	graph.AddNode(graphName, "\""+fpath+"\"", attr)
}

func DrawHosts(graph *ggv.Graph, parentName string, hosts []string) {
	fpath := poolPath + "/" + parentName + "/hosts"
	attr := map[string]string{}
	lbl := ""
	i := 1
	for _, v := range hosts {
		lbl = lbl + "| <f" + strconv.FormatInt(int64(i), 10) + "> " + v + " "
	}
	attr["shape"] = "record"
	attr["label"] = "\"{ <f0> Hosts " + lbl + "} \""
	attr["color"], attr["fillcolor"], attr["fontcolor"] = GetColorAttr(fpath)
	attr["fontname"] = font
	attr["style"] = "\"filled\""
	graph.AddNode(graphName, "\""+fpath+"\"", attr)
	graph.AddEdge("\""+poolPath+"/"+parentName+"\"", "\""+fpath+"\"", true, PoolEdgeAttr)
}

func DrawRule(graph *ggv.Graph, name string, r Rule) {
	fpath := rulePath + "/" + name
	attr := map[string]string{}
	lbl := " | <f1> Type : " + r.Type + " | <f2> Value : " + r.Value
	if r.Pool != "" {
		lbl = lbl + "| <f3> " + StrikethroughString("Next : "+r.Next) + " | <f4> Pool : " + r.Pool
	} else {
		lbl = lbl + "| <f3> Next : " + r.Next + " | <f4> " + StrikethroughString("Pool : "+r.Pool)
	}
	attr["shape"] = "record"
	attr["label"] = "\"{ <f0>" + name + lbl + "} \""
	attr["color"], attr["fillcolor"], attr["fontcolor"] = GetColorAttr(fpath)
	attr["fontname"] = font
	attr["style"] = "\"filled\""
	graph.AddNode(graphName, "\""+fpath+"\"", attr)
}

func (n *Node) addToGraph(g *gographviz.Graph, parent string) {
	id := strconv.Itoa(n.id)

	label := "root"
	if n.game != nil {
		label = fmt.Sprintf(`"Score: %d
Weights: %v
Direction: %s
Unit: %+v"`, int(n.score), n.weights, n.d, n.game.currUnit)
	}

	attrs := map[string]string{
		"label": label,
	}

	g.AddNode(parent, id, attrs)
	g.AddEdge(parent, id, true, nil)

	for _, c := range n.children {
		c.addToGraph(g, id)
	}
}

// dotDump dumps the given image stream tree in DOT syntax
func dotDump(root *Node, g *dot.Graph, graphName string) (string, error) {
	if root == nil {
		return "", nil
	}

	// Add current node
	rootNamespace, rootName, err := split(root.FullName)
	if err != nil {
		return "", err
	}
	attrs := make(map[string]string)
	for _, tag := range root.Tags {
		setTag(tag, attrs)
	}
	var tag string
	// Inject tag into root's name
	once.Do(func() {
		tag = root.Tags[0]
	})
	setLabel(rootName, rootNamespace, attrs, tag)
	rootName = validDOT(rootName)
	g.AddNode(graphName, rootName, attrs)

	// Add edges between current node and its children
	for _, child := range root.Children {
		for _, edge := range root.Edges {
			if child.FullName == edge.To {
				_, childName, err := split(child.FullName)
				if err != nil {
					return "", err
				}
				childName = validDOT(childName)
				edgeNamespace, edgeName, err := split(edge.FullName)
				if err != nil {
					return "", err
				}
				edgeName = validDOT(edgeName)

				edgeAttrs := make(map[string]string)
				setLabel(edgeName, edgeNamespace, edgeAttrs, "")
				g.AddEdge(rootName, childName, true, edgeAttrs)
			}
		}
		// Recursively add every child and their children as nodes
		if _, err := dotDump(child, g, graphName); err != nil {
			return "", err
		}
	}

	dotOutput := g.String()

	// Parse DOT output for validation
	if _, err := dot.Parse([]byte(dotOutput)); err != nil {
		return "", fmt.Errorf("cannot parse DOT output: %v", err)
	}

	return dotOutput, nil
}

func main() {
	var (
		bytes   []byte
		data    map[string]service
		err     error
		graph   *gographviz.Graph
		project string
	)
	logger = stdlog.GetFromFlags()
	project = ""

	// Load docker-compose.yml
	bytes, err = ioutil.ReadFile("docker-compose.yml")
	if err != nil {
		abort(err.Error())
	}

	// Parse it as YML
	data = make(map[string]service, 5)
	yaml.Unmarshal(bytes, &data)
	if err != nil {
		abort(err.Error())
	}

	// Create directed graph
	graph = gographviz.NewGraph()
	graph.SetName(project)
	graph.SetDir(true)

	// Add legend
	graph.AddSubGraph(project, "cluster_legend", map[string]string{"label": "Legend"})
	graph.AddNode("cluster_legend", "legend_service", map[string]string{"label": "service"})
	graph.AddNode("cluster_legend", "legend_service_with_ports",
		map[string]string{
			"label": "\"service with exposed ports\\n80:80 443:443\\n--volume1[:host_dir1]\\n--volume2[:host_dir2]\"",
			"shape": "box"})
	graph.AddEdge("legend_service", "legend_service_with_ports", true, map[string]string{"label": "links"})
	graph.AddEdge("legend_service_with_ports", "legend_service", true, map[string]string{"label": "volumes_from", "style": "dashed"})

	// Round one: populate nodes
	for name, service := range data {
		var attrs = map[string]string{"label": name}
		if service.Ports != nil {
			attrs["label"] += "\\n" + strings.Join(service.Ports, " ")
			attrs["shape"] = "box"
		}
		if service.Volumes != nil {
			attrs["label"] += "\\n--" + strings.Join(service.Volumes, "\\n--")
		}
		attrs["label"] = fmt.Sprintf("\"%s\"", attrs["label"])
		graph.AddNode(project, name, attrs)
	}

	// Round two: populate connections
	for name, service := range data {
		// links
		if service.Links != nil {
			for _, linkTo := range service.Links {
				if strings.Contains(linkTo, ":") {
					linkTo = strings.Split(linkTo, ":")[0]
				}
				graph.AddEdge(name, linkTo, true, nil)
			}
		}
		// volumes_from
		if service.VolumesFrom != nil {
			for _, linkTo := range service.VolumesFrom {
				graph.AddEdge(name, linkTo, true, map[string]string{"style": "dotted"})
			}
		}
	}

	fmt.Print(graph)
}