module main

import x.encoding.asn1

// This example was taken from https://www.oss.com/asn1/resources/asn1-made-simple/asn1-quick-reference/sequence.html
// But little modified with removed optional key in the structure and serialization.
// Example schema:
//
// ModuleName DEFINITIONS AUTOMATIC TAGS ::= BEGIN
// PersonelEntry ::= SEQUENCE {
//         name     OCTET STRING,
//         location INTEGER { home(0), field(1), roving(2)} OPTIONAL,
//         age      INTEGER   OPTIONAL
// }
// END

// The syntax above is equivalent with the following one:

// PersonelEntry ::= SEQUENCE {
//         name     [0] IMPLICIT OCTET STRING,
//         location [1] IMPLICIT INTEGER {home(0), field(1), roving(2)} OPTIONAL,
//         age      [2] IMPLICIT INTEGER OPTIONAL
// }
struct PersonelEntry {
mut:
	name     asn1.OctetString @[context_specific: 0; implicit; inner: 4]
	location asn1.Integer     @[context_specific: 1; implicit; inner: 2]
	age      asn1.Integer     @[context_specific: 2; implicit; inner: 2]
}

fn (pr PersonelEntry) tag() asn1.Tag {
	return asn1.default_sequence_tag
}

fn (pr PersonelEntry) payload() ![]u8 {
	mut out := []u8{}

	// by default, in .der, optional element was not included in the output, so, we remove optional options here.
	out << asn1.encode_with_options(pr.name, 'context_specific:0; implicit; inner:4')!
	out << asn1.encode_with_options(pr.location, 'context_specific:1; implicit; inner:2')!
	// the example the third element is optional, but in .der it would not be serializable until you set it to present
	out << asn1.encode_with_options(pr.age, 'context_specific:2; implicit; inner:2')!

	return out
}

// This is an example of way how we can write routine for decode PersonelEntry from bytes.
fn PersonelEntry.decode(bytes []u8) !PersonelEntry {
	// 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 as 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 := fields[0].unwrap_with_options('context_specific:0; implicit; inner:4')!
	name := el_name.into_object[asn1.OctetString]()!

	el_location := fields[1].unwrap_with_options('context_specific:1; implicit; inner:2')!
	location := el_location.into_object[asn1.Integer]()!

	el_age := fields[2].unwrap_with_options('context_specific:2; implicit; inner:2')!
	age := el_age.into_object[asn1.Integer]()!

	return PersonelEntry{
		name:     name
		location: location
		age:      age
	}
}

// expected output :
// 30 10
//   80 08 6269672068656164 // bytestr: 'big head'
//   81 01 02
//   82 01 1A
fn main() {
	expected_output := [u8(0x30), 0x10, u8(0x80), 0x08, 0x62, 0x69, 0x67, 0x20, 0x68, 0x65, 0x61,
		0x64, u8(0x81), 0x01, 0x02, u8(0x82), 0x01, 0x1A]

	rock_star1 := PersonelEntry{
		name:     asn1.OctetString.from_hexstring('6269672068656164')!
		location: asn1.Integer.from_int(2)
		age:      asn1.Integer.from_int(26)
	}

	// serializes the object into bytes array and check the result
	out := asn1.encode(rock_star1)!
	dump(out == expected_output) //  out == expected_output: true

	// deserializes bytes back into PersonelEntry object.
	out_back := PersonelEntry.decode(out)!
	dump(out_back)
	// out_back: PersonelEntry{
	// 	name: OctetString (big head)
	// 	location: Integer 2
	// 	age: Integer 26
	// }
	dump(out_back.name == rock_star1.name) // true
	dump(out_back.location == rock_star1.location) // true
	dump(out_back.age == rock_star1.age) // true
}