set _ ""

proc is_called {name from} {
    unset -nocomplain ::uncalled($name)
    if {[info exists ::called($name)] && $from in $::called($name)} return
    if {!([dict exists $::apidoc $from] && [dict get $::apidoc $from deprecated_p])} {
	incr ::called_from_nondeprecated($name)
    }
    lappend ::called($name) $from
}

set procs [lsort [nsv_array names api_proc_doc]]
foreach p $procs {
    set ::uncalled($p) 1
    set ::called_from_nondeprecated($p) 0
    dict set ::apidoc $p [nsv_get api_proc_doc $p]
}


foreach kw $::apidoc::KEYWORDS { set keyword($kw) 1 }

set count 0
foreach package_key [db_list _ {select package_key from apm_package_types order by 1}] {
    set processed 0
    foreach path [apm_get_package_files -package_key $package_key -file_types content_page] {
	set type [string range [file extension $path] 1 end]
	if {$type in {tcl adp}} {
	    set stub $::acs::rootdir/packages/$package_key/[file root $path]
	    append _ $package_key/$path \n
	    template::adp_init $type $stub
	    incr processed
	} else {
	    append _ "ignore $package_key/$path (type $type)\n"
	}
    }
    append _ "$package_key ($processed files)\n"
    #if {$count > 2} break
}

template::adp_init tcl $::acs::rootdir/packages/acs-bootstrap-installer/installer
template::adp_init tcl $::acs::rootdir/packages/acs-bootstrap-installer/installer-init
foreach file [glob $::acs::rootdir/packages/*/tcl/*init.tcl] {
    ns_log notice "adding [file root $file]"
    template::adp_init tcl [file root $file]
}


append _ "www tcl [llength [info commands ::template::code::tcl::*]]\n"
append _ "www adp  [llength [info commands ::template::code::adp::*]]\n"

lappend procs {*}[info commands ::template::code::tcl::*]
lappend procs {*}[info commands ::template::code::adp::*]

foreach p [info procs ::*] {
    set relname [string trimleft $p :]
    if {$relname ni $procs} {lappend procs $relname}
}

set count 0
set dcount 0

ns_log notice "check [llength $procs] procs"
foreach proc [lsort $procs] {
    incr count
    #append _ "$count: $proc\n"
    #if {[info commands $proc] eq "" && [info commands ::$proc] eq ""} {
#	append _ "... $proc undefined\n"
#	ns_log notice "===... $proc undefined\n"
#	continue
 #   }
    if {[dict exists $::apidoc $proc] 
	&& [dict get $::apidoc $proc deprecated_p]} {
	set deprecated deprecated
	append _ "deprecated [incr dcount]: $proc\n"
    } else {
	set deprecated non-deprecated
    }
    set body [apidoc::tcl_to_html $proc]
    #ns_log notice "$proc $body"
    dom parse -html <p>$body</p> doc
    $doc documentElement root
    foreach a [$root selectNodes //a] {
	set href [$a getAttribute href]
	# if {$proc in {auth::local::password::ChangePassword}} {
	#     #ns_log notice "$count: $href"
	#     #ns_log notice "$proc contains $href"
	#     append _ "$proc contains $href" \n
	# }
	#ns_log notice href=$href
	if {[regexp {/api-doc/proc-view[?]proc=%3a%3a%3(.*)&} $href . called]} {
	    ns_log notice "=========proc $proc href=$href"
	}
	if {[regexp {/api-doc/proc-view[?]proc=(.*)&} $href . called]} {
	    set called [string trimleft [ns_urldecode $called] :]
	    #ns_log notice "$deprecated $proc calls $called"
	    #append _ "$proc calls $called \n"
	    is_called $called $proc
	    if {[dict exists $::apidoc $called]} {
		if {[dict get $::apidoc $called deprecated_p]} {
		    ns_log notice "$count: $deprecated $proc calls deprecated $called"
		    append _ "$deprecated $proc calls deprecated $called\n"
		}
	    }
	} elseif {![info exists keyword($kw)]} {
	    ns_log notice "no apidoc for $called"
	}
    }
}

set count 0
foreach name [lsort [array names ::uncalled]] {
    if {[string match "* *" $name] || [string match "AcsSc*" $name] || [string match "_*" $name]} {
	# xotcl calls are not traced so far
	continue
    }
    set deprecated ""
    if {[dict exists $::apidoc $name]} {
	if {[dict get $::apidoc $name deprecated_p]} {
	    set deprecated "(deprecated)"
	}
	if {[dict get $::apidoc $name private_p]} {
	    set deprecated "(private)"
	}
    }
    append _ "[incr count] uncalled: $name $deprecated\n"
}

set count 0
foreach name [lsort [array names ::called]] {
    if {![info exists ::called_from_nondeprecated($name)]} {set ::called_from_nondeprecated($name) -1}
    if {[dict exists $::apidoc $name] && [dict get $::apidoc $name deprecated_p]} {
	set deprecated " (deprecated)"
    } else {
	set deprecated ""
    }

    append _ "[incr count] called: $name$deprecated (from nondeprec $::called_from_nondeprecated($name)) $::called($name)\n"
}

ns_return 200 text/plain $_