fetch.nct

use std/cli.Application
use std/http.{Client, Request}
use std/io.{BlockingReader, BlockingWriter}
use std/io
use std/time.Duration
use std/url.Url

blocking func run(): i32 {
    var application = Application.new("http-get", "Fetch one HTTP or HTTPS URL.") catch failure {
        report_failure(&failure) catch _ { return 2 }
        return 2
    }
    application.add_positional("URL", true, "Absolute URL to fetch.") catch failure {
        report_failure(&failure) catch _ { return 2 }
        return 2
    }
    let arguments = application.parse_process() catch failure {
        if failure.has_code("std.cli.missing_positional")
        || failure.has_code("std.cli.unexpected_positional") {
            report_usage(&application) catch _ { return 2 }
        } else {
            report_failure(&failure) catch _ { return 2 }
        }
        return 2
    }
    let source = arguments.positional("URL") otherwise { return 2 }
    fetch(source) catch failure {
        report_failure(&failure) catch _ { return 2 }
        return 2
    }
    return 0
}

blocking func fetch(source: &str): void! {
    let url = Url.parse(source)?
    let request = Request.get(move url)?
    let client = Client.new()
    var response = client.send_with_timeout_blocking(move request, Duration.from_seconds(5))?
    let status = response.status().code().to_string()
    let body = response.read_to_end_blocking()?
    var output = io.stdout()
    output.write_text_blocking("HTTP ")?
    output.write_text_blocking(&status)?
    output.write_text_blocking("\n")?
    output.write_blocking(&body)?
    return
}

blocking func report_usage(application: &Application): void! {
    var output = io.stderr()
    let usage = application.usage()
    output.write_text_blocking(&usage)?
    output.write_text_blocking("\n")?
    return
}

blocking func report_failure(failure: &error): void! {
    var output = io.stderr()
    output.write_text_blocking("http-get: ")?
    output.write_text_blocking(failure.code())?
    output.write_text_blocking(": ")?
    output.write_text_blocking(failure.message())?
    output.write_text_blocking("\n")?
    return
}