import System.*
import System.Data.Json.*
import System.Result.*
import System.Concurrency.Tasks.*
import System.Text.*
import System.Web.Http.*
import System.Web.Http.Json.*

func ErrorContent(message: string) -> HttpContent {
    // Messages passed here are application-owned constants, not unescaped input.
    return HttpStringContent(message, "application/json; charset=utf-8")
}

class ReportServer {
    async func Configure(context: HttpContext) -> Task<Result<unit, AppError>> {
        let request = context.Request
        if request.Method.Method == "GET" && request.Target == "/report" {
            let report = CreateReport()?
            let content = JsonContent.Create(report)?
            context.Respond(HttpStatusCode.OK, content)
        } else if request.Method.Method == "POST" && request.Target == "/reports" {
            // Invalid input becomes an HTTP response at this application boundary.
            let acknowledged = await Acknowledge(request.Content)
            if let Ok(reply) = acknowledged {
                if let Ok(content) = JsonContent.Create(reply) {
                    context.Respond(HttpStatusCode.Created, content)
                    return Ok(())
                }
            } else if acknowledged is Failure(JsonError.Reflection(_)) || acknowledged is Failure(JsonError.UnsupportedMapping(_)) {
                context.Respond(HttpStatusCode.InternalServerError, ErrorContent("{\"error\":\"Report mapping failed\"}"))
                return Ok(())
            }
            context.Respond(HttpStatusCode.BadRequest, ErrorContent("{\"error\":\"Invalid report\"}"))
        } else {
            context.Respond(HttpStatusCode.NotFound, ErrorContent("{\"error\":\"Not found\"}"))
        }
        return Ok(())
    }

    async func Serve(server: HttpServer, count: int) -> Task<Result<unit, AppError>> {
        var index = 0
        while index < count {
            let accepted = await server.Accept()
            if let Failure(reason) = accepted {
                // Accept already closes the rejected connection and releases its slot.
                // Count rejected attempts too, so the sample has a bounded lifetime.
                if reason is HttpError.Protocol(_) || reason is HttpError.LimitExceeded(_) || reason is HttpError.Unsupported(_) {
                    index += 1
                    continue
                }
                return Failure(AppError.Http(reason))
            }
            let Ok(context) = accepted else {
                return Failure(AppError.Body("Missing accepted request"))
            }
            // Close the owned exchange before propagating a configuration failure.
            let configured = await Configure(context)
            if let Failure(error) = configured {
                context.Close()
                return Failure(error)
            }
            let sent = await context.Complete()
            if let Failure(sendError) = sent {
                return Failure(AppError.Http(sendError))
            }
            index += 1
        }
        return Ok(())
    }

}

func StartServer(arguments: string[]) -> Task<()> {
    var count = 1
    if arguments.Length > 0 {
        if let Ok(parsed) = Int32.Parse(arguments[0]) {
            count = parsed
        }
    }
    let Ok(server) = HttpServer.Listen("127.0.0.1", 0, 4) else {
        Panic("Listen failed")
        return Task.CompletedTask
    }
    let Ok(port) = server.GetLocalPort() else {
        server.Close()
        Panic("Local port unavailable")
        return Task.CompletedTask
    }
    Console.WriteLine(port)
    let serving = ReportServer().Serve(server, count)
    return FinishServing(server, serving)
}

async func FinishServing(server: HttpServer, serving: Task<Result<unit, AppError>>) -> Task<()> {
    let result = await serving
    server.Close()
    if let Failure(error) = result {
        Panic(error.ToString())
    }
    Console.WriteLine("Reports served")
}

async func Main(arguments: string[]) -> Task<()> {
    await StartServer(arguments)
}
