module main

pub interface Iterator {
mut:
    next() ?string
}

pub struct LineIterator {
    lines []string
mut:
    idx int
}

type AliasLineIterator = LineIterator

pub fn (mut line_iterator LineIterator) next() ?string {
    if line_iterator.idx >= line_iterator.lines.len {
        return none
    }
    defer { line_iterator.idx += 1 }
    return line_iterator.lines[line_iterator.idx]
}

fn iterator_as_interface() Iterator {
    return LineIterator{
        lines: ['interface']
    }
}

fn iterator_as_concrete_type() LineIterator {
    return LineIterator{
        lines: ['concrete']
    }
}

fn iterator_as_alias_concrete_type() AliasLineIterator {
    return AliasLineIterator(LineIterator{
        lines: ['alias', 'iterator', 'next']
    })
}

pub fn (mut line_iterator AliasLineIterator) next() ?string {
    if line_iterator.idx >= line_iterator.lines.len {
        return none
    }
    defer { line_iterator.idx += 2 }
    return line_iterator.lines[line_iterator.idx]
}

struct SquareIterator {
    arr []int
mut:
    idx int
}

interface Iterable[T] {
mut:
    idx int
    next() ?T
}

fn (mut iter SquareIterator) next() ?string {
    if iter.idx >= iter.arr.len {
        return none
    }
    defer { iter.idx++ }
    return (iter.arr[iter.idx] * iter.arr[iter.idx]).str()
}

fn collect_iterable(iter Iterable[string]) []string {
    mut out := []string{}
    for item in iter {
        out << item
    }
    return out
}

fn test_main() {
    mut out := []string{}
    for line in iterator_as_interface() {
        out << 'LINE: ${line}'
    }
    for idx, line in iterator_as_interface() {
        out << 'LINE [${idx}]: ${line}'
    }

    assert out[0] == 'LINE: interface'
    assert out[1] == 'LINE [0]: interface'

    for line in iterator_as_concrete_type() {
        out << 'LINE: ${line}'
    }
    for idx, line in iterator_as_concrete_type() {
        out << 'LINE [${idx}]: ${line}'
    }

    assert out[2] == 'LINE: concrete'
    assert out[3] == 'LINE [0]: concrete'

    mut iter := iterator_as_interface()
    for {
        line := iter.next() or { break }
        out << 'LINE: ${line}'
    }
    for _, line in iterator_as_concrete_type() {
        out << 'LINE: ${line}'
    }

    assert out[4] == 'LINE: interface'
    assert out[5] == 'LINE: concrete'

    for _, line in iterator_as_alias_concrete_type() {
        out << 'LINE: ${line}'
    }

    assert out[6] == 'LINE: alias'
    assert out[7] == 'LINE: next'
}

fn test_for_in_generic_iterator_interface_param() {
    iter := SquareIterator{
        arr: [1, 2, 3, 4, 5]
    }
    assert collect_iterable(iter) == ['1', '4', '9', '16', '25']
}