module asn1

import io

// Parser is ongoing ASN.1 parser.
// Its capables parsing ASN.1 element through availables methods.
pub struct Parser {
mut:
	data []u8
}

// new creates a new Parser from bytes array in data.
pub fn Parser.new(data []u8) &Parser {
	return &Parser{
		data: data
	}
}

// reset resets internal data of parser to empty buffer.
pub fn (mut p Parser) reset() {
	p.data = unsafe { p.data[..0] }
}

// peek_tag lookups the tag from the parser without updates internal parser data.
pub fn (mut p Parser) peek_tag() !Tag {
	tag, _ := Tag.from_bytes(p.data)!
	return tag
}

// read_tag lookups the tag from the current parser and updates internal parser data.
pub fn (mut p Parser) read_tag() !Tag {
	tag, rest := Tag.from_bytes(p.data)!
	p.data = rest
	return tag
}

// read_length read the Length from the current parser data.
pub fn (mut p Parser) read_length() !Length {
	length, rest := Length.from_bytes(p.data)!
	p.data = rest
	return length
}

// read_bytes read length bytes from the current parser data.
pub fn (mut p Parser) read_bytes(length int) ![]u8 {
	if length > p.data.len {
		return error('Parser: too short data to read ${length} bytes')
	}
	result := p.data[0..length]
	rest := if length == p.data.len { []u8{} } else { unsafe { p.data[length..] } }
	p.data = rest
	return result
}

// BUG: This is not supported with error:
// ```bash
// error: unknown function: asn1.Boolean__static__parse
// 	 57 | // Note: somes builtin have not this method.
//   58 | fn (mut p Parser) read_element[T]() !T {
//   59 |     result := T.parse(mut p)!
//      |               ~~~~~~~~~~~~~~
//   60 |     return result
//   61 | }
// vlib/x/encoding/asn1/parser.v:59:26: error: unexpected `!`,
// the function `T__static__parse` does not return a Result
//   57 | // Note: somes builtin have not this method.
//   58 | fn (mut p Parser) read_element[T]() !T {
//   59 |     result := T.parse(mut p)!
//      |                             ^
//   60 |     return result
//   61 | }
// vlib/x/encoding/asn1/parser.v:59:9: error: assignment mismatch: 1 variable
// but `T.parse()` returns 0 values
//   57 | // Note: somes builtin have not this method.
//   58 | fn (mut p Parser) read_element[T]() !T {
//   59 |     result := T.parse(mut p)!
//      |            ~~
//   60 |     return result
//   61 | }
// ```
// read_element read an element T from the current parser.
// Note: somes builtin have not this method.
// fn (mut p Parser) read_element[T]() !T {
//	result := T.parse(mut p)!
//	return result
// }

// read_tlv read an Element from the parser data.
// Its return an Element, you should cast it to underlying data if you need.
pub fn (mut p Parser) read_tlv() !Element {
	tag := p.read_tag()!
	length := p.read_length()!
	content := p.read_bytes(length)!

	elem := parse_element(tag, content)!
	return elem
}

// finish end this parser or error if not empty.
pub fn (mut p Parser) finish() ! {
	if !p.is_empty() {
		return error('not empty on finish')
	}
}

// is_empty checks whether the parser has empty buffer data.
pub fn (mut p Parser) is_empty() bool {
	return p.data.len == 0
}

// read_from read up to buf.len bytes from reader r, places them into buf and then appends
// to current Parser data.
fn (mut p Parser) read_from(mut r io.Reader, mut buf []u8) !int {
	n := r.read(mut buf)!
	p.data << buf

	return n
}

fn parse_single[T](data []u8) !T {
	mut p := Parser.new(data)!
	out := p.read_element[T]()!
	return out
}

fn parse[T](data []u8, callback fn (mut p Parser) !T) !T {
	mut p := Parser.new(data)
	result := callback(mut p)!
	p.finish()!
	return result
}

/*
fn strip_tlv(data []u8) !(Element, []u8) {
	mut p := Parser.new(data)
	tlv := p.read_element[Asn1Element]()!
	return tlv, p.data
}
*/