module util

import strings

// Surrounder is an utility to help you manage a stack of additions, that
// should be done *both* _before_ and _after_ a given piece of generated
// code, in a synchronised way. It does so by forcing you to put the
// creation/destruction samples next to each other, so that it is easier to
// keep them in sync and spot errors.
// Note: Surrounder writes the creation samples (`befores`) in the _same_ order
// they were added, and the destruction samples (`afters`) in _reverse_ order.
//
// Usage:
// ```v
// mut sr := new_surrounder(2) // just a rough initial guess; it can grow
// sr.add('string tmp1 = ...;', 'string_free(&tmp1);')
// sr.add('string tmp2 = ...;', 'string_free(&tmp2);')
// ..
// sr.builder_write_befores(mut some_string_builder)
// some_string_builder.writeln('MIDDLE_that_uses_tmp1_and_tmp2')
// sr.builder_write_afters(mut some_string_builder)
// ```
// ... will produce this in `some_string_builder`:
// ```
// string tmp1 = ...;
// string tmp2 = ...;
// MIDDLE_that_uses_tmp1_and_tmp2
// string_free(&tmp2);
// string_free(&tmp1);
// ```

@[noinit]
pub struct Surrounder {
mut:
    befores []string
    afters  []string
}

// new_surrounder creates a new Surrounder instance.
// The expected_length is a hint for the initial capacity for the
// befores/afters stacks.
pub fn new_surrounder(expected_length int) Surrounder {
    return Surrounder{
        befores: []string{cap: expected_length}
        afters:  []string{cap: expected_length}
    }
}

// add appends a `before`/`after` pair to the surrounder
// When you call .after() or .builder_write_afters(),
// all `before` parts will be in order, while all `after`
// parts, will be in reverse order.
pub fn (mut s Surrounder) add(before string, after string) {
    s.befores << before
    s.afters << after
}

// before returns all the `before` parts that were accumulated so far
@[manualfree]
pub fn (s &Surrounder) before() string {
    len := s.befores.len
    if len > 0 {
        mut res := strings.new_builder(len * 100)
        defer {
            unsafe { res.free() }
        }
        for i := 0; i < len; i++ {
            x := s.befores[i]
            if x.len > 0 {
                res.writeln(x)
            }
        }
        ret := res.str()
        return ret
    }
    return ''
}

// after returns all the `after` parts that were accumulated so far,
// in reverse order of their addition.
@[manualfree]
pub fn (s &Surrounder) after() string {
    len := s.afters.len
    if len > 0 {
        mut res := strings.new_builder(len * 100)
        defer {
            unsafe { res.free() }
        }
        for i := len - 1; i >= 0; i-- {
            x := s.afters[i]
            if x.len > 0 {
                res.writeln(x)
            }
        }
        ret := res.str()
        return ret
    }
    return ''
}

// builder_write_befores writeln-es all the `before` parts into the given
// string builder `sb`.
pub fn (s &Surrounder) builder_write_befores(mut sb strings.Builder) {
    len := s.befores.len
    if len > 0 {
        for i := 0; i < len; i++ {
            x := s.befores[i]
            if x.len > 0 {
                sb.writeln(x)
            }
        }
    }
}

// builder_write_afters writeln-es all the `after` parts into the given
// string builder `sb`. They will be written there in reverse order, compared
// to how/when they were added.
pub fn (s &Surrounder) builder_write_afters(mut sb strings.Builder) {
    len := s.afters.len
    if len > 0 {
        for i := len - 1; i >= 0; i-- {
            x := s.afters[i]
            if x.len > 0 {
                sb.writeln(x)
            }
        }
    }
}

// free frees the private resources associated with the surrounder instance
// Called automatically by `-autofree`, or in `@[manualfree]` tagged functions.
@[unsafe]
pub fn (mut s Surrounder) free() {
    unsafe {
        s.befores.free()
        s.afters.free()
    }
}