Launch

// Mission control: run the checklist, ask how long a countdown you want, count down, and launch.
//
// Every part of this has appeared before. The checklist is an array of text, the countdown is a
// loop with a pause from the Time package between steps, and the question is the line reading
// from the Input lesson, with the number checked the way the Parse lesson checks it.
//
// What makes it a whole program is that the input is handled in every way it can arrive. A
// number from 1 to 10 sets the countdown and an empty line takes the default of 10, so the
// countdown is always bounded. Anything else is asked again. And if the input ends before an
// answer arrives (Ctrl+Z and Enter on Windows, Ctrl+D elsewhere, or the end of piped input),
// nobody gave the go, so the mission is scrubbed.
import Allocator::{ Allocator, SystemAllocator };
import Format::ParseInt32;
import Io::{ IoErrorKind, Print, PrintLine, ReadLine };
import Text::StringBuilder;
import Time::{ Duration, SleepFor };

// A pause that does not happen only makes the countdown quicker, so a failed sleep is ignored
// on purpose rather than by accident.
func Pause(milliseconds: int64) {
    SleepFor(Duration::FromMilliseconds(milliseconds)) catch { else => {} };
}

func Main() -> int {
    PrintLine("\u{1F680}  RUX MISSION CONTROL  \u{1F680}");
    PrintLine("========================");
    let checklist = [
        "fuel ............. loaded",
        "crew ............. strapped in",
        "weather .......... clear skies",
        "snacks ........... dangerously low",
        "borrow checker ... satisfied"
    ];
    for item in checklist {
        PrintLine("  {}  \u{2705}", item);
        Pause(150);
    }
    PrintLine();

    var system = SystemAllocator();
    let allocator: Allocator = system;
    var builder = StringBuilder(allocator);

    var count = 0;
    while count == 0 {
        Print("Count down from? (1 to 10, Enter for 10) ");
        builder.Clear();
        match ReadLine(builder) {
            .Success(_) => {},
            .Failure(error) if error.kind == IoErrorKind::EndOfStream => {
                PrintLine();
                PrintLine("No go from the flight director. Mission scrubbed.  \u{1F6D1}");
                return 0;
            },
            .Failure(_) => {
                PrintLine("The radio is down: the input could not be read.");
                return 1;
            }
        }

        let answer = builder.View().Trim();
        if answer.IsEmpty() {
            count = 10;
        } else {
            // Text that is not a number becomes 0, which the range check refuses as well.
            let asked = ParseInt32(answer) catch { else => 0 };
            if asked >= 1 && asked <= 10 {
                count = asked;
            } else {
                PrintLine("Mission rules allow 1 to 10. Say again?");
            }
        }
    }

    PrintLine();
    while count > 0 {
        PrintLine("   T minus {}...", count);
        Pause(400);
        count -= 1;
    }
    PrintLine("   \u{1F525} IGNITION \u{1F525}");
    Pause(500);

    // Each frame is one line, so the rocket climbs up the terminal as it prints.
    let frames = [
        "                \u{1F680}",
        "              \u{1F680}",
        "            \u{1F680}",
        "          \u{1F680}",
        "        \u{1F680}",
        "      \u{1F680}",
        "    \u{1F680}",
        "  \u{1F680}"
    ];
    for frame in frames {
        PrintLine(frame);
        Pause(120);
    }
    PrintLine();
    PrintLine("   \u{2B50}  \u{1F30D}  \u{2B50}");
    PrintLine("   Liftoff! The crew waves from the window.  \u{1F44B}");
    return 0;
}