import string;
import array;

void main() {
    // Unlike arrays, slices are typed only by the
    // elements they contain (not the number of elements).
    // An uninitialized slice equals to null and has
    // length 0.
    array<string> s;
    print("uninit: " + s + " " + (s is null) + " " + (s.length() == 0));

    // To create an empty slice with non-zero length, use
    // the array constructor. Here we make a slice of
    // strings of length 3 (initially empty strings).
    s = array<string>(3);
    print("emp: " + s + " len: " + s.length() + " cap: " + s.capacity());

    // We can set and get just like with arrays.
    s[0] = "a";
    s[1] = "b";
    s[2] = "c";
    print("set: " + s);
    print("get: " + s[2]);

    // length() returns the length of the slice as expected.
    print("len: " + s.length());

    // In addition to these basic operations, slices
    // support several more that make them richer than
    // arrays. One is the insertLast method, which
    // adds one or more new values to the end of the slice.
    s.insertLast("d");
    s.insertLast("e");
    s.insertLast("f");
    print("apd: " + s);

    // Slices can also be copied. Here we create a new
    // slice c and copy the contents of s into it.
    array<string> c = s;
    print("cpy: " + c);

    // Slices support a "slice" operator with the syntax
    // slice.slice(start, end). For example, this gets a slice
    // of the elements s[2], s[3], and s[4].
    array<string> l = s.slice(2, 5);
    print("sl1: " + l);

    // This slices up to (but excluding) s[5].
    l = s.slice(0, 5);
    print("sl2: " + l);

    // And this slices up from (and including) s[2].
    l = s.slice(2);
    print("sl3: " + l);

    // We can declare and initialize a variable for slice
    // in a single line as well.
    array<string> t = {"g", "h", "i"};
    print("dcl: " + t);

    // AngelScript doesn't have a built-in slices package,
    // so we'll implement a simple equality check ourselves.
    array<string> t2 = {"g", "h", "i"};
    if (arraysEqual(t, t2)) {
        print("t == t2");
    }

    // Slices can be composed into multi-dimensional data
    // structures. The length of the inner slices can
    // vary, unlike with multi-dimensional arrays.
    array<array<int>> twoD(3);
    for (uint i = 0; i < 3; i++) {
        uint innerLen = i + 1;
        twoD[i].resize(innerLen);
        for (uint j = 0; j < innerLen; j++) {
            twoD[i][j] = int(i) + int(j);
        }
    }
    print("2d: " + twoD);
}

bool arraysEqual(array<string>@ a, array<string>@ b) {
    if (a.length() != b.length()) return false;
    for (uint i = 0; i < a.length(); i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

uninit: {} true true
emp: {  } len: 3 cap: 3
set: {a b c}
get: c
len: 3
apd: {a b c d e f}
cpy: {a b c d e f}
sl1: {c d e}
sl2: {a b c d e}
sl3: {c d e f}
dcl: {g h i}
t == t2
2d: {{0} {1 2} {2 3 4}}