@derive(Copy)
struct Complex {
    re: float,
    im: float,
}

fn complex_make(re: float, im: float) -> Complex {
    return Complex { re: re, im: im };
}

fn complex_add(a: Complex, b: Complex) -> Complex {
    return Complex { re: a.re + b.re, im: a.im + b.im };
}

fn complex_mul(a: Complex, b: Complex) -> Complex {
    return Complex {
        re: a.re * b.re - a.im * b.im,
        im: a.re * b.im + a.im * b.re
    };
}

fn complex_abs2(z: Complex) -> float {
    return z.re * z.re + z.im * z.im;
}

fn complex_print(z: Complex) {
    println "{z.re}{z.im}i";
}

fn pick_char(iter: int, max_iter: int, edge_chars: char[], edge_count: int) -> char {
    if (iter >= max_iter) { return ' '; }
    if (iter <= 0) { return edge_chars[0]; }

    let t: float = ((float)iter) / ((float)max_iter);
    let idx: int = (int)(t * ((float)(edge_count - 1)));

    if (idx < 0) { idx = 0; }
    if (idx >= edge_count) { idx = edge_count - 1; }

    return edge_chars[idx];
}

fn main() {
    let width: int = 120;
    let height: int = 40;
    let max_iter: int = 200;

    let edge_chars: char[12] = [ '#', '@', '%', '8', '&', '*', '+', '=', '-', ':', '.', ',' ];
    let edge_count: int = 12;

    let min_re: float = -2.2;
    let max_re: float =  1.0;
    let min_im: float = -1.2;
    let max_im: float =  1.2;

    for y in 0..height {
        let im: float =
            max_im - (max_im - min_im) * ( ((float)y) / ((float)(height - 1)) );

        for x in 0..width {
            let re: float =
                min_re + (max_re - min_re) * ( ((float)x) / ((float)(width - 1)) );

            let c: Complex = complex_make(re, im);
            let z: Complex = complex_make(0.0, 0.0);

            let iter: int = 0;
            while (iter < max_iter and complex_abs2(z) <= 4.0) {
                z = complex_add(complex_mul(z, z), c);
                iter += 1;
            }

            let pixel = pick_char(iter, max_iter, edge_chars, edge_count);
            print "{pixel}";
        }
        print "\n";
    }
}