namespace eval ::nano::rpc {}
namespace eval ::nano::rpc::client {}
namespace eval ::nano::rpc::cli {}
namespace eval ::nano::balance {}
namespace eval ::nano::node::bootstrap {}
namespace eval ::nano::node::realtime {}
namespace eval ::nano::node::cli {}
namespace eval ::nano::node::stats {}
namespace eval ::nano::network::client {}
namespace eval ::nano::network::server {}
namespace eval ::nano::protocol::create {}
namespace eval ::nano::protocol::parse {}
namespace eval ::nano::protocol::extensions {}
namespace eval ::nano::network::_dns {}
namespace eval ::nano::wallet {}

#puts "Querying $peerSock with node_id_handshake (1)"
				::nano::network::client $peerSock "node_id_handshake" query -query $node_id_nonce
			}
		}
	}

	# Stats
	::nano::node::stats::incr [list keepalive count]
	::nano::node::stats::incr [list keepalive peers] [llength $peers]
	foreach peer $peers {
		::nano::node::stats::lappend keepalive $peer
	}


	return ""
}

proc ::nano::protocol::parse::node_id_handshake {extensions messageData} {
	array set result [list]

	if {"query" in [dict get $messageDict flags]} {
		set query [dict get $messageDict query]
		set clientID [dict get $::nano::node::configuration node client_id_private_key]
		set retval [dict create "invoke_client" [list node_id_handshake response -privateKey $clientID -query [binary decode hex $query]]]

		# Stats
		::nano::node::stats::incr [list node_id_handshake query count]
	}

	if {"response" in [dict get $messageDict flags]} {
		set peerInfo [dict get $messageDict socket remote]
		set peerAddress [lindex $peerInfo 0]
		set peerPort [lindex $peerInfo 1]
		set peer [dict create address $peerAddress port $peerPort]

		# XXX:TODO: Verify the nonce
		if {![info exists ::nano::node::_node_id_nonces($peer)]} {
			return ""
		}
		set sentNonce $::nano::node::_node_id_nonces($peer)
		unset ::nano::node::_node_id_nonces($peer)

		# Add the peer to our list of peers
#puts "Got node_id_handshake response from $peer"
		set ::nano::node::peers($peer) [dict create lastSeen [clock seconds]]

		# Stats
		::nano::node::stats::incr [list node_id_handshake response count]

		::nano::node::stats::lappend [list node_id_handshake response uniqueKeys] [dict get $messageDict key]
	}

	return $retval
}

proc ::nano::network::server::confirm_req {messageDict} {
	::nano::node::stats::incr [list confirm_req]
	return ""
}

proc ::nano::network::server::confirm_ack {messageDict} {
	# keep statistics
	dict with messageDict {}

	::nano::node::stats::incr [list confirm_ack valid $valid]
	if {!$valid} {
		return ""
	}

	::nano::node::stats::incr [list confirm_ack rep $voteAccount valid $valid]

	::nano::node::stats::incr [list confirm_ack voteType $voteType]
	::nano::node::stats::incr [list confirm_ack rep $voteAccount voteType $voteType]


	::nano::node::stats::newMinMax [list confirm_ack rep $voteAccount voteSequence] $voteSequence














	set votedOn [llength $hashes]

	::nano::node::stats::incr [list confirm_ack votedOnCount] $votedOn
	::nano::node::stats::incr [list confirm_ack rep $voteAccount votedOnCount] $votedOn

	foreach hash $hashes {
		::nano::node::stats::lappend [list confirm_ack votedOnUniqueCount] $hash
		::nano::node::stats::lappend [list confirm_ack rep $voteAccount votedOnUniqueCount] $hash
	}




	return ""
}

proc ::nano::protocol::parse::publish {extensions messageData} {
	set blockTypeID [expr {($extensions >> 8) & 0x0f}]
	set blockType [::nano::block::typeFromTypeID $blockTypeID]
	set blockDict [::nano::block::dict::fromBlock $messageData -type=$blockType]

	}
	catch {
		set valid [::nano::internal::boolean [::nano::block::dict::verifySignature $block]]
	}
	set validWork [::nano::internal::boolean [::nano::block::dict::validateWork $block]]


	::nano::node::stats::incr [list publish valid $valid]
	::nano::node::stats::incr [list publish validWork $validWork]
	::nano::node::stats::incr [list publish type [dict get $block type]]
	::nano::node::stats::lappend [list publish unique] $hash



}]} { puts $::errorInfo }

	return ""
}

# Namespace ::nano::protocol::parse deals with the network level protocol (outside the node)
# Namespace ::nano::network::server deals with the node's actual interaction with the network

}

proc ::nano::node::start args {
	package require defer
	package require udp

	set ::nano::node::startTime [clock seconds]
	::nano::node::stats::open

	array set config {
		-bootstrap true
		-realtime true
		-wait true
	}
	array set config $args

	if {$config(-bootstrap)} {
		coroutine ::nano::node::bootstrap::run ::nano::node::bootstrap
	}

	if {$config(-realtime)} {
		coroutine ::nano::node::realtime::run ::nano::node::realtime
	}

	if {$config(-wait)} {
		vwait ::nano::node::_FOREVER_
	}
}

# Node stats
proc ::nano::node::stats::open {} {
	set db ::nano::node::stats::_db
	if {[llength [info command $db]] != 0} {
		return
	}

	package require sqlite3

	sqlite3 $db "" -create true
	tailcall clear
}

proc ::nano::node::stats::clear {} {
	set db ::nano::node::stats::_db

	$db eval {DROP TABLE IF EXISTS counters}
	$db eval {DROP TABLE IF EXISTS minmax}
	$db eval {DROP TABLE IF EXISTS lists}
	$db eval {DROP TABLE IF EXISTS info}
	$db eval {CREATE TABLE counters (key PRIMARY KEY, current INTEGER DEFAULT 0)}
	$db eval {CREATE TABLE minmax (key PRIMARY KEY, high INTEGER NOT NULL, low INTEGER NOT NULL)}
	$db eval {CREATE TABLE lists (key NOT NULL, value, UNIQUE (key, value))}
	$db eval {CREATE TABLE info (key PRIMARY KEY, value NOT NULL)}

	set now [clock seconds]
	$db eval {INSERT OR REPLACE INTO info (key, value) VALUES ('startTime', $now)}

	return
}

proc ::nano::node::stats::incr {key {amount 1}} {
	set db ::nano::node::stats::_db

	# Requires a new version of SQLite3
	set haveUpsert false

	if {$haveUpsert} {
		# Untested
		set query {
			INSERT INTO counters (key, current) VALUES ($key, '@@AMOUNT@@') ON CONFLICT (key) DO
			UPDATE counters SET current = current + @@AMOUNT@@;
		}
	} else {
		set query {
			INSERT OR IGNORE INTO counters (key, current) VALUES ($key, '0');
			UPDATE counters SET current = current + @@AMOUNT@@ WHERE key = $key;
		}
	}

	$db eval [string map [list @@AMOUNT@@ $amount] $query]
}

proc ::nano::node::stats::newMinMax {key value} {
	set db ::nano::node::stats::_db

	$db eval {
		INSERT OR IGNORE INTO minmax (key, high, low) VALUES ($key, $value, $value);
		UPDATE minmax SET high = $value WHERE key = $key AND $value > high;
		UPDATE minmax SET low = $value  WHERE key = $key AND $value < low;
	}
}

proc ::nano::node::stats::lappend {key value} {
	set db ::nano::node::stats::_db

	$db eval {INSERT OR IGNORE INTO lists (key, value) VALUES ($key, $value)}
}

proc ::nano::node::stats::startTime {} {
	set db ::nano::node::stats::_db

	set startTime [$db onecolumn {SELECT value FROM info WHERE key = 'startTime'}]

	return $startTime
}

proc ::nano::node::stats::get {} {
	set db ::nano::node::stats::_db

	set results(startTime) [startTime]

	unset -nocomplain row
	$db eval {SELECT key, current FROM counters} row {
		set results($row(key)) $row(current)
	}

	unset -nocomplain row
	$db eval {SELECT key, COUNT(key) count FROM lists GROUP BY key} row {
		set results($row(key)) $row(count)
	}

	unset -nocomplain row
	$db eval {SELECT key, high, low FROM minmax} row {
		set results([concat $row(key) min]) $row(low)
		set results([concat $row(key) max]) $row(high)
	}

	return [array get results]
}

# RPC Client
## Side-effect: Sets ::nano::rpc::client::config
proc ::nano::rpc::client::init args {
	package require http 2

	if {![info exists ::nano::rpc::client::config]} {

	set balance [join [list $leading $trailing] "."]
	set balance [string trimright $balance "."]

	set result [list $balance $baseUnit]

	return $result
}

# Node Wallet Functions
proc ::nano::wallet::decode_backup {password walletJSON} {
	array set walletArray [::json::json2dict $walletJSON]

	set wallet(version) [expr 0x$walletArray(0000000000000000000000000000000000000000000000000000000000000000)]
	set wallet(salt)    [binary decode hex $walletArray(0000000000000000000000000000000000000000000000000000000000000001)]
	set wallet(key)     [binary decode hex $walletArray(0000000000000000000000000000000000000000000000000000000000000002)]
	set wallet(check)   [binary decode hex $walletArray(0000000000000000000000000000000000000000000000000000000000000003)]
	set wallet(rep)     [::nano::address::fromPublicKey $walletArray(0000000000000000000000000000000000000000000000000000000000000004)]
	set wallet(seed)    [binary decode hex $walletArray(0000000000000000000000000000000000000000000000000000000000000005)]
	set wallet(index)   [expr 0x$walletArray(0000000000000000000000000000000000000000000000000000000000000006)]

	if {$wallet(version) != 4} {
		return -code error "Unsupported wallet backup version ($version)"
	}

	set walletKeyIV [string range $wallet(salt) 0 15]
	set seedIV      [string range $wallet(salt) 16 end]

	# XXX:TODO: Check the password against "check"

	# Decrypt seed
	set aesKey    [::nano::internal::deriveKeyFromPassword $password $wallet(salt)]
	set walletKey [::nano::internal::AES256-CTR $aesKey $walletKeyIV $wallet(key)]
	set seed      [::nano::internal::AES256-CTR $walletKey $seedIV $wallet(seed)]

	# Format results
	set wallet(seed) [string toupper [binary encode hex $seed]]

	# XXX:TODO: Include ad-hoc keys

	return [array get wallet]
}


# Generic CLI helpers
proc ::nano::_cli {namespace args} {
	for {set argIndex 0} {$argIndex < [llength $args]} {incr argIndex} {
		set arg [lindex $args $argIndex]
		switch -exact -- $arg {
			"-prompt" {

	tailcall $proc {*}$args
}

proc {::nano::_cli::multiword help} {namespace base args} {
	tailcall help $namespace $base {*}$args
}



































# Node CLI
proc ::nano::node::cli {args} {
	tailcall ::nano::_cli node -prompt {
		return "\[[dict get $::nano::node::configuration network]\] nano-node [package present nano]> "
	} {*}$args
}

proc {::nano::node::cli::show uptime} {} {
	set now [clock seconds]
	set start $::nano::node::startTime
	set statsStart [::nano::node::stats::startTime]

	set uptime [expr {$now - $start}]
	set uptimeStats [expr {$now - $statsStart}]

	set format {%-19s: %s}
	lappend response [format $format Uptime [::nano::_cli::interval $uptime]]
	lappend response [format $format "Stats last cleared" "[::nano::_cli::interval $uptimeStats] ago"]

}

proc {::nano::node::cli::show logs} args {
	return [join [lrange $::nano::node::log end-19 end] "\n"]
}

proc {::nano::node::cli::clear stats} args {


	::nano::node::stats::clear



	return
}

proc {::nano::node::cli::clear peers} args {
	return -code error "Unimplemented"
	set ::nano::node::statsStartTime [clock seconds]

	unset -nocomplain ::nano::node::peers
	array set ::nano::node::peers [list]

	return
}

proc {::nano::node::cli::show stats} args {
	set stats [::nano::node::stats::get]

	set statsStart [dict get $stats startTime]
	dict unset stats startTime

	set now [clock seconds]

	set uptimeStats [expr {$now - $statsStart}]

	set quiet false
	if {!$quiet} {
		set format {%-19s: %s}
		puts [format $format "Stats last cleared" "[::nano::_cli::interval $uptimeStats] ago"]
		puts ""
	}

	set globalOnly false
	if {[lindex $args 0] eq "-global"} {
		set globalOnly true
	}

	if {[lindex $args 0] in {"-rep" "-representative"}} {
		set repOnly [::nano::address::toPublicKey [lindex $args 1] -binary]
	}

	set maxKeyLen 0
	foreach {key val} $stats {
		if {[lindex $key 1] eq "rep"} {
			if {$globalOnly} {
				continue
			} elseif {[info exists repOnly]} {
				if {$repOnly ne [::nano::address::toPublicKey [lindex $key 2] -binary]} {
					continue
				}

	foreach {key val} [lsort -stride 2 -dictionary [array get localStats]] {
		set extra ""
		if {![regexp { (min|max)[A-Z]} $key]} {
			if {[string is entier -strict $val]} {
				set valAvg [expr {($val * 1.0) / $uptimeStats}]
				set valAvg [format %.4f $valAvg]

				if {[lindex $key end] ni {max min}} {
					set extra " (avg: $valAvg per second)"
				}
			}
		}

		puts [format "%-${maxKeyLen}s = %s%s" $key $val $extra]
	}

	return