package require tcltest

namespace eval ::testspace {
    namespace import ::tcltest::*
    variable common {
        set result ""
    }

    test define_tstr_template1 {Test basic tstr substitution finds vars in namespace in which define was called}\
        -setup $common -body {
            namespace eval whatever {
                set plus +++ 
                set minus --- 

                punk::args::define {
                    @id -id ::testspace::test1
                    @values
                    param -type string -default "${$plus}XXX${$minus}YYY"
                }
            }

            set argd [punk::args::parse {} withid ::testspace::test1]
            set vals [dict get $argd values]
            lappend result [dict get $vals param]
        }\
        -cleanup {
            namespace delete ::testspace::whatever
        }\
        -result [list\
            +++XXX---YYY 
        ]

    test define_tstr_template2 {Test basic tstr substitution when @dynamic}\
        -setup $common -body {
            namespace eval whatever {
                set plus +++ 
                set minus --- 

                punk::args::define {
                    @dynamic
                    @id -id ::testspace::test2
                    @values
                    param -type string -default "${$plus}XXX${$minus}YYY"
                }
            }

            set argd [punk::args::parse {} withid ::testspace::test2]
            puts ">>>>define_tstr_template2 argd:$argd"
            set vals [dict get $argd values]
            lappend result [dict get $vals param]
        }\
        -cleanup {
            namespace delete ::testspace::whatever
        }\
        -result [list\
            +++XXX---YYY 
        ]

    test define_tstr_template3 {Test double tstr substitution when @dynamic}\
        -setup $common -body {
            variable test_list
            set test_list {A B C}
            proc ::testspace::get_list {} {
                variable test_list
                return $test_list 
            }
            namespace eval whatever {
                set plus +++ 
                set minus --- 
                set DYN_LIST {${[::testspace::get_list]}}
                set DYN_CLOCKSECONDS {${[clock seconds]}}

                punk::args::define {
                    @dynamic
                    @id -id ::testspace::test2
                    @values
                    param1 -type string -default "${$plus}XXX${$minus}YYY"
                    param2 -type list -default "${$DYN_LIST}"
                    param3 -type string -default "${[clock seconds]}"
                    param4 -type string -default "${$DYN_CLOCKSECONDS}"
                }
            }

            set argd [punk::args::parse {} withid ::testspace::test2]
            set vals [dict get $argd values]
            lappend result [dict get $vals param1]
            lappend result [dict get $vals param2]
            set c1_at_define    [dict get $vals param3]
            set c1_at_resolve   [dict get $vals param4]

            #update test_list to ensure parse is actually dynamic
            set ::testspace::test_list {X Y Z}
            #update plus - should not affect output as it is resolved at define time
            set ::testspace::whatever::plus "new+"
            #unset minus - should not cause error
            unset ::testspace::whatever::minus
            after 1100 ;#ensure more than 1 sec apart


            set argd [punk::args::parse {} withid ::testspace::test2]
            set vals [dict get $argd values]
            lappend result [dict get $vals param1]
            lappend result [dict get $vals param2]
            set c2_at_define    [dict get $vals param3]
            set c2_at_resolve   [dict get $vals param4]

            if {$c1_at_define == $c2_at_define} {
                lappend result "OK_define_time_var_match"
            } else {
                lappend result "UNEXPECTED_define_time_var_mismatch"
            }
            if {$c1_at_resolve < $c2_at_resolve} {
                lappend result "OK_resolve_time_2_greater"
            } else {
                lappend result "UNEXPECTED_resolve_time_2_not_greater"
            }

        }\
        -cleanup {
            namespace delete ::testspace::whatever
        }\
        -result [list\
            +++XXX---YYY  {A B C} +++XXX---YYY {X Y Z} OK_define_time_var_match OK_resolve_time_2_greater
        ]
}