package mustache

import "base:runtime"
import "core:mem"

import "core:reflect"
import "core:strings"
import "core:log"
import "core:fmt"

decode :: proc( v: any, key: string ) -> any {
	if key ==  "." do return v

	v := reflect.any_base(v)
	ti := type_info_of(v.id)

	#partial switch i in runtime.type_info_base(ti).variant {
	case runtime.Type_Info_Enumerated_Array:
		return decode(any{v.data, ti.id}, key)

	case runtime.Type_Info_Union:
		return decode(any{v.data, reflect.union_variant_typeid(v) }, key)

	case runtime.Type_Info_Struct:
		newkey, err := strings.split_after_n(key, ".", 2)
		
		if err != nil {
			return nil
		}

		defer delete(newkey)

		newkey_0 := newkey[0]
		newkey_1 := "."

		if len(newkey) == 2 {
			newkey_0 = newkey[0][:len(newkey[0])-1]
			newkey_1 = newkey[1]
		}

		return decode( reflect.struct_field_value_by_name(v, newkey_0), newkey_1 )


	case runtime.Type_Info_Map:
		newkey, err := strings.split_after_n(key, ".", 2)

		if err!= nil {
			return nil
		}

		defer delete(newkey)

		newkey_0 := newkey[0]
		newkey_1 := "."

		if len(newkey) == 2 {
			newkey_0 = newkey[0][:len(newkey[0])-1]
			newkey_1 = newkey[1]
		}


		m := (^mem.Raw_Map)(v.data)
		ks, vs, _, _, _ := runtime.map_kvh_data_dynamic(m^, i.map_info)

		for j in 0..<runtime.map_cap(m^) {
			key_data := runtime.map_cell_index_dynamic(ks, i.map_info.ks, uintptr(j))
			ky, ok := reflect.as_string(any{rawptr(key_data), i.key.id})

			if !ok {
				return nil
			}

			if ky == newkey_0 {
				t := any{rawptr(runtime.map_cell_index_dynamic(vs, i.map_info.vs, uintptr(j))), i.value.id}
				return decode(t, newkey_1 )
			}
		}

		return ""
	}

	return ""
}

decode_string :: proc( v: any, key: string ) -> string {
	return fmt.tprintf("%v", decode(v, key))
}

section :: proc( r: ^strings.Reader, v: any, key: string ) -> string {
	save := r.i

	t := reflect.any_base(decode(v, key))
	ti := type_info_of(t.id)

	ret : string= ""
	#partial switch i in runtime.type_info_base(ti).variant {
	case runtime.Type_Info_Slice:
		for i in 0..<reflect.length(t) {
			elem :=reflect.index(t, i);

			strings.reader_seek(r, save, .Start)
			tmp := mustache(r, elem, key)
			defer delete(tmp)

			ret = strings.concatenate({ret, tmp})
		}
	}

	return ret
}