Server.cs

namespace Webtech3;

/**
<summary> Main class. Realize server instance. </summary>
<example>
    Simple example.
    <code>
        using Webtech3;

        class PingPongExample {
            [APIInfo(url: "/ping")]
            public static async Task Pong(Request req, Response res) {
                Logger.Info("Pong", "Ping request catched");
                await res.ResponseText("Pong");
            }
        }

        class PongMain {
            public static async Task Main() {
                var api = new RestAPI(typeof(PingPongExample));
                var server = new Server() { Api = api }; //without args listen on 127.0.0.1:8888
                Console.CancelKeyPress += (_, e) => { //need for correct end of work with Ctrl+C
                    e.Cancel = true;
                    server.Work = false; //stop the server
                };
                Logger.Info("main", "Working started");
                await server.Listen();
            }
        }
    </code>
</example>
<example>
    Example with auth.
    <code>
        static class WithAuthExample {
            [APIInfo(url: "/test", auth: true)]
            public static async Task TestAuth(Request req, Response res) {
                await res.ResponseText("Response if you authorized by header only.");
            }
        }

        class AuthMain {
            public static async Task Main() {
                var users_repo = new UsersList(
                    new User(ID: 0, Login_hash: "tyson", Password_hash: "punch")
                );
                var auth = new BasicAuth() { Users = users_repo };
                var api = new RestAPI() { Authentificator = auth };
                api.Add(WithAuthExample.TestAuth);
                var server = new Server(addresses: new IP(127, 0, 0, 1, 8989)) { Api = api };
                //need for correct end of work with Ctrl+C
                Console.CancelKeyPress += (_, e) => {
                    e.Cancel = true;
                    server.Work = false; //stop the server
                };

                await server.Listen();
            }
        }
    </code>
</example>
<example>
    Example with roles.
    <code>
        using Webtech3;
        using Webtech3.Defaults;

        class WithRoleExample {
            public static async Task TestRole(Request req, Response res) {
                await res.ResponseJson(new {
                    Status = 200,
                    Text = "Response if you have correct role only."
                });
            }
        }

        class RoleMain {
            public static async Task Main() {
                var users_repo = new UsersList(
                    new User(0, "tyson", "punch"),
                    new User(1, "rabbit", "carrot")
                );
                //Dynamicly setting the role
                var tyson = users_repo.Get(0UL)!;
                tyson = tyson with {Role = Roles.Admin};
                users_repo.Replace(0UL, tyson);

                var auth = new BasicAuth() { Users = users_repo };
                var api = new RestAPI() { Authentificator = auth };
                api.Route( //You can set APIInfo so
                    url: "/test",
                    roles: [Roles.Admin], //if roles is specified, auth implicitly enabled
                    action: WithRoleExample.TestRole
                );
                var server = new Server() { Api = api };
                //need for correct end of work with Ctrl+C        
                Console.CancelKeyPress += (_, e) => {
                    e.Cancel = true;
                    server.Work = false; //stop the server
                };
                await server.Listen();
            }
        }
    </code>
</example>
*/
public sealed class Server {
    HttpListener http;
    List<Task> tasks;
    bool work;
    /// <summary>
    /// Property for check (get) &amp; begin/end (set) server work
    /// </summary>
    /// <value>True - server works, false otherwise</value>
    public bool Work {
        get => work;
        set {
            work = value;
            if(!work)
                http.Stop();
        }
    }
    /// <summary>
    /// API instance.
    /// </summary>
    public required RestAPI Api { get; init; }
    /// <summary>
    /// Construct the server.
    /// </summary>
    /// <param name="use_https">Flag, means use https or not. Default is false.</param>
    /// <param name="addresses">IP addresses to listen on.</param>
    /// <remarks>
    /// For using https you need mannually configure SSL certificate for every address in OS.
    /// </remarks>
    public Server(bool use_https = false, params IP[] addresses) {
        http = new(); tasks = new(); work = true;
        if(addresses.Length == 0)
            http.Prefixes.Add($"http{(use_https ? "s" : "")}://{new IP(127, 0, 0, 1, 8888)}/");
        else
            foreach(var ip in addresses)
                http.Prefixes.Add($"http{(use_https ? "s" : "")}://{ip}/");
    }
    /// <summary>
    /// Stops the listening.
    /// </summary>
    public void Stop() => http.Stop();
    /// <summary>
    /// Close server.
    /// </summary>
    /// <returns>Task obj.</returns>
    public async Task Close() {
        await Task.WhenAll(tasks);
        http.Close();
    }
    /// <summary>
    /// Main loop.
    /// </summary>
    /// <returns>Task obj.</returns>
    public async Task Listen() {
        http.Start();
        Context? ctx = null;
        while(work) try {
            ctx = await http.GetContextAsync();
            Request req = new(ctx.Request); Response res = new(ctx.Response);
            var endpoint = Api[req.Method, req.Url];
            if(endpoint == null) 
                await res.ResponseError(501, "Method doesn't exists.");
            else
                if(endpoint.Info.Authentication) {
                    req.CurrentUser = Api.Authentificator?.Authentificate(req);
                    if(req.CurrentUser == null)
                        await res.ResponseError(401, "Not authorized.");
                    else
                        if(endpoint.Info.Roles == null)
                            tasks.Add(endpoint.Action(req, res));
                        else
                            if(endpoint.Info.Roles?.Any(r => r == req.CurrentUser.Role) ?? false)
                                tasks.Add(endpoint.Action(req, res));
                            else
                                await res.ResponseError(403, "You doesn't have a sufficient rights for calling this method.");
                } else tasks.Add(endpoint.Action(req, res));
            if(tasks.Count > 20)
                tasks.RemoveAll(t => t.IsCompleted);
        } catch(Exception err) {
            if(ctx != null)
                await new Response(ctx.Response).ResponseError(500, "Internal exception", err.Message);
        }
        Stop();
        await Close();
    }
}