namespace eval ::nano::key {}
namespace eval ::nano::block {}
namespace eval ::nano::block::json {}
namespace eval ::nano::block::dict {}
namespace eval ::nano::block::create {}
namespace eval ::nano::work {}
namespace eval ::nano::account {}
namespace eval ::nano::rpc {}
namespace eval ::nano::rpc::client {}
namespace eval ::nano::balance {}

# Constants
set ::nano::block::stateBlockPreamble [binary decode hex "0000000000000000000000000000000000000000000000000000000000000006"]
set ::nano::address::base32alphabet {13456789abcdefghijkmnopqrstuwxyz}

# Address management functions
proc ::nano::address::toPublicKey {address args} {

	set newFrontierHash [dict get [json::json2dict $block] "_blockHash"]

	setFrontier $account $newFrontierHash $balance $representative

	return $block
}

# RPC Client
proc ::nano::rpc::client::init args {
	dict with args {}

	if {![info exists url]} {
		set url {http://localhost:7076/}
	}

	set ::nano::rpc::client::url $url
}

proc ::nano::rpc::client {action args} {
	::nano::rpc::client::init

	set rpcURL $::nano::rpc::client::url

	set jsonArgs [list]
	foreach {key value} $args {
		switch -exact -- $key {
			"-count" {}
			"-accounts" {
				set valueAsStrings [lmap valueItem $value { json::write string $valueItem }]
				set value [json::write array {*}$valueAsStrings]
			}
			default {
				set value [json::write string $value]
			}
		}
		set key [string range $key 1 end]

		lappend jsonArgs $key $value
	}

	set query [json::write object action [json::write string $action] {*}$jsonArgs]

	catch {
		set token [http::geturl $rpcURL -query $query]
		set ncode [http::ncode $token]
		set data [http::data $token]
	} error
	if {![info exists data]} {
		set ncode -1
		set data $error
	}

	if {[info exists token]} {
		http::cleanup $token
	}

	if {$ncode ne "200"} {
		return -code error "$ncode: $data"
	}

	set data [json::json2dict $data]

	return $data
}

# Account balance manipulation
set ::nano::balance::_conversion {
	GNano 1000000000000000000000000000000000000000
	MNano 1000000000000000000000000000000000000
	Gnano 1000000000000000000000000000000000
	Gxrb  1000000000000000000000000000000000
	KNano 1000000000000000000000000000000000
	Nano  1000000000000000000000000000000
	_USER 1000000000000000000000000000000
	NANO  1000000000000000000000000000000
	Mnano 1000000000000000000000000000000
	Mxrb  1000000000000000000000000000000
	Mrai  1000000000000000000000000000000
	knano 1000000000000000000000000000
	kxrb  1000000000000000000000000000
	mNano 1000000000000000000000000000
	nano  1000000000000000000000000
	xrb   1000000000000000000000000
	uNano 1000000000000000000000000
	mnano 1000000000000000000000
	mxrb  1000000000000000000000
	unano 1000000000000000000
	uxrb  1000000000000000000
	Traw  1000000000000
	Graw  1000000000
	Mraw  1000000
	Kraw  1000
	raw   1
}

proc ::nano::balance::toUnit {raw toUnit {decimals 0}} {
	set divisor [dict get $::nano::balance::_conversion $toUnit]

	if {$decimals == 0} {
		set balance [expr {entier(($raw / ($divisor * 1.0)) + 0.5)}]
	} else {
		set balance [expr {$raw / ($divisor * 1.0)}]
		set balance [format "%.${decimals}f" $balance]
	}

	return $balance
}

proc ::nano::balance::toRaw {balance fromUnit} {
	set multiplier [dict get $::nano::balance::_conversion $fromUnit]

	# Determine how long the multiplier is
	set zeros [expr {entier(log10($multiplier))}]

	# Find the location of the decimal point (or add it)
	set decimal [string first "." $balance]
	if {$decimal == -1} {
		append balance "."

		set decimal [string first "." $balance]
	}

	# Ensure that the balance has atleast the right number of trailing zeros
	append balance [string repeat "0" $zeros]

	# Remove the decimal point
	set balance [string replace $balance $decimal $decimal]

	# Get the subset of the string that corresponds to the balance
	set balance [string range $balance 0 [expr {$zeros + $decimal - 1}]]

	# Convert to a integer type
	set balance [expr {entier($balance)}]

	return $balance
}

proc ::nano::balance::normalizeUnitName {unit} {
	set multiplier [dict get $::nano::balance::_conversion $unit]
	foreach {unitName multiplierCheck} $::nano::balance::_conversion {
		if {$multiplierCheck == $multiplier} {
			return $unitName
		}
	}
}

proc ::nano::balance::toHuman {raw {decimals 3}} {
	set humanUnit [normalizeUnitName _USER]
	set humanUnitMultiplier [dict get $::nano::balance::_conversion $humanUnit]

	if {$raw > [expr {$humanUnitMultiplier / 10000000}]} {
		set balance [toUnit $raw $humanUnit 7]
		set baseUnit $humanUnit
		set balance [expr {entier($balance * 1000000)}]
		set labels {u m "" K M G T}
	} else {
		set balance $raw
		set baseUnit "raw"
		set labels {"" K M G T}
	}

	set labelIdx -1
	foreach label $labels {
		incr $labelIdx

		if {$balance < 1000} {
			break
		}

		set balance [expr {$balance / 1000}]
	}

	set unit "${label}${baseUnit}"
	set unit [normalizeUnitName $unit]

	set balance [toUnit $raw $unit $decimals]
	set balance [string trimright $balance "0."]

	set result [list $balance $unit]

	return $result
}

		puts "\[3.FAIL\] Exp: true"

		return false
	}

	return true
}

proc test_balances {} {
	set balance 1001500000000000000000000000000
	set balance [::nano::balance::toUnit $balance Nano 3]
	set balance_expected "1.001"
	if {$balance != $balance_expected} {
		puts "\[1.FAIL\] Got: $balance"
		puts "\[1.FAIL\] Exp: $balance_expected"

		return false
	}

	set balance 1001510000000000000000000000000
	set balance [::nano::balance::toUnit $balance Nano 3]
	set balance_expected "1.002"
	if {$balance != $balance_expected} {
		puts "\[2.FAIL\] Got: $balance"
		puts "\[2.FAIL\] Exp: $balance_expected"

		return false
	}

	set balance 100150000000000000000000000000000000000
	set balance [::nano::balance::toUnit $balance unano 3]
	set balance_expected "100150000000000000000.000"
	if {$balance != $balance_expected} {
		puts "\[3.FAIL\] Got: $balance"
		puts "\[3.FAIL\] Exp: $balance_expected"

		return false
	}
	set balance 10
	set balance [::nano::balance::toRaw $balance Nano]
	set balance_expected 10000000000000000000000000000000
	if {$balance != $balance_expected} {
		puts "\[4.FAIL\] Got: $balance"
		puts "\[4.FAIL\] Exp: $balance_expected"

		return false
	}

	set balance 1.000000000000000000001
	set balance [::nano::balance::toRaw $balance Nano]
	set balance_expected 1000000000000000000001000000000
	if {$balance != $balance_expected} {
		puts "\[5.FAIL\] Got: $balance"
		puts "\[5.FAIL\] Exp: $balance_expected"

		return false
	}

	set unitName [::nano::balance::normalizeUnitName Mnano]
	set unitName_expected "Nano"
	if {$unitName != $unitName_expected} {
		puts "\[6.FAIL\] Got: $unitName"
		puts "\[6.FAIL\] Exp: $unitName_expected"

		return false
	}

	set balance 3.3346
	set balance [::nano::balance::toRaw $balance unano]
	set balance_expected $balance
	set balance [::nano::balance::toHuman $balance]
	set balance [::nano::balance::toRaw {*}$balance]
	if {$balance != $balance_expected} {
		puts ""
		puts "\[7.FAIL\] Got: $balance"
		puts "\[7.FAIL\] Exp: $balance_expected"

		return false
	}
	return true
}

set tests {
	selftest
	signatures
	hashing
	keygeneration
	addressformat
	blocks
	work
	balances
}

foreach test $tests {
	puts -nonewline "\[    \] $test"
	flush stdout

	if {[catch {
		if {![test_$test]} {
			puts "\[FAIL\] $test"
			puts "\r\[FAIL\] $test"
			exit 1
		} else {
			puts "\r\[ OK \] $test"
		}
	} testErr]} {
		puts "\[ERR \] $test: $testErr"
		puts "\r\[ERR!\] $test: $testErr"
		exit 1
	}
}

puts "\[DONE\] All tests pass"

exit 0