module parser

import v.ast
import v.token

@[inline]
fn (p &Parser) current_attr_string_quote() u8 {
    if p.tok.kind == .string && p.tok.pos >= 0 && p.tok.pos < p.scanner.text.len {
        quote := p.scanner.text[p.tok.pos]
        if quote in [`'`, `"`] {
            return quote
        }
    }
    return `'`
}

fn (mut p Parser) parse_attr_arg(err_context string) (ast.AttrKind, string, u8) {
    if p.tok.kind == .name { // `name: arg`
        return ast.AttrKind.plain, p.check_name(), `'`
    } else if p.tok.kind == .number { // `name: 123`
        arg := p.tok.lit
        p.next()
        return ast.AttrKind.number, arg, `'`
    } else if p.tok.kind == .string { // `name: 'arg'`
        arg := p.tok.lit
        quote := p.current_attr_string_quote()
        p.next()
        return ast.AttrKind.string, arg, quote
    } else if p.tok.kind == .key_true || p.tok.kind == .key_false { // `name: true`
        arg := p.tok.kind.str()
        p.next()
        return ast.AttrKind.bool, arg, `'`
    } else if token.is_key(p.tok.lit) { // `name: keyword`
        return ast.AttrKind.plain, p.check_name(), `'`
    }
    p.unexpected(additional_msg: 'an argument is expected${err_context}')
    return ast.AttrKind.plain, '', `'`
}

fn (mut p Parser) parse_attr_call(name string, is_at bool, apos token.Pos) []ast.Attr {
    p.check(.lpar)
    mut base_kind := ast.AttrKind.plain
    mut base_arg := ''
    mut base_quote := u8(`'`)
    mut base_arg_name := ''
    mut base_call_arg_idx := -1
    mut base_has_arg := false
    mut attrs := []ast.Attr{}
    mut has_base_arg := false
    mut positional_arg_idx := 1
    mut call_arg_idx := 0
    for p.tok.kind !in [.rpar, .eof] {
        mut is_named := false
        mut arg_name := ''
        if p.tok.kind == .name && p.peek_token(1).kind == .colon {
            is_named = true
            arg_name = p.tok.lit
            p.next()
            p.check(.colon)
        }
        kind, arg, quote := p.parse_attr_arg(' in `(...)`')
        if is_named {
            if name == 'deprecated' && arg_name == 'msg' {
                if has_base_arg {
                    p.error_with_pos('duplicate `msg` argument for `@[deprecated(...)]` attribute',
                        apos.extend(p.prev_tok.pos()))
                }
                base_has_arg = true
                base_arg = arg
                base_kind = kind
                base_quote = quote
                base_arg_name = arg_name
                base_call_arg_idx = call_arg_idx
                has_base_arg = true
            } else {
                attrs << ast.Attr{
                    name:          '${name}_${arg_name}'
                    has_arg:       true
                    arg:           arg
                    kind:          kind
                    quote:         quote
                    pos:           apos.extend(p.prev_tok.pos())
                    has_at:        is_at
                    call_name:     name
                    call_arg_name: arg_name
                    call_arg_idx:  call_arg_idx
                }
            }
        } else if !has_base_arg {
            base_has_arg = true
            base_arg = arg
            base_kind = kind
            base_quote = quote
            base_arg_name = arg_name
            base_call_arg_idx = call_arg_idx
            has_base_arg = true
        } else {
            attrs << ast.Attr{
                name:         '${name}_${positional_arg_idx}'
                has_arg:      true
                arg:          arg
                kind:         kind
                quote:        quote
                pos:          apos.extend(p.prev_tok.pos())
                has_at:       is_at
                call_name:    name
                call_arg_idx: call_arg_idx
            }
            positional_arg_idx++
        }
        call_arg_idx++
        if p.tok.kind == .comma {
            p.next()
            continue
        }
        break
    }
    p.check(.rpar)
    base_attr := ast.Attr{
        name:          name
        has_arg:       base_has_arg
        arg:           base_arg
        kind:          base_kind
        quote:         base_quote
        pos:           apos.extend(p.prev_tok.pos())
        has_at:        is_at
        call_name:     name
        call_arg_name: base_arg_name
        call_arg_idx:  base_call_arg_idx
    }
    attrs.insert(0, base_attr)
    return attrs
}

fn (mut p Parser) parse_attr(is_at bool) []ast.Attr {
    mut kind := ast.AttrKind.plain
    p.inside_attr_decl = true
    defer {
        p.inside_attr_decl = false
    }
    apos := if is_at { p.peek_token(-2).pos() } else { p.prev_tok.pos() }
    if p.tok.kind == .key_unsafe {
        p.next()
        mut call_name := ''
        if p.tok.kind == .lpar {
            p.check(.lpar)
            p.check(.rpar)
            call_name = 'unsafe'
        }
        return [
            ast.Attr{
                name:      'unsafe'
                kind:      kind
                pos:       apos.extend(p.prev_tok.pos())
                has_at:    is_at
                call_name: call_name
            },
        ]
    }
    mut name := ''
    mut has_arg := false
    mut arg := ''
    mut quote := u8(`'`)
    mut comptime_cond := ast.empty_expr
    mut comptime_cond_opt := false
    if p.tok.kind == .key_if {
        kind = .comptime_define
        p.next()
        p.comptime_if_cond = true
        p.inside_if_expr = true
        p.inside_ct_if_expr = true
        comptime_cond = p.expr(0)
        p.comptime_if_cond = false
        p.inside_if_expr = false
        p.inside_ct_if_expr = false
        if comptime_cond is ast.PostfixExpr {
            comptime_cond_opt = true
        }
        name = comptime_cond.str()
    } else if p.tok.kind == .string {
        name = p.tok.lit
        quote = p.current_attr_string_quote()
        kind = .string
        p.next()
    } else {
        name = p.check_name()
        // support dot prefix `module.name: arg`
        if p.tok.kind == .dot {
            p.next()
            name += '.'
            name += p.check_name()
        }
        if p.tok.kind == .colon {
            has_arg = true
            p.next()
            kind, arg, quote = p.parse_attr_arg(' after `:`')
        } else if p.tok.kind == .lpar {
            return p.parse_attr_call(name, is_at, apos)
        }
    }
    return [
        ast.Attr{
            name:    name
            has_arg: has_arg
            arg:     arg
            kind:    kind
            quote:   quote
            ct_expr: comptime_cond
            ct_opt:  comptime_cond_opt
            pos:     apos.extend(p.tok.pos())
            has_at:  is_at
        },
    ]
}

fn (mut p Parser) is_attributes() bool {
    if p.tok.kind != .lsbr {
        return false
    }
    mut i := 0
    for {
        tok := p.peek_token(i)
        if tok.kind == .eof || tok.line_nr != p.tok.line_nr {
            return false
        }
        if tok.kind == .rsbr {
            break
        }
        i++
    }
    if i == 1 {
        // empty `[]` is an array literal, not an attribute
        return false
    }
    peek_rsbr_tok := p.peek_token(i + 1)
    if peek_rsbr_tok.line_nr == p.tok.line_nr && peek_rsbr_tok.kind != .rcbr {
        return false
    }
    return true
}

// when is_top_stmt is true, attrs are added to p.attrs
fn (mut p Parser) attributes() {
    start_pos := p.tok.pos()
    mut is_at := false
    if p.tok.kind == .lsbr {
        if p.pref.is_fmt {
        } else {
            p.error('`[attr]` has been deprecated, use `@[attr]` instead')
        }
        // [attr]
        p.check(.lsbr)
    } else if p.tok.kind == .at {
        // @[attr]
        p.check(.at)
        p.check(.lsbr)
        is_at = true
    }
    mut has_ctdefine := false
    for p.tok.kind != .rsbr {
        attr_start_pos := p.tok.pos()
        attrs := p.parse_attr(is_at)
        for attr in attrs {
            if p.attrs.contains(attr.name) && attr.name != 'wasm_export' {
                p.error_with_pos('duplicate attribute `${attr.name}`',
                    attr_start_pos.extend(p.prev_tok.pos()))
                return
            }
            if attr.kind == .comptime_define {
                if has_ctdefine {
                    p.error_with_pos('only one `[if flag]` may be applied at a time `${attr.name}`',
                        attr_start_pos.extend(p.prev_tok.pos()))
                    return
                } else {
                    has_ctdefine = true
                }
            }
            p.attrs << attr
        }
        if p.tok.kind != .semicolon {
            if p.tok.kind == .rsbr {
                p.next()
                break
            }
            p.unexpected(expecting: '`;`')
            return
        }
        p.next()
    }
    if p.attrs.len == 0 {
        p.error_with_pos('attributes cannot be empty', start_pos.extend(p.tok.pos()))
        return
    } else {
        p.check_deprecated_attributes()
    }
    // TODO: remove when old attr syntax is removed
    if p.inside_struct_attr_decl && p.tok.kind == .lsbr {
        p.error_with_pos('multiple attributes should be in the same [], with ; separators',
            p.prev_tok.pos().extend(p.tok.pos()))
        return
    } else if p.inside_struct_attr_decl && p.tok.kind == .at {
        p.error_with_pos('multiple attributes should be in the same @[], with ; separators',
            p.prev_tok.pos().extend(p.tok.pos()))
        return
    }
}

fn (mut p Parser) check_deprecated_attributes() {
    mut deprecated := false
    mut deprecated_after := false
    mut deprecated_after_pos := token.Pos{}
    for attr in p.attrs {
        match attr.name {
            'deprecated' {
                deprecated = true
            }
            'deprecated_after' {
                deprecated_after = true
                deprecated_after_pos = attr.pos
            }
            else {}
        }
    }
    if deprecated_after && !deprecated {
        p.warn_with_pos('@[deprecated_after] is only valid, in the presence of a `@[deprecated]` attribute',
            deprecated_after_pos)
    }
}