Neighbourhood.omg.lol/Models/State.cs

using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using System.ComponentModel;
using System.Text.Json;

namespace Neighbourhood.omg.lol.Models {
  public class State : INotifyPropertyChanged {
    // Main data lists
    public List<Status>? Statuses { get; set; }
    public List<Pic>? Pics { get; set; }
    public List<NowData>? NowGarden { get; set; }
    public List<MarkupString>? EphemeralMessages { get; set; }

    // Account data
    public AccountResponseData? AccountInfo { get; set; }
    public AddressResponseList? AddressList { get; set; }
  
    public string? Name { get => AccountInfo?.Name; }
    public string? Email { get => AccountInfo?.Email; }
    public IEnumerable<string>? AddressNames { get => AddressList?.Select(a => a.Address); }

    // Selected Address
    public AddressResponseData? SelectedAddress { get; set; }
    public string? SelectedAddressName { get => SelectedAddress?.Address; }

    // data for selected address
    public List<Status>? CachedAddressStatuses { get; set; }
    public List<Pic>? CachedAddressPics { get; set; }
    public MarkupString? CachedAddressBio { get; set; }
    private string? _cachedAddress;
    public string? CachedAddress {
      get => _cachedAddress;
      set {
        if (_cachedAddress != value) {
          _cachedAddress = value;
          CachedAddressStatuses = new List<Status>();
          CachedAddressPics = new List<Pic>();
          CachedAddressBio = null;
        }
      }
    }

    // share intent stuff
    public event EventHandler<EventArgs>? IntentReceived;
    private string? _shareString;
    public string? ShareString { 
      get => _shareString;
      set {
        _shareString = value;
        IntentReceived?.Invoke(this, EventArgs.Empty);
      }
    }
    private string? _sharePhoto;
    public string? SharePhoto {
      get => _sharePhoto;
      set {
        _sharePhoto = value;
        IntentReceived?.Invoke(this, EventArgs.Empty);
      }
    }

    // refreshing
    public event PropertyChangedEventHandler? PropertyChanged;
    private bool _isRefreshing;
    public bool IsRefreshing {
      get => _isRefreshing;
      set {
        _isRefreshing = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsRefreshing)));
      }
    }

    private bool _canRefresh;
    public bool CanRefresh {
      get => _canRefresh;
      set {
        _canRefresh = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CanRefresh)));
      }
    }

    private bool _atTop;
    public bool AtTop {
      get => _atTop;
      set {
        if (_atTop != value) {
          _atTop = value;
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(AtTop)));
        }
      }
    }

    private bool _atBottom;
    public bool AtBottom {
      get => _atBottom;
      set {
        if (_atBottom != value) {
          _atBottom = value;
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(AtBottom)));
        }
      }
    }

    // api service
    private RestService api { get; set; }

    public State(RestService restService) {
      api = restService;
    }

    public async Task PopulateAccountDetails(string token) {
      api.AddToken(token);

      string accountJson = Preferences.Default.Get("accountdetails", string.Empty);
      string addressJson = Preferences.Default.Get("accountaddresses", string.Empty);
      string selectedAddressJson = Preferences.Default.Get("selectedaddress", string.Empty);

      if (!string.IsNullOrEmpty(accountJson)) AccountInfo = JsonSerializer.Deserialize<AccountResponseData>(accountJson);
      if (!string.IsNullOrEmpty(addressJson)) AddressList = JsonSerializer.Deserialize<AddressResponseList>(addressJson);
      if (!string.IsNullOrEmpty(selectedAddressJson)) SelectedAddress = JsonSerializer.Deserialize<AddressResponseData>(selectedAddressJson);

      // if we haven't got account info, attempt to retrieve it.
      if (AccountInfo == null) {
        AccountInfo = await api.AccountInfo();
        if (AccountInfo != null) {
          Preferences.Default.Set("accountdetails", JsonSerializer.Serialize(AccountInfo));
        }
      }

      // if we don't have the list of addresses, attempt to retrieve that.
      if (AddressList == null) {
        AddressList = await api.Addresses();
        if (AddressList != null) {
          Preferences.Default.Set("accountaddresses", JsonSerializer.Serialize(AddressList));
          SelectedAddress = AddressList.FirstOrDefault();
          Preferences.Default.Set("selectedaddress", JsonSerializer.Serialize(SelectedAddress));
        }
      }
    }

    public async Task RemoveAccountDetails() {
      Preferences.Default.Clear();
      AccountInfo = null;
      AddressList = null;
      SelectedAddress = null;
      api.RemoveToken();
    }

    public async Task<MarkupString?> GetBio(string address, bool forceRefresh = false) {
      CachedAddress = address;
      if (forceRefresh || CachedAddressBio == null) {
        CachedAddressBio = await api.StatuslogBio(address);
      }
      return CachedAddressBio;
    }

    public async Task<List<MarkupString>?> GetEphemeralMessages(bool forceRefresh = false) {
      if(forceRefresh || this.EphemeralMessages == null || this.EphemeralMessages.Count == 0) {
        this.EphemeralMessages = await api.Ephemeral();
      }
      return this.EphemeralMessages;
    }

    public async Task<List<Status>?> GetStatuses(bool forceRefresh = false) {
      if (forceRefresh || this.Statuses == null || this.Statuses.Count == 0) {
        this.Statuses = await api.StatuslogLatest();
      }
      return this.Statuses;
    }

    public async Task<List<Status>?> GetStatuses(string address, bool forceRefresh = false) {
      this.CachedAddress = address;
      if (forceRefresh || this.CachedAddressStatuses == null || this.CachedAddressStatuses.Count == 0) {
        this.CachedAddressStatuses = await api.Statuslog(address);
      }
      return this.CachedAddressStatuses;
    }

    public async Task<List<NowData>?> GetNowGarden(bool forceRefresh = false) {
      if (forceRefresh || this.NowGarden == null || this.NowGarden.Count == 0) {
        this.NowGarden = await api.NowGarden();
      }
      return this.NowGarden;
    }

    public async Task<List<Pic>?> GetPics(bool forceRefresh = false) {
      if(forceRefresh || this.Pics == null || this.Pics.Count == 0) {
        this.Pics = await api.SomePics();
      }
      return this.Pics;
    }

    public async Task<List<Pic>?> GetPics(string address, bool forceRefresh = false) {
      CachedAddress = address;
      if (forceRefresh || this.CachedAddressPics == null || this.CachedAddressPics.Count == 0) {
        CachedAddressPics = (await api.SomePics(address)) ?? new List<Pic>();
      }
      return CachedAddressPics;
    }

    public async Task RefreshStatuses() => await GetStatuses(forceRefresh: true);
    public async Task RefreshPics() => await GetPics(forceRefresh: true);
    public async Task RefreshNow() => await GetNowGarden(forceRefresh: true);



    [JSInvokable("SetAtTop")]
    public void SetAtTop(bool atTop) {
      if(AtTop != atTop) AtTop = atTop;
      //if(CanRefresh != atTop) CanRefresh = atTop;
    }

    [JSInvokable("SetAtBottom")]
    public void SetAtBottom(bool atBottom) {
      if(AtBottom != atBottom) AtBottom = atBottom;
    }

  }
}