// Copyright (c) 2025 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module util

const d_sig = "\$d('"

// resolve_d_value replaces all occurrences of `$d('ident','value')`
// in `str` with either the default `'value'` param or a compile value passed via `-d ident=value`.
pub fn resolve_d_value(compile_values map[string]string, str string) !string {
    start := str.index(d_sig) or { return error('no "${d_sig}...\')" could be found in "${str}"') }
    mut i := 0
    mut ch := u8(`.`)
    mut bd_ident := []u8{cap: 20}
    mut blevel := 1
    for i = start + d_sig.len; i < str.len && ch != `'`; i++ {
        ch = str[i]
        if ch == `)` {
            blevel--
        } else if ch == `(` {
            blevel++
        }
        if ch.is_letter() || ch.is_digit() || ch == `_` {
            bd_ident << ch
        } else {
            if !(ch == `'`) {
                if ch == `$` {
                    return error('cannot use string interpolation in compile time \$d() expression')
                }
                return error('invalid `\$d` identifier in "${str}", invalid character `${rune(ch)}`')
            }
        }
    }
    d_ident := bd_ident.bytestr().trim_space()
    if d_ident == '' {
        return error('first argument of `\$d` must be a string identifier')
    }

    // At this point we should have a valid identifier in `d_ident`.
    // Next we parse out the default string value.

    // Advance past the `,` and the opening `'` in second argument, or ... eat whatever is there:
    for ; i < str.len; i++ {
        ch = str[i]
        match ch {
            ` `, `,` {
                continue
            }
            `'` {
                i++
            }
            else {}
        }

        break
    }
    // Rinse, repeat for the expected default value string
    ch = `.`
    dv_start := i
    mut dv_end := i
    for i < str.len {
        ch = str[i]
        dv_end++
        i++
        match ch {
            `'` {
                break
            }
            `(` {
                blevel++
            }
            `)` {
                blevel--
                if blevel <= 0 {
                    break
                }
            }
            `$` {
                return error('cannot use string interpolation in compile time \$d() expression')
            }
            else {}
        }
    }
    if dv_end - dv_start == 0 {
        return error('second argument of `\$d` must be a pure literal')
    }
    for ; blevel > 0 && i < str.len; i++ {
        if str[i] == `)` {
            i++
            break
        }
    }
    d_default_value := str#[dv_start..dv_end - 1].trim_space() // last character is the closing `)`
    // at this point we have the identifier and the default value.
    // now we need to resolve which one to use from `compile_values`.
    d_value := compile_values[d_ident] or { d_default_value }
    original_expr_to_be_replaced := str#[start..i]
    if original_expr_to_be_replaced[original_expr_to_be_replaced.len - 1] != `)` {
        panic('the last character of `${original_expr_to_be_replaced}` should be `)`')
    }
    rep := str.replace_once(original_expr_to_be_replaced, d_value)
    if original_expr_to_be_replaced.len > 0 && rep.contains(d_sig) {
        // if more `$d()` calls remains, resolve those as well:
        return resolve_d_value(compile_values, rep)
    }
    return rep
}