Neighbourhood.omg.lol/Classes/RestService.cs

using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;
using Neighbourhood.omg.lol.Models;
using System.Diagnostics;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;

namespace Neighbourhood.omg.lol
{
  public class RestService {
    HttpClient _client;
    JsonSerializerOptions _serializerOptions;
    public const string BaseUrl = "https://api.omg.lol";

    public RestService(string? token = null) {
      _client = new HttpClient();
      _client.BaseAddress = new Uri(BaseUrl);
      _client.DefaultRequestHeaders.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue(App.Name, App.Version));
      _serializerOptions = new JsonSerializerOptions {
        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
        WriteIndented = true
      };
      AddToken(token);
    }

    public T? Deserialize<T>(string str) {
      T? responseObj = default(T);
      try {
        responseObj = JsonSerializer.Deserialize<T>(str, _serializerOptions);
      }
      catch (JsonException ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
        Debug.WriteLine(str);
      }
      return responseObj;
    }

    public void AddToken(string? token = null) {
      if (token == null) token = Task.Run(() => SecureStorage.GetAsync("accounttoken")).GetAwaiter().GetResult();
      if (token != null) _client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
    }

    public void RemoveToken() {
      _client.DefaultRequestHeaders.Remove("Authorization");
    }

    private async Task<T?> Get<T>(string uri, CancellationToken cancellationToken = default) where T : IOmgLolResponseData {
      T? responseData = default(T);
      try {
        HttpResponseMessage response = await _client.GetAsync(uri, cancellationToken: cancellationToken);
        if (response.IsSuccessStatusCode) {
          string str = await response.Content.ReadAsStringAsync();
          try {
            OmgLolResponse<T>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<T>>(_serializerOptions, cancellationToken: cancellationToken);
            if (responseObj?.Request == null || (responseObj?.Request?.Success ?? false)) {
              responseData = responseObj!.Response;
            }
          }
          catch (JsonException ex) {
            Debug.WriteLine(@"\tERROR {0}", ex.Message);
            Debug.WriteLine(str);
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<TResponse?> Post<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default) where TResponse : IOmgLolResponseData {
      TResponse? responseData = default(TResponse);
      try {
        HttpResponseMessage response = await _client.PostAsJsonAsync(uri, data, _serializerOptions, cancellationToken: cancellationToken);
        string str = await response.Content.ReadAsStringAsync();
        if (response.IsSuccessStatusCode) {
          OmgLolResponse<TResponse>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<TResponse>>(_serializerOptions, cancellationToken: cancellationToken);
          if (responseObj?.Request?.Success ?? false) {
            responseData = responseObj.Response;
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<TResponse?> PostBinary<TResponse, TData>(string uri, FileResult? fileResult = null, CancellationToken cancellationToken = default) where TResponse : IOmgLolResponseData {
      TResponse? responseData = default(TResponse);
      try {
        if (fileResult != null) using (var fileStream = await fileResult.OpenReadAsync()) {
            Uri url = new Uri(_client.BaseAddress?.AbsoluteUri + uri);
            if (string.IsNullOrEmpty(url.Query)) uri += "?binary";
            else if (!url.Query.Contains("binary")) uri += "&binary";

            HttpContent fileStreamContent = new StreamContent(fileStream);
            fileStreamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(fileResult.ContentType ?? "application/octet-stream");
            fileStreamContent.Headers.ContentLength = fileStream.Length;
            HttpResponseMessage response = await _client.PostAsync(uri, fileStreamContent, cancellationToken: cancellationToken);
            string str = await response.Content.ReadAsStringAsync();
            if (response.IsSuccessStatusCode) {
              OmgLolResponse<TResponse>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<TResponse>>(_serializerOptions, cancellationToken: cancellationToken);
              if (responseObj?.Request?.Success ?? false) {
                responseData = responseObj.Response;
              }
            }
          }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<TResponse?> PostMultipart<TResponse, TData>(string uri, TData? data = null, FileResult? fileResult = null, CancellationToken cancellationToken = default)
        where TResponse : IOmgLolResponseData where TData : class 
    {
      if(fileResult != null) {
        using (var fileStream = await fileResult.OpenReadAsync())
          return await PostMultipart<TResponse, TData>(uri, data: data, fileStream: fileStream, fileName: fileResult.FileName, contentType: fileResult.ContentType);
      }
      else return await PostMultipart<TResponse, TData>(uri, data, fileStream: null);
    }

    private async Task<TResponse?> PostMultipart<TResponse, TData>(string uri, TData? data = null, Stream? fileStream = null, string? fileName = null, string? contentType = null, CancellationToken cancellationToken = default) 
        where TResponse : IOmgLolResponseData where TData : class
    {
      TResponse? responseData = default;
      try {
        using (MultipartFormDataContent formData = new MultipartFormDataContent()) {
          if(fileStream != null) {
            HttpContent fileStreamContent = new StreamContent(fileStream);
            fileStreamContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data") {
              Name = "\"file\"",
              FileName = $"\"{fileName}\"" ?? "\"unknown\""
            };
            fileStreamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType ?? "application/octet-stream");
            formData.Add(fileStreamContent);
          }
          if (data != null) {
            HttpContent jsonContent = JsonContent.Create(data, options: _serializerOptions);
            formData.Add(jsonContent);
          }

          HttpResponseMessage response = await _client.PostAsync(uri, formData, cancellationToken: cancellationToken);
          string str = await response.Content.ReadAsStringAsync();
          if (response.IsSuccessStatusCode) {
            OmgLolResponse<TResponse>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<TResponse>>(_serializerOptions, cancellationToken: cancellationToken);
            if (responseObj?.Request?.Success ?? false) {
              responseData = responseObj.Response;
            }
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<TResponse?> Put<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default) where TResponse : IOmgLolResponseData {
      TResponse? responseData = default(TResponse);
      try {
        string json = JsonSerializer.Serialize(data, _serializerOptions);
        HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, uri);
        request.Content = new StringContent(json, Encoding.UTF8, "application/json");
        HttpResponseMessage response = await _client.SendAsync(request, cancellationToken: cancellationToken);
        if (response.IsSuccessStatusCode) {
          OmgLolResponse<TResponse>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<TResponse>>(_serializerOptions, cancellationToken: cancellationToken);
          if (responseObj?.Request?.Success ?? false) {
            responseData = responseObj.Response;
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<TResponse?> Patch<TResponse, TData>(string uri, TData data, CancellationToken cancellationToken = default) where TResponse : IOmgLolResponseData {
      TResponse? responseData = default(TResponse);
      try {
        HttpResponseMessage response = await _client.PatchAsJsonAsync(uri, data, _serializerOptions, cancellationToken: cancellationToken);
        string str = await response.Content.ReadAsStringAsync();
        if (response.IsSuccessStatusCode) {
          OmgLolResponse<TResponse>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<TResponse>>(_serializerOptions, cancellationToken: cancellationToken);
          if (responseObj?.Request?.Success ?? false) {
            responseData = responseObj.Response;
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    private async Task<T?> Delete<T>(string uri, CancellationToken cancellationToken = default) where T : IOmgLolResponseData {
      T? responseData = default(T);
      try {
        HttpResponseMessage response = await _client.DeleteAsync(uri, cancellationToken: cancellationToken);
        if (response.IsSuccessStatusCode) {
          string str = await response.Content.ReadAsStringAsync();
          try {
            OmgLolResponse<T>? responseObj = await response.Content.ReadFromJsonAsync<OmgLolResponse<T>>(_serializerOptions, cancellationToken: cancellationToken);
            if (responseObj?.Request?.Success ?? false) {
              responseData = responseObj.Response;
            }
          }
          catch (JsonException ex) {
            Debug.WriteLine(@"\tERROR {0}", ex.Message);
            Debug.WriteLine(str);
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }

      return responseData;
    }

    public async Task<List<Status>> StatuslogLatest() =>
      (await Get<StatusResponseData>("/statuslog/latest"))?.Statuses ?? new List<Status>();

    public async Task<List<Status>> Statuslog(string address) =>
      (await Get<StatusResponseData>($"/address/{address}/statuses"))?.Statuses ?? new List<Status>();

    public async Task<MarkupString> StatuslogBio(string address) {
      StatusBioResponseData? responseData = await Get<StatusBioResponseData>($"/address/{address}/statuses/bio");
      return Utilities.MdToHtmlMarkup(responseData?.Bio ?? "");
    }

    public async Task<AccountResponseData?> AccountInfo() =>
      await Get<AccountResponseData>("/account/application/info");

    public async Task<AddressResponseList?> Addresses() =>
      await Get<AddressResponseList>("/account/application/addresses");

    public async Task<StatusPostResponseData?> StatusPost(string address, StatusPost statusPost) =>
      await Post<StatusPostResponseData, StatusPost>($"/address/{address}/statuses", statusPost);

    public async Task<List<Pic>> SomePics() =>
      (await Get<SomePicsResponseData>("/pics"))?.Pics ?? new List<Pic>();

    public async Task<List<Pic>> SomePics(string address) =>
      (await Get<SomePicsResponseData>($"/address/{address}/pics"))?.Pics ?? new List<Pic>();

    public async Task<PutPicResponseData?> PutPic(string address, string base64Image) =>
      (await Put<PutPicResponseData, PutPic>($"/address/{address}/pics/upload", new PutPic { Pic = base64Image }));
    public async Task<PutPicResponseData?> PutPic(string address, IBrowserFile file) {
      byte[] bytes;
      using (var memoryStream = new MemoryStream()) {
        await file.OpenReadStream().CopyToAsync(memoryStream);
        bytes = memoryStream.ToArray();
      }

      return await PutPic(address, bytes);
    }

    public async Task<PutPicResponseData?> PutPic(string address, FileResult file) {
      byte[] bytes;
      using var memoryStream = new MemoryStream();
      using var fileStream = await file.OpenReadAsync();
      await fileStream.CopyToAsync(memoryStream);
      bytes = memoryStream.ToArray();

      return await PutPic(address, bytes);
    }

    public async Task<PutPicResponseData?> PutPic(string address, byte[] bytes) =>
      await PutPic(address, Convert.ToBase64String(bytes));

    public async Task<PutPicResponseData?> PostPicDescription(string address, string id, string? description) =>
      (await Post<PutPicResponseData, PostPic>($"/address/{address}/pics/{id}", new PostPic { Description = description }));
    public async Task<BasicResponseData?> DeletePic(string address, string id) =>
      (await Delete<BasicResponseData>($"/address/{address}/pics/{id}"));

    public async Task<PatchStatusResponseData?> PatchStatus(string address, string id, string content, string? emoji) =>
      (await Patch<PatchStatusResponseData, PatchStatus>($"/address/{address}/statuses/", new PatchStatus { Id = id, Content = content, Emoji = emoji }));

    public async Task<BasicResponseData?> DeleteStatus(string address, string id) =>
      (await Delete<BasicResponseData>($"/address/{address}/statuses/{id}"));

    public async Task<List<NowData>?> NowGarden() =>
      (await Get<NowResponseData>($"/now/garden"))?.Garden ?? new List<NowData>();

    public async Task<List<string>?> Directory() =>
      (await Get<DirectoryResponseData>($"/directory"))?.Directory ?? new List<string>();

    public async Task<NowContentData?> GetNowPage(string address) =>
      (await Get<NowPageResponseData>($"/address/{address}/now"))?.Now;

    public async Task<BasicResponseData?> PostNowPage(string address, string content, bool listed) =>
      await Post<BasicResponseData, NowContentData>($"/address/{address}/now", new NowContentData { Content = content, Listed = listed ? 1 : 0 });

    public async Task<List<MarkupString>> Ephemeral() =>
      (await Get<EphemeralResponseData>($"/ephemeral"))?.Content?.Select(s => (MarkupString)s)?.ToList() ?? new List<MarkupString>();

    public async Task<BasicResponseData?> PostEphemeral(string content) =>
      await Post<BasicResponseData, EphemeralData>("/ephemeral", new EphemeralData { Content = content });

    public async Task<ProfileResponseData?> GetProfile(string address) =>
      await Get<ProfileResponseData>($"/address/{address}/web");

    public async Task<BasicResponseData?> PostProfile(string address, string content, bool publish = true) =>
      await Post<BasicResponseData, PostProfile>($"/address/{address}/web", new PostProfile { Content = content, Publish = publish });

    public async Task<BasicResponseData?> PostProfile(string address, PostProfile data) =>
      await Post<BasicResponseData, PostProfile>($"/address/{address}/web", data);
    public async Task<Dictionary<string, Theme>?> GetThemes() =>
      (await Get<ThemeResponseData>($"/theme/list"))?.Themes;

    public async Task<MarkupString?> GetThemePreview(string theme) =>
      (MarkupString)((await Get<ThemePreviewResponseData>($"/theme/{theme}/preview"))?.Html ?? string.Empty);

    public async Task<BasicResponseData?> PostProfilePic(string address, FileResult image) =>
        await PostBinary<BasicResponseData, object>($"/address/{address}/pfp", fileResult: image);

    public async Task<string?> OAuth(string code, string client_id, string client_secret, string redirect_uri) {
      string? token = null;
      string uri = $"/oauth/?code={code}&client_id={client_id}&client_secret={client_secret}&redirect_uri={redirect_uri}&scope=everything";
      try {
        HttpResponseMessage response = await _client.GetAsync(uri);
        if (response.IsSuccessStatusCode) {
          TokenResponseData? responseObj = await response.Content.ReadFromJsonAsync<TokenResponseData>(_serializerOptions);
          if (responseObj != null && !string.IsNullOrEmpty(responseObj.AccessToken)) {
            token = responseObj.AccessToken;
          }
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }
      return token;
    }

    public async Task<MarkupString?> GetHtml(string url) {
      string? raw = null;
      try {
        HttpResponseMessage response = await _client.GetAsync(url);
        if (response.IsSuccessStatusCode) {
          raw = await response.Content.ReadAsStringAsync();
        }
      }
      catch (Exception ex) {
        Debug.WriteLine(@"\tERROR {0}", ex.Message);
      }
      return string.IsNullOrEmpty(raw) ? null : (MarkupString)raw;
    }
  }
}