Billing/Billing.Shared/Views/AddBillPage.xaml.cs

using System;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Billing.Models;
using Billing.Store;
using Billing.UI;
using Xamarin.Essentials;
using Xamarin.Forms;
using Resource = Billing.Languages.Resource;

namespace Billing.Views
{
    public partial class AddBillPage : BillingPage
    {
        private static readonly BindableProperty CheckBillProperty = Helper.Create<Command, AddBillPage>(nameof(CheckBill), defaultValue: new Command(() => { }, () => false));
        private static readonly BindableProperty AmountProperty = Helper.Create<string, AddBillPage>(nameof(Amount));
        private static readonly BindableProperty NameProperty = Helper.Create<string, AddBillPage>(nameof(Name), defaultValue: string.Empty);
        private static readonly BindableProperty CategoryProperty = Helper.Create<Category, AddBillPage>(nameof(Category));
        private static readonly BindableProperty WalletProperty = Helper.Create<Account, AddBillPage>(nameof(Wallet));
        private static readonly BindableProperty StoreProperty = Helper.Create<string, AddBillPage>(nameof(Store));
        private static readonly BindableProperty CreatedDateProperty = Helper.Create<DateTime, AddBillPage>(nameof(CreatedDate));
        private static readonly BindableProperty CreatedTimeProperty = Helper.Create<TimeSpan, AddBillPage>(nameof(CreatedTime));
        private static readonly BindableProperty NoteProperty = Helper.Create<string, AddBillPage>(nameof(Note));
        private static readonly BindableProperty ViewLocationProperty = Helper.Create<Command, AddBillPage>(nameof(ViewLocation), defaultValue: new Command(() => { }, () => false));

        public Command CheckBill => (Command)GetValue(CheckBillProperty);
        public string Amount
        {
            get => (string)GetValue(AmountProperty);
            set => SetValue(AmountProperty, value);
        }
        public string Name
        {
            get => (string)GetValue(NameProperty);
            set => SetValue(NameProperty, value);
        }
        public Category Category => (Category)GetValue(CategoryProperty);
        public Account Wallet => (Account)GetValue(WalletProperty);
        public string Store
        {
            get => (string)GetValue(StoreProperty);
            set => SetValue(StoreProperty, value);
        }
        public DateTime CreatedDate
        {
            get => (DateTime)GetValue(CreatedDateProperty);
            set => SetValue(CreatedDateProperty, value);
        }
        public TimeSpan CreatedTime
        {
            get => (TimeSpan)GetValue(CreatedTimeProperty);
            set => SetValue(CreatedTimeProperty, value);
        }
        public string Note
        {
            get => (string)GetValue(NoteProperty);
            set => SetValue(NoteProperty, value);
        }

        public Command SelectCategory { get; }
        public Command SelectWallet { get; }
        public Command ViewLocation => (Command)GetValue(ViewLocationProperty);

        public event EventHandler<Bill> BillChecked;

        private readonly Bill bill;
        private readonly DateTime createDate;

        private bool categoryChanged;
        private CancellationTokenSource tokenSource;
        private Location location;

        public AddBillPage() : this(DateTime.Today) { }
        public AddBillPage(DateTime date)
        {
            createDate = date;
            SelectCategory = new Command(OnSelectCategory);
            SelectWallet = new Command(OnSelectWallet);
            InitializeComponent();
            Title = Resource.AddBill;

            Initial();
        }

        public AddBillPage(Bill bill)
        {
            this.bill = bill;
            SelectCategory = new Command(OnSelectCategory);
            SelectWallet = new Command(OnSelectWallet);
#if __IOS__
            if (bill != null && bill.Latitude != null && bill.Longitude != null)
            {
                SetValue(ViewLocationProperty, new Command(OnViewLocation));
            }
#endif
            InitializeComponent();
            Title = Resource.EditBill;

            Initial();
        }

        protected override void OnDisappearing()
        {
            if (tokenSource != null && !tokenSource.IsCancellationRequested)
            {
                tokenSource.Cancel();
            }
            base.OnDisappearing();
        }

        private void Initial()
        {
            if (bill != null)
            {
                Amount = Math.Abs(bill.Amount).ToString(CultureInfo.InvariantCulture);
                Name = bill.Name;
                SetValue(WalletProperty, App.Accounts.FirstOrDefault(a => a.Id == bill.WalletId) ?? Account.Empty);
                SetValue(CategoryProperty, App.Categories.FirstOrDefault(c => c.Id == bill.CategoryId) ?? Category.Empty);
                categoryChanged = true;
                Store = bill.Store;
                CreatedDate = bill.CreateTime.Date;
                CreatedTime = bill.CreateTime.TimeOfDay;
                Note = bill.Note;
            }
            else
            {
                SetValue(WalletProperty, App.Accounts.FirstOrDefault() ?? Account.Empty);
                SetValue(CategoryProperty, App.Categories.FirstOrDefault() ?? Category.Empty);
                CreatedDate = createDate.Date;
                CreatedTime = DateTime.Now.TimeOfDay;
            }
        }

        protected override void OnLoaded()
        {
            if (bill == null)
            {
                editorAmount.SetFocus();
            }
            if (bill == null && App.SaveLocation)
            {
                _ = GetCurrentLocation();
            }
            else
            {
                SetValue(CheckBillProperty, new Command(OnCheckBill));
            }
        }

        private async Task GetCurrentLocation()
        {
            try
            {
                var request = new GeolocationRequest(GeolocationAccuracy.Best, TimeSpan.FromSeconds(10));
                tokenSource = new CancellationTokenSource();
                var status = await Helper.CheckAndRequestPermissionAsync<Permissions.LocationWhenInUse>();
                if (status != PermissionStatus.Granted)
                {
                    return;
                }
                location = await Geolocation.GetLocationAsync(request, tokenSource.Token);
#if __IOS__
                if (bill == null)
                {
                    SetValue(ViewLocationProperty, new Command(OnViewLocation));
                }
#endif
            }
            catch (FeatureNotSupportedException) { }
            catch (FeatureNotEnabledException) { }
            catch (PermissionException) { }
            catch (Exception ex)
            {
                Helper.Error("location.get", ex);
            }
            finally
            {
                SetValue(CheckBillProperty, new Command(OnCheckBill));
            }
        }

        private async void OnCheckBill()
        {
            if (Tap.IsBusy)
            {
                return;
            }
            using (Tap.Start())
            {
                if (!decimal.TryParse(Amount, out decimal amount))
                {
                    return;
                }
                if (amount == 0)
                {
                    await this.ShowMessage(Resource.AmountRequired);
                    return;
                }
                var category = Category;
                var wallet = Wallet;
                amount = Math.Abs(amount);
                if (category.Type == CategoryType.Spending)
                {
                    amount *= -1;
                }
                await Navigation.PopAsync();
                var name = Name;
                if (string.IsNullOrWhiteSpace(name))
                {
                    name = category.Name;
                }
                Bill b = bill;
                if (b == null)
                {
                    b = new Bill();
                }
                b.Amount = amount;
                b.Name = name;
                b.CategoryId = category.Id;
                b.WalletId = wallet.Id;
                b.CreateTime = CreatedDate.Date.Add(CreatedTime);
                b.Store = Store;
                b.Note = Note;
                if (location != null)
                {
                    b.Latitude = location.Latitude;
                    b.Longitude = location.Longitude;
                    b.Altitude = location.Altitude;
                    b.Accuracy = location.Accuracy;
                    b.IsGps = location.IsFromMockProvider;
                }
                BillChecked?.Invoke(this, b);

                category.LastAccountId = wallet.Id;
                category.LastUsed = DateTime.Now;

                await StoreHelper.SaveCategoryItemAsync(category);

                try
                {
                    HapticFeedback.Perform();
                }
                catch (FeatureNotSupportedException) { }
                catch (Exception ex)
                {
                    Helper.Error("haptic.feedback", ex);
                }
            }
        }

        private async void OnSelectCategory()
        {
            if (Tap.IsBusy)
            {
                return;
            }
            using (Tap.Start())
            {
                var page = new CategorySelectPage(categoryChanged ? Category.Id : -1);
                page.CategoryTapped += CategorySelectPage_Tapped;
                await Navigation.PushAsync(page);
            }
        }

        private void CategorySelectPage_Tapped(object sender, UICategory e)
        {
            SetValue(CategoryProperty, e.Category);
            categoryChanged = true;
            if (e.Category.LastAccountId != null)
            {
                var wallet = App.Accounts.FirstOrDefault(a => a.Id == e.Category.LastAccountId.Value);
                if (wallet != null)
                {
                    SetValue(WalletProperty, wallet);
                }
            }
        }

        private async void OnSelectWallet()
        {
            if (Tap.IsBusy)
            {
                return;
            }
            using (Tap.Start())
            {
                var page = new ItemSelectPage<Account>(App.Accounts);
                page.ItemTapped += Wallet_ItemTapped;
                await Navigation.PushAsync(page);
            }
        }

        private void Wallet_ItemTapped(object sender, Account account)
        {
            SetValue(WalletProperty, account);
        }

        private async void OnViewLocation()
        {
            if (bill == null && location == null)
            {
                return;
            }
            if (Tap.IsBusy)
            {
                return;
            }
            using (Tap.Start())
            {
                var page = new ViewLocationPage(bill ?? new Bill
                {
                    Name = Name,
                    Store = Store,
                    Longitude = location.Longitude,
                    Latitude = location.Latitude
                });
                page.Synced += (sender, loc) => location = loc;
                await Navigation.PushAsync(page);
            }
        }
    }
}