package mustache

import "base:runtime"
import "core:reflect"
import "core:strings"
import "core:mem"

import "core:log"

@private
_clean_html :: proc(s: string) -> string {
	ret:  strings.Builder

	for c in s do switch c {
	case '<': 
		strings.write_string(&ret, "&lt;")
	case '>':
		strings.write_string(&ret, "&gt;")
	case '&':
		strings.write_string(&ret, "&amp;")
	case '"':
		strings.write_string(&ret, "&quot;")
	case '\'':
		strings.write_string(&ret, "&apos;")
	case:
		strings.write_rune(&ret, c)
	}
	
	return strings.to_string(ret)
}

decode :: proc( v: any, key: string ) -> any {
	ti := type_info_of(v.id)
	variant := runtime.type_info_base(ti).variant

	#partial switch i in 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)
	}

	if key == "." {
		return v
	}

	#partial switch i in variant {
	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 nil
	}

	return  nil
}

@private 
mustache_section :: proc( r: ^strings.Reader, v, p: any, section_key: string, inv: bool = false ) -> string {
	tmp := mustache(r, v, section_key)
	defer delete(tmp)

	tmp2 := mustache(tmp, p, section_key)

	if inv {
		return tmp2
	}

	delete(tmp2)
	return ""
}

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

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

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

			tmp := mustache_section(r, elem, v, section_key, !inv)
			defer delete(tmp)

			ret = strings.concatenate({ret, tmp})
		}
		return ret
	case runtime.Type_Info_Boolean:
		b, _ := reflect.as_bool(t)

		return mustache_section(r, t, v, section_key, b~inv)
	}

	if t == nil {
		return mustache_section(r, t, v, section_key, inv)
	}

	return mustache_section(r, t, v, section_key, !inv)
}