Luski.Net/Luski.net/Server.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Json;
using System.Net.Mime;
using System.Text.Json;
using System.Text.Json.Serialization.Metadata;
using System.Threading;
using System.Threading.Tasks;
using Luski.net.Enums;
using Luski.net.Interfaces;
using Luski.net.JsonTypes.BaseTypes;
using Luski.net.JsonTypes.WSS;
using Luski.Shared.PublicServers.V1.ClientToServer.HTTP;
using Luski.Shared.PublicServers.V1.Enums;
using Luski.Shared.PublicServers.V1.ServerToClient.HTTP;
using File = System.IO.File;

namespace Luski.net;

public partial class Server
{
    
    internal Server(string Domain, string API_Version, bool Secure = true)
    {
        this.Domain = Domain;
        this.ApiVersion = API_Version;
        this.Secure = Secure;
        Storage = new(Domain);
        EncryptionHandler = new(Storage);
    }
    
    internal bool Secure = true;
    internal string wssurl { get; set; } = "";

    public ServerEncryption EncryptionHandler { get; }
    public ServerStorage Storage { get; }
    
    public async Task<Stream> GetAvatar(CancellationToken CancellationToken)
    {
        bool isc = File.Exists(Storage.GetStorageDirectory(StorageDirectory.ServerAssets) + "Icon");
        if (!isc) await GetFromServer($"socketserver/Icon/", Storage.GetStorageDirectory(StorageDirectory.ServerAssets) + "Icon", CancellationToken);
        return Storage.GetResourceStream(StorageDirectory.ServerAssets, "Icon");
    }

    public void SendServerOld<Tvalue>(Tvalue Payload, JsonTypeInfo<Tvalue> jsonTypeInfo) where Tvalue : IncomingWSS
    {
        ServerOut?.Send(JsonSerializer.Serialize(Payload, jsonTypeInfo));
    }
    
    public void SendServer(Luski.Shared.PublicServers.V1.Enums.DataType Type, IServerEvent Payload)
    {
        ServerOut?.Send(JsonSerializer.Serialize(new WSSOut()
        {
            Data = new()
            {
                Type = Type,
                Data = Payload
            }
        }));
    }
    

    public HttpResponseMessage GetFromServer(string Path, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers)
    {
        using HttpClient web = new();
        web.Timeout = TimeSpan.FromSeconds(10);
        if (!login) web.DefaultRequestHeaders.Add("token", Token);
        if (Headers is not null && Headers.Length > 0) foreach (KeyValuePair<string, string?> header in Headers) web.DefaultRequestHeaders.Add(header.Key, header.Value);
        return web.GetAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", cancellationToken: CancellationToken).Result;
    }

    public Task GetFromServer(string Path, string File, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers)
    {
		using HttpClient web = new();
		web.Timeout = TimeSpan.FromMinutes(10);
		if (!login) web.DefaultRequestHeaders.Add("token", Token);
		if (Headers is not null && Headers.Length > 0) foreach (KeyValuePair<string, string?> header in Headers) web.DefaultRequestHeaders.Add(header.Key, header.Value);
		HttpResponseMessage Response = web.GetAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", CancellationToken).Result;
        Stream stream = Response.Content.ReadAsStreamAsync(CancellationToken).Result;
        using FileStream fs = System.IO.File.Create(File);
        stream.CopyTo(fs);
        return Task.CompletedTask;
    }

    public async Task<Tresult> GetFromServer<Tresult>(string Path, JsonTypeInfo<Tresult> Type, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers) where Tresult : STC, new()
    {
        HttpResponseMessage ServerResponce = GetFromServer(Path, CancellationToken, Headers);
        Tresult temp = new();
        string raw = ServerResponce.Content.ReadAsStringAsync(CancellationToken).Result;
        try
        {
            temp = JsonSerializer.Deserialize(raw, Type)!;
        }
        catch (Exception e)
        {
            Console.WriteLine("JSON parse failed for the following data as type {0}\n{1}", temp.GetType(), raw);
        }
        if (temp is null) return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = ErrorCode.ServerError, ErrorMessage = $"Server responded with empty data" };
        return temp;
    }
    
    public Tresult GetFromServerRaw<Tresult>(string Path, JsonTypeInfo<Tresult> Type, params KeyValuePair<string, string?>[] Headers) where Tresult : STC, new()
    {
        HttpResponseMessage ServerResponce = GetFromServer(Path, CancellationToken.None, Headers);
        Tresult temp = new();
        string raw ="";
        try
        {
            temp = JsonSerializer.Deserialize(ServerResponce.Content.ReadAsStream(), Type)!;
        }
        catch (Exception e)
        {
            Console.WriteLine("JSON parse failed for the following data as type {0}\n{1}", temp.GetType(), raw);
        }
        if (temp is null) return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = ErrorCode.ServerError, ErrorMessage = $"Server responded with empty data" };
        return temp;
    }

    public async Task<Tresult> SendServer<Tvalue, Tresult>(string Path, Tvalue Payload, JsonTypeInfo<Tvalue> jsonTypeInfo, JsonTypeInfo<Tresult> ReturnjsonTypeInfo, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers) where Tvalue : CTS where Tresult : STC, new()
    {
        using HttpClient web = new();
        if (!login) web.DefaultRequestHeaders.Add("token", Token);
        if (Headers is not null && Headers.Length > 0) foreach (KeyValuePair<string, string?> header in Headers) web.DefaultRequestHeaders.Add(header.Key, header.Value);
        HttpResponseMessage ServerResponce = web.PostAsJsonAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", Payload, jsonTypeInfo, CancellationToken).Result;
        //if (!ServerResponce.IsSuccessStatusCode) return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = ErrorCode.ServerError, ErrorMessage = $"Server responded with status code {(int)ServerResponce.StatusCode}:{ServerResponce.StatusCode}" };
        Tresult error = new() { StatusCode = ServerResponce.StatusCode, Error = null, ErrorMessage = $"Server responded with empty data" };
        if (string.IsNullOrWhiteSpace(ServerResponce.Content.ReadAsStringAsync(CancellationToken).Result)) return error;
        try
        {
            Tresult? temp = JsonSerializer.Deserialize(ServerResponce.Content.ReadAsStreamAsync(CancellationToken).Result, ReturnjsonTypeInfo);
            if (temp is null) return error;
            return temp;
        }
        catch { return error; }
    }
    
    public async Task<Tresult> SendServerPatch<Tvalue, Tresult>(string Path, Tvalue Payload, JsonTypeInfo<Tvalue> jsonTypeInfo, JsonTypeInfo<Tresult> ReturnjsonTypeInfo, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers) where Tvalue : CTS where Tresult : STC, new()
    {
        using HttpClient web = new();
        if (!login) web.DefaultRequestHeaders.Add("token", Token);
        if (Headers is not null && Headers.Length > 0) foreach (KeyValuePair<string, string?> header in Headers) web.DefaultRequestHeaders.Add(header.Key, header.Value);
        HttpResponseMessage ServerResponce = await web.PatchAsJsonAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", Payload, jsonTypeInfo, CancellationToken);
       // HttpResponseMessage ServerResponce = await web.PatchAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", new StringContent(JsonSerializer.Serialize(Payload, jsonTypeInfo)),
           // CancellationToken);
        //if (!ServerResponce.IsSuccessStatusCode) return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = ErrorCode.ServerError, ErrorMessage = $"Server responded with status code {(int)ServerResponce.StatusCode}:{ServerResponce.StatusCode}" };
        Tresult error = new() { StatusCode = ServerResponce.StatusCode, Error = null, ErrorMessage = $"Server responded with empty data" };
        if (string.IsNullOrWhiteSpace(ServerResponce.Content.ReadAsStringAsync(CancellationToken).Result)) return error;
        try
        {
            Tresult? temp = JsonSerializer.Deserialize(ServerResponce.Content.ReadAsStreamAsync(CancellationToken).Result, ReturnjsonTypeInfo);
            if (temp is null) return error;
            return temp;
        }
        catch { return error; }
    }

    public async Task<Tresult> SendServer<Tresult>(string Path, string File, JsonTypeInfo<Tresult> ReturnjsonTypeInfo, CancellationToken CancellationToken, params KeyValuePair<string, string?>[] Headers) where Tresult : STC, new()
    {
		var fs = System.IO.File.OpenRead(File);
		try
        {
            using HttpClient web = new();
            if (!login) web.DefaultRequestHeaders.Add("token", Token);
            web.Timeout = new TimeSpan(0, 10, 0);
            if (Headers is not null && Headers.Length > 0) foreach (KeyValuePair<string, string?> header in Headers) web.DefaultRequestHeaders.Add(header.Key, header.Value);
            //web.DefaultRequestHeaders.Add("Content-Type", MediaTypeNames.Application.Octet);
            HttpResponseMessage ServerResponce = web.PostAsync($"{(Secure ? "https" : "http" )}://{Domain}/{ApiVersion}/{Path}", new StreamContent(fs), CancellationToken).Result;
            try
            {
                Tresult? temp = JsonSerializer.Deserialize(ServerResponce.Content.ReadAsStreamAsync(CancellationToken).Result, ReturnjsonTypeInfo);
                if (temp is null) return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = null, ErrorMessage = $"Server responded with empty data" };
                return temp;
            }
            catch { return new Tresult() { StatusCode = ServerResponce.StatusCode, Error = ErrorCode.ServerError, ErrorMessage = $"Server responded with empty data" }; }
        }
        finally
        {
            fs.Close();
        }
    }
}