module callgraph

import v.ast
import v.ast.walker
import v.pref
import v.dotgraph

// callgraph.show walks the AST, starting at main() and prints a DOT output describing the calls
// that function make transitively
pub fn show(mut table ast.Table, pref_ &pref.Preferences, ast_files []&ast.File) {
	mut mapper := &Mapper{
		pref:  pref_
		table: table
		dg:    dotgraph.new('CallGraph', 'CallGraph for ${pref_.path}', 'green')
	}
	// Node14 [shape="box",label="PrivateBase",URL="$classPrivateBase.html"];
	// Node15 -> Node9 [dir=back,color="midnightblue",fontsize=10,style="solid"];
	for afile in ast_files {
		walker.walk(mut mapper, afile)
	}
	mapper.dg.finish()
}

@[heap]
struct Mapper {
	pos int
mut:
	pref            &pref.Preferences = unsafe { nil }
	table           &ast.Table        = unsafe { nil }
	file            &ast.File         = unsafe { nil }
	node            &ast.Node         = unsafe { nil }
	fn_decl         &ast.FnDecl       = unsafe { nil }
	caller_name     string
	dot_caller_name string
	is_caller_used  bool
	dg              dotgraph.DotGraph
}

fn (mut m Mapper) dot_normalise_node_name(name string) string {
	res := name.replace_each([
		'.',
		'_',
		'==',
		'op_eq',
		'>=',
		'op_greater_eq',
		'<=',
		'op_lesser_eq',
		'>',
		'op_greater',
		'<',
		'op_lesser',
		'+',
		'op_plus',
		'-',
		'op_minus',
		'/',
		'op_divide',
		'*',
		'op_multiply',
		'^',
		'op_xor',
		'|',
		'op_or',
		'&',
		'op_and',
	])
	return res
}

fn (mut m Mapper) fn_name(fname string, receiver_type ast.Type, is_method bool) string {
	if !is_method {
		return fname
	}
	rec_sym := m.table.sym(receiver_type)
	return '${rec_sym.name}.${fname}'
}

fn (mut m Mapper) dot_fn_name(fname string, recv_type ast.Type, is_method bool) string {
	if is_method {
		return 'Node_method_' + int(recv_type).str() + '_' + m.dot_normalise_node_name(fname)
	}
	return 'Node_fn_' + m.dot_normalise_node_name(fname)
}

fn (mut m Mapper) visit(node &ast.Node) ! {
	m.node = unsafe { node }
	match node {
		ast.File {
			m.file = unsafe { &node }
		}
		ast.Stmt {
			match node {
				ast.FnDecl {
					m.is_caller_used = true
					if m.pref.skip_unused {
						m.is_caller_used = m.table.used_features.used_fns[node.fkey()]
					}
					m.fn_decl = unsafe { &node }
					m.caller_name = m.fn_name(node.name, node.receiver.typ, node.is_method)
					m.dot_caller_name = m.dot_fn_name(node.name, node.receiver.typ, node.is_method)
					if m.is_caller_used {
						m.dg.new_node(m.caller_name,
							node_name:        m.dot_caller_name
							should_highlight: m.caller_name == 'main.main'
						)
					}
				}
				else {}
			}
		}
		ast.Expr {
			match node {
				ast.CallExpr {
					if m.is_caller_used {
						dot_called_name := m.dot_fn_name(node.name, node.receiver_type,
							node.is_method)
						// Node15 -> Node9 [dir=back,color="midnightblue",fontsize=10,style="solid"];
						m.dg.new_edge(m.dot_caller_name, dot_called_name,
							should_highlight: m.caller_name == 'main.main'
						)
					}
				}
				else {}
			}
		}
		else {}
	}
}