// Copyright (c) 2022, 2024 blackshirt. All rights reserved.
// Use of this source code is governed by a MIT License
// that can be found in the LICENSE file.
module asn1

// This file contains structures and routines for (limited) support for
// other class (type) of ASN.1 Element.
//

// ASN.1 Raw Element.
pub struct RawElement {
mut:
    // The tag is the (outer) tag of the TLV, if this a wrpper.
    tag Tag
    // `content` is the value of a TLV. Its depends on the context.
    content []u8
    // Optional fields
    inner_tag     ?Tag
    mode          ?TaggedMode
    default_value ?Element
}

// new creates a RawElement from tag and content. If your element is universal class,
// use universal type constructor instead, provided in this module.
pub fn RawElement.new(tag Tag, content []u8) !RawElement {
    if tag.number < 0 || tag.number > max_tag_number {
        return error('Unallowed tagnum was provided')
    }
    // universal class with constructed form only valid for sequence(of) and set(of) type.
    if tag.class == .universal {
        if tag.number > max_universal_tagnumber {
            return error('Tag number for universal class was exceed limit')
        }
        if tag.constructed {
            if tag.number != int(TagType.sequence) && tag.number != int(TagType.set) {
                return error('unexpected_tag_value required sequence or set number')
            }
        }
        if tag.number == int(TagType.sequence) || tag.number == int(TagType.set) {
            if !tag.constructed {
                return error('unexpected_tag_value sequence or set number should in constructed tag')
            }
        }
    }
    // otherwise, treats as a RawElement
    return RawElement{
        tag:     tag
        content: content
    }
}

// from_element creates a RawElement from another element (with wrapping semantic).
pub fn RawElement.from_element(el Element, cls TagClass, tagnum int, mode TaggedMode) !RawElement {
    // wrapping into .universal is not allowed.
    if cls == .universal {
        return error('wrap with universal class is unallowed')
    }
    inner_form := el.tag().constructed
    constructed := if mode == .explicit { true } else { inner_form }
    content := if mode == .explicit { encode_with_rule(el, .der)! } else { el.payload()! }

    outer_tag := Tag.new(cls, constructed, tagnum)!
    raw := RawElement{
        tag:       outer_tag
        content:   content
        inner_tag: el.tag()
        mode:      mode
    }

    return raw
}

// tag returns the tag of the RawElement, ie, outer tag when its a wrapper.
pub fn (r RawElement) tag() Tag {
    return r.tag
}

// payload returns the payload of the RawElement.
pub fn (r RawElement) payload() ![]u8 {
    return r.content
}

// set_mode sets the RawElement tagged mode, in explicit or implicit mode. If the mode has been set,
// it would drop into error until you forces it by setting force flag into true value, ie, replaces the old one.
pub fn (mut r RawElement) set_mode(mode TaggedMode, force bool) ! {
    if r.tag.class == .universal {
        return error('No need it on universal class')
    }
    if r.mode != none {
        if !force {
            return error('unallowed_operation r.mode != none')
        }
    }
    r.mode = mode
}

// set_inner_tag sets the inner tag of the RawElement into inner_tag value. If it has been already set,
// it would be an error until you setting force flag into true value to replace the old one.
pub fn (mut r RawElement) set_inner_tag(inner_tag Tag, force bool) ! {
    // not needed in universal class
    if r.tag.class == .universal {
        return error('No need it on universal class')
    }
    mode := r.mode or { return error('You dont set any mode') }
    // when its in explicit mode, compares the provided tag with tag from the inner element.
    if mode == .explicit {
        if !r.tag.constructed {
            return error('unmeet_requirement, explicit should be constructed')
        }
        // check inner_tag
        itt, _ := Tag.decode(r.content)!
        if !itt.equal(inner_tag) {
            return error('unmeet_requirement, unequal supplied tag')
        }
    }
    if r.inner_tag != none {
        if !force {
            return error('.unallowed_operation, r.inner_tag != none')
        }
    }
    r.inner_tag = inner_tag
}

// force_set_default_value forces set default value of this RawElement into value.
fn (mut r RawElement) set_default_value(value Element, force bool) ! {
    // default value of this element should have an equal tag.
    if !value.tag().equal(r.tag) {
        return error('You provides unequal tag for default value')
    }
    if r.default_value != none {
        if !force {
            return error('The RawElement already default_value being set')
        }
    }
    r.default_value = value
}

// inner_tag returns the inner tag of the RawElement if it exists, or error on fails.
pub fn (r RawElement) inner_tag() ?Tag {
    return r.inner_tag
}

// inner_element returns the inner element of the RawElement if its exists.
pub fn (r RawElement) inner_element() !Element {
    if r.tag.class == .universal {
        return error('inner element from universal class is not availables')
    }
    inner_tag := r.inner_tag or { return err }
    mode := r.mode or { return error('You dont set any mode') }
    if mode == .explicit {
        if !r.tag.constructed {
            return error('tag should be constructed when in explicit')
        }
    }
    // in implicit, r.content is inner element content with inner tag
    if mode == .implicit {
        elem := parse_element(inner_tag, r.content)!
        return elem
    }
    // otherwise, treats it in explicit mode.
    // read an inner tag from r.content
    mut p := Parser.new(r.content)
    tag := p.peek_tag()!
    if !tag.equal(inner_tag) {
        return error('gets unequal inner_tag')
    }
    el := p.read_tlv()!
    // should finish
    p.finish()!
    return el
}

fn (r RawElement) check_inner_tag() ! {
    if r.tag.class == .universal {
        return error('Universal class does not have inner tag')
    }
    mode := r.mode or { return error('You dont set any mode') }
    if mode != .explicit {
        return
    }
    // read an inner tag from content
    tag, _ := Tag.decode_with_rule(r.content, 0, .der)!
    inner_tag := r.inner_tag or { return error('You dont set an inner_tag') }
    if !tag.equal(inner_tag) {
        return error('Get unexpected inner tag from bytes')
    }
}

// ContextSpecific tagged type element.
pub struct ContextElement {
    RawElement
}

// new creates a raw context specific element. Use `ContextElement.from_element` instead
// if your context specific element is wrapper of another element.
pub fn ContextElement.new(tag Tag, content []u8) !ContextElement {
    if tag.class != .context_specific {
        return error('Your tag is not .context_specific')
    }
    raw := RawElement.new(tag, content)!
    return ContextElement{raw}
}

// from_element creates a new tagged type of ContextElement from some element in inner.
pub fn ContextElement.from_element(inner Element, tagnum int, mode TaggedMode) !ContextElement {
    raw := RawElement.from_element(inner, .context_specific, tagnum, mode)!

    ctx := ContextElement{raw}
    return ctx
}

// tag returns the tag of context specific element.
pub fn (ctx ContextElement) tag() Tag {
    return ctx.RawElement.tag
}

// payload returns the payload of the context specific element.
pub fn (ctx ContextElement) payload() ![]u8 {
    return ctx.RawElement.content
}

// explicit_context creates a new ContextElement with explicit mode.
pub fn ContextElement.explicit_context(inner Element, tagnum int) !ContextElement {
    return ContextElement.from_element(inner, tagnum, .explicit)!
}

// implicit_context creates new ContextElement with implicit mode.
pub fn ContextElement.implicit_context(inner Element, tagnum int) !ContextElement {
    return ContextElement.from_element(inner, tagnum, .implicit)!
}

fn ContextElement.decode_raw(bytes []u8) !(ContextElement, int) {
    tag, length_pos := Tag.decode_with_rule(bytes, 0, .der)!
    if tag.class != .context_specific {
        return error('tag required to be context_specific')
    }
    length, content_pos := Length.decode_with_rule(bytes, length_pos, .der)!
    content := if length == 0 {
        []u8{}
    } else {
        if content_pos >= bytes.len || content_pos + length > bytes.len {
            return error('ContextElement: truncated payload bytes')
        }
        unsafe { bytes[content_pos..content_pos + length] }
    }
    next := content_pos + length
    // Raw ContextElement, you should provide mode and inner tag.
    ctx := ContextElement{
        tag:     tag
        content: content
    }
    return ctx, next
}

fn ContextElement.decode_with_options(bytes []u8, opt string) !(ContextElement, int) {
    if opt.len == 0 {
        return ContextElement.decode_raw(bytes)!
    }
    fo := FieldOptions.from_string(opt)!
    // get mode and inner tag
    if !valid_mode_value(fo.mode) {
        return error('Get unexpected mode option for ContextElement')
    }
    mode := TaggedMode.from_string(fo.mode)!
    inner_tag := fo.inner_tag()!

    // outer tag from bytes
    tag, length_pos := Tag.decode_with_rule(bytes, 0, .der)!
    if tag.class != .context_specific {
        return error('Get non ContextSpecific tag')
    }

    // if mode is explicit without constructed form, its would return on error.
    if mode == .explicit {
        if !tag.constructed {
            return error('explicit need constructed form')
        }
    }
    length, content_pos := Length.decode_with_rule(bytes, length_pos, .der)!
    content := if length == 0 {
        []u8{}
    } else {
        if content_pos >= bytes.len || content_pos + length > bytes.len {
            return error('ContextElement: truncated payload bytes')
        }
        unsafe { bytes[content_pos..content_pos + length] }
    }
    next := content_pos + length

    if mode == .implicit {
        ctx := ContextElement{
            tag:       tag
            content:   content
            inner_tag: inner_tag
            mode:      .implicit
        }
        return ctx, next
    }
    // explicit one, build ContextElement and performs checks for inner_tag validity.
    ctx := ContextElement{
        tag:       tag
        content:   content
        inner_tag: inner_tag
        mode:      .explicit
    }
    ctx.check_inner_tag()!

    return ctx, next
}

// Limited support for APPLICATION CLASS Element.
pub struct ApplicationElement {
    RawElement
}

// new creates a new application class element.
pub fn ApplicationElement.new(tag Tag, content []u8) !ApplicationElement {
    if tag.class != .application {
        return error('Your tag is not .application')
    }
    raw := RawElement.new(tag, content)!
    return ApplicationElement{raw}
}

// from_element creates application class element from some element.
pub fn ApplicationElement.from_element(inner Element, tagnum int, mode TaggedMode) !ApplicationElement {
    raw := RawElement.from_element(inner, .application, tagnum, mode)!
    app := ApplicationElement{raw}
    return app
}

// tag returns the tag of the application class element.
pub fn (app ApplicationElement) tag() Tag {
    return app.RawElement.tag
}

// payload returns the payload of application class element.
pub fn (app ApplicationElement) payload() ![]u8 {
    return app.RawElement.content
}

// Limited support for PRIVATE CLASS Element.
pub struct PrivateELement {
    RawElement
}

// new creates a raw private class element.
pub fn PrivateELement.new(tag Tag, content []u8) !PrivateELement {
    if tag.class != .private {
        return error('Your tag is not private')
    }
    raw := RawElement.new(tag, content)!

    return PrivateELement{raw}
}

// from_element creates a new private class element from another element.
pub fn PrivateELement.from_element(inner Element, tagnum int, mode TaggedMode) !PrivateELement {
    raw := RawElement.from_element(inner, .private, tagnum, mode)!
    app := PrivateELement{raw}

    return app
}

// tag returns the tag of the private element.
pub fn (prv PrivateELement) tag() Tag {
    return prv.RawElement.tag
}

// payload returns the payload of the private element.
pub fn (prv PrivateELement) payload() ![]u8 {
    return prv.RawElement.content
}