import System.*
import System.Result.*
import System.Concurrency.Tasks.*
import System.Networking.Sockets.*
import System.Networking.*
import System.Collections.*

func Check(condition: bool) {
    if !condition {
        Panic("Socket client contract failed")
    }
}

func Churn() {
    var index = 0
    while index < 400 {
        let garbage: byte[] = [(byte)0]
        _ = garbage
        index += 1
    }
}

async func SendGreeting(socket: Socket) -> Task<Result<int, SocketError>> {
    var sent = 0
    while sent < 2 {
        let buffer: byte[] = [(byte)9, (byte)72, (byte)105, (byte)9]
        let pending = socket.Send(((ReadOnlyMemory<byte>)buffer).Slice(1 + sent, 2 - sent))
        // Each Send owns a snapshot; this reuse must not alter the transmitted bytes.
        buffer[1] = (byte)0
        buffer[2] = (byte)0
        Churn()
        let count = await pending?
        Check(count > 0)
        sent += count
    }
    Console.WriteLine("Sent Hi")
    return Ok(sent)
}

async func ReadGreeting(socket: Socket) -> Task<Result<int, SocketError>> {
    let buffer: byte[] = [(byte)9, (byte)9, (byte)9, (byte)9]
    var received = 0
    while received < 2 {
        let pending = socket.Receive(((Memory<byte>)buffer).Slice(1 + received, 2 - received))
        Churn()
        let count = await pending?
        Check(count > 0)
        received += count
    }
    Check(buffer[0] == 9 && buffer[1] == 72 && buffer[2] == 105 && buffer[3] == 9)
    Check(await socket.Receive(((Memory<byte>)buffer).Slice(0, 1))? == 0)
    Console.WriteLine("Received Hi; peer finished sending")
    return Ok(received)
}

async func Exchange(socket: Socket) -> Task<Result<int, SocketError>> {
    Check(await SendGreeting(socket)? == 2)
    return await ReadGreeting(socket)
}

async func ResolveHost() -> Task<Result<Sequence<IPAddress>, DnsError>> {
    let addresses = await Dns.GetHostAddresses("localhost")?
    return Ok(addresses)
}

async func ExchangeGreeting(addresses: Sequence<IPAddress>) -> Task<Result<int, SocketError>> {
    // The verifier substitutes the host's ephemeral loopback port.
    let pending = Socket.Connect(addresses, 19090)
    Churn()
    let socket = await pending?
    let result = await Exchange(socket)
    socket.Close()
    socket.Close()
    let closed = socket.Receive([(byte)0]).GetResult()
    if let Failure(error) = closed {
        Check(error is SocketError.Closed)
    } else {
        Panic("Closed socket admitted a receive")
    }
    let closedSend = socket.Send([(byte)0]).GetResult()
    if let Failure(error) = closedSend {
        Check(error is SocketError.Closed)
    } else {
        Panic("Closed socket admitted a send")
    }
    return result
}

func StartExchange(addresses: Sequence<IPAddress>) {
    // The controlled loopback demo deliberately tries an address with no listener first.
    let Ok(fallback) = IPAddress.Parse("127.0.0.2") else {
        Panic("Invalid fallback address in sample")
        return
    }
    let Ok(replacement) = IPAddress.Parse("127.0.0.3") else {
        Panic("Invalid replacement address in sample")
        return
    }
    let candidates = ArrayList<IPAddress>()
    candidates.Add(fallback)
    var index = 0
    while index < addresses.Count {
        candidates.Add(addresses[index])
        index += 1
    }
    let greeting = ExchangeGreeting(candidates)
    // Connect already owns the address snapshot; caller reuse is safe.
    candidates[0] = replacement
    candidates[1] = replacement
    greeting.OnCompleted(() => {
        if let Ok(count) = greeting.GetResult() {
            Check(count == 2)
            Console.WriteLine("Socket closed")
        } else {
            Panic("TCP exchange failed")
        }
    })
}

func Main() {
    let empty = ArrayList<string>()
    if let Failure(error) = Socket.Connect(empty, 19090).GetResult() {
        Check(error is SocketError.InvalidRange)
    } else {
        Panic("Empty address sequence admitted")
    }
    let invalid: Sequence<string> = ["127.0.0.1", "bad address"]
    if let Failure(error) = Socket.Connect(invalid, 19090).GetResult() {
        Check(error is SocketError.InvalidAddress)
    } else {
        Panic("Malformed address sequence admitted")
    }
    if let Failure(error) = Dns.GetHostAddresses("bad name").GetResult() {
        Check(error is DnsError.InvalidName)
    } else {
        Panic("Invalid hostname admitted")
    }
    let lookup = ResolveHost()
    Churn()
    lookup.OnCompleted(() => {
        if let Ok(addresses) = lookup.GetResult() {
            Check(addresses.Count > 0)
            Console.WriteLine("Resolved localhost")
            StartExchange(addresses)
        } else {
            Panic("Hostname lookup failed")
        }
    })
    TaskQueue.Default.Post(() => Console.WriteLine("Other work runs while TCP is pending"))
}
