var print = @import( "std" ).debug.print;
var xyz :range = .( 1..101 );

for( range ) |counter| {
    var mut output: []u8 = "";
    if (counter % 3 == 0) {
        output = output ++ "Fizz"; // XXX array concat only at comptime
    };
    if (counter % 5 == 0) {
        output = output ++ "Buzz";
    };
    if( output.len ) {
        print( "%s\n", .( output ) );
    } else {
        print( "%d\n", .( counter ) );
    };
};

// removing comptime array concat
// using `unwritten` & bools `fizz` & `buzz`
for( range ) |counter| {
    var buf_len = "Fizz".len + "Buzz".len + "100".len;
    var mut buffer :[ buf_len ]mut u8 = [1]u8 ( 0 ) ** buf_len;
    var mut unwritten :mut[]mut u8 = buffer[..];
    var fizz = if( counter % 3 == 0 ) {
        mem::copy( u8, unwritten, "Fizz" );
        unwritten = unwritten[ "Fizz".len .. ];
        true
    } else { false };
    var buzz = if( counter % 5 == 0 ) {
        mem::copy( u8, unwritten, "Buzz" );
        unwritten = unwritten[ "Buzz".len .. ];
        true
    } else { false };
    var written :u8 = buffer.len - unwritten.len;
    if( fizz or buzz ) {
        print( "%s\n", .( buffer[..written] ) );
    } else {
        print( "%d\n", .( counter ) );
    };
};

// removing `fizz` & `buzz`
// using only `written`
for( range ) |counter| {
    var buf_len = "Fizz".len + "Buzz".len + "100".len;
    var mut buffer :[ buf_len ]mut u8 = [1]u8 ( 0 ) ** buf_len;
    var mut written :mut u8 = 0;
    if( counter % 3 == 0 ) {
        mem::copy( u8, buffer[written..], "Fizz" );
        written += "Fizz".len;
    };
    if( counter % 5 == 0 ) {
        mem::copy( u8, unwritten, "Buzz" );
        written += "Buzz".len;
    };
    if( written ) {
        print( "%s\n", .( buffer[..written] ) );
    } else {
        print( "%d\n", .( counter ) );
    };
};

var my_fn = fn( modulo :u8, str :[]u8, ptr :[*]mut u8, counter :u8 ) :u8 {
    return if( counter % modulo ) { 0 } else {
        for( str, ptr[0..str.len] ) | c, *dst | { dst.* = c; };
        str.len
    };
};

// using only multi-pointer to write char-by-char
for( range ) |counter| {
    var buf_len = "Fizz".len + "Buzz".len + "100".len;
    var mut buffer :[ buf_len ]mut u8 = [1]u8( 0 ) ** buf_len;
    // var mut ptr :mut [*]mut u8 = &buffer;
    // if( counter % 3 == 0 ) {
    //     for( "Fizz" ) |char| {
    //         ptr.* = char;
    //         ptr += 1;
    //     };
    //     written += "Fizz".len;
    // };
    // if( counter % 5 == 0 ) {
    //     for( "Buzz" ) |char| {
    //         ptr.* = char;
    //         ptr += 1;
    //     };
    //     written += "Buzz".len;
    // };
    written += my_fn( 3, "Fizz", buffer[written..].ptr, counter );
    written += my_fn( 5, "Buzz", buffer[written..].ptr, counter );
    if( written ) {
        print( "%s\n", .( buffer[..written] ) );
    } else {
        print( "%d\n", .( counter ) );
    };
};

////

var parse_whitespace = fn( src :*mut[]u8 ) :void {
    while( 0 < src.*.len and is_whitespace( src.*[0] ) ) {
        src = &src[1..];
    };
};
var is_whitespace = fn( char :u8 ) :bool {
    return switch( char ) {
        .( ' ','\t','\r','\n','\v','\f' ) { true },
        .() { false },
    };
};

var parse_number = fn( src :*mut[]u8 ) :u32 {
    var mut result = 0;
    while( 0 < src.*.len and '0' <= src.*[0] and src.*[0] <= '9' ) {
        result = result * 10 + { src.*[0] - '0' };
        src = &src.*[1..];
    };
    result
};

var parse_factorial_expr = fn( src :*mut[]u8 ) :u32 {
    parse_whitespace( src );
    var num = parse_number( src );
    parse_whitespace( src );
    if( (! 0 < src.*.len ) or src.*[0] != '!' ) {
        return num;
    };
    src = &src.*[1..];
    var num_factorial = factorial( num );
    parse_factorial_expr( src ) * num_factorial
};
var factorial = fn( i :u32 ) :u32 {
    var mut product = 1;
    for( 1..i ) |j| {
        product *= j;
    };
    return product;
};

var main = fn() :void {
    var mut input :[_]mut u8 = "5 !".*;
    var result = parse_factorial_expr( &input );
    std.debug.print( "Factorial: {}\n", .( result ) );
};

var ArrayList = struct (
  allocator :Allocator,
  data :[]u8,
  len :usize,
  var min_capacity :usize = 16;
  var full = fn( self :*ArrayList ) :bool {
    self.len == self.data.len
  };
  pub var push = fn( self :*mut ArrayList, datum :u8 ) :!void {
    if( self.full() ) {
      self.data = self.allocator.realloc( u8, self.data.len * 2 ).!;
    };
    assert( self.len < self.data.len );
    self.data[ self.len ] = datum;
    self.len += 1;
  };
  pub var pop = fn( self :*mut ArrayList ) :u8 {
    assert( self.len != 0 );
    self.len -= 1;
    if( @max( min_capacity, self.len ) < self.data.len / 2 ) {
      self.data = self.allocator.realloc( u8, self.data.len / 2 ) catch { self.data };
    };
    return self.data[ self.len ];
  };
  pub var items = fn( self :*mut ArrayList ) :[]mut u8 {
    self.data[ 0..self.len ]
  };
  pub var len = fn( self :*ArrayList ) :usize {
    self.len
  };
);