module main

import x.encoding.asn1

// Previously, defined type KerberosString = asn1.GeneralString directly
// without reduplicating required Element methods, would produces
// RUNTIME ERROR: invalid memory access.
// **Updates**
// Its has been resolved in [22901](https://github.com/vlang/v/issues/22901)
// Thanks to @felipensp
type KerberosString = asn1.GeneralString

fn KerberosString.new(s string) !KerberosString {
	return KerberosString(asn1.GeneralString.new(s)!)
}

type KerberosStringList = []KerberosString

fn (ksl KerberosStringList) tag() asn1.Tag {
	return asn1.default_sequence_tag
}

fn (ksl KerberosStringList) payload() ![]u8 {
	mut out := []u8{}
	for item in ksl {
		// maybe produces x00000000: at ???: RUNTIME ERROR: invalid memory access
		// `item` cannot be used as interface object outside `unsafe` blocks as it
		// might be stored on stack. Consider declaring `KerberosString` as `@[heap]`
		obj := unsafe { item }
		out << asn1.encode(obj)!
	}
	return out
}

// PrincipalName   ::= SEQUENCE {
//    name-type       [0] Int32,
//    name-string     [1] SEQUENCE OF KerberosString
// }
struct PrincipalName {
	name_type asn1.Integer @[context_specific: 0; explicit; inner: 2] // integer tag = (universal, false, 2)

	// defines name_string  as asn1.SequenceOf[KerberosString] would produces unexpected result
	// when you build payload with `asn1.make_payload`,
	// see issues at https://github.com/vlang/v/issues/22721
	// so we build with KerberosStringList
	name_string KerberosStringList @[context_specific: 1; explicit; inner: 16] // sequence tag = (universal, true, 16)
}

fn (pn PrincipalName) tag() asn1.Tag {
	return asn1.default_sequence_tag
}

fn (pn PrincipalName) payload() ![]u8 {
	kd := asn1.new_key_default()
	payload := asn1.make_payload[PrincipalName](pn, kd)!
	return payload
}

fn PrincipalName.decode(bytes []u8) !PrincipalName {
	// decode should produces Sequence type
	elem := asn1.decode(bytes)!
	assert elem.tag().equal(asn1.default_sequence_tag)

	// cast it into Sequence type and get the fields
	seq := elem.into_object[asn1.Sequence]()!
	fields := seq.fields()

	// every fields of the sequence is raw of wrapped element, so we should unwrap it with
	// the same options used to wrap in encode step, and turn to the real underlying object.
	el_name_type := fields[0].unwrap_with_options('context_specific: 0; explicit; inner: 2')!
	name_type := el_name_type.into_object[asn1.Integer]()!

	// tag 16 is sequence tag, its decoded into Sequence type
	el_name_string := fields[1].unwrap_with_options('context_specific: 1; explicit; inner: 16')!
	el_seq := el_name_string.into_object[asn1.Sequence]()!

	// KerberosString string has a general_string tag, so it would be parsed as asn1.GeneralString
	// so, we transforms it into KerberosString back and build KerberosStringList.
	mut a := []KerberosString{}
	for item in el_seq.fields() {
		gst := item.into_object[asn1.GeneralString]()!
		obj := KerberosString(gst)
		a << obj
	}

	name_string_list := KerberosStringList(a)

	return PrincipalName{
		name_type:   name_type
		name_string: name_string_list
	}
}

fn main() {
	// Basically this is a Kerberos PrincipalName data
	data := [u8(0x30), 0x15, 0xa0, 0x03, 0x02, 0x01, 0x01, 0xa1, 0x0e, 0x30, 0x0c, 0x1b, 0x0a,
		0x62, 0x6f, 0x62, 0x62, 0x61, 0x2d, 0x66, 0x65, 0x74, 0x74]
	els := [KerberosString.new('bobba-fett')!]

	pn := PrincipalName{
		name_type:   asn1.Integer.from_int(1)
		name_string: KerberosStringList(els)
	}

	out1 := asn1.encode(pn)!
	back := PrincipalName.decode(data)!
	dump(back == pn) // should assert to true
	dump(out1.hex() == data.hex()) // should assert to true

	// run this produces:
	// [examples/examples_0.v:128] back == pn: true
	// [examples/examples_0.v:129] out1.hex() == data.hex(): true
}