prs/prs.mobile.new/PRS.Mobile/Components/DigitalForms/Archive/DigitalFormPickerScreen/DigitalFormsPicker.xaml.cs

using Comal.Classes;
using System;
using System.Collections.Generic;
using System.Linq;
using InABox.Clients;
using InABox.Core;
using InABox.Mobile;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using XF.Material.Forms.UI.Dialogs;

namespace PRS.Mobile
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class DigitalFormsPicker : MobilePage
    {

        public Guid JobID { get; set; } = Guid.Empty;

        #region Fields
        bool _searching = false;
        Kanban addToTaskKanban = new Kanban();
        List<String> types = new List<String>();
        private bool firstLoad = true;
        private bool incompleteVisible = true;
        private bool addingToTask = false;
        List<ExistingFormShell> incompleteForms = new List<ExistingFormShell>();
        List<ExistingFormShell> completeForms = new List<ExistingFormShell>();
        #endregion
        
        
        private String _appliesTo;
        private Guid _parent;

        public DigitalFormsPicker(String appliesto, Guid parent)
        {
            _appliesTo = appliesto;
            _parent = _parent;
            InitializeComponent();
            // This is for New Forms
            App.Data.DigitalForms.Refresh(false,
                () => Device.BeginInvokeOnMainThread(LoadScreen)
            );
            
            // This is for Existing Forms

        }

        private void ExitBtn_Clicked(object sender, EventArgs e)
        {
            Navigation.PopAsync();
        }

        #region OnAppearing and Loading Screen

        protected override void OnDisappearing()
        {
            base.OnDisappearing();
        }

        protected override void OnAppearing()
        {
            _searching = false;
            if (RetainedResults.IsFormRetained)
            {
                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(RetainedResults.LastDigitalFormLayout, CheckType(), addToTaskKanban, JobID, null, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
            LoadExistingForms();
            
            base.OnAppearing();
        }

        public void LoadScreen()
        {
            var layouts = Enumerable.ToArray(App.Data.DigitalForms.Layouts
                    .Where(l => String.Equals(l.Form.AppliesTo, _appliesTo)));
            
            // GetAverages();
            
            layoutsList.ItemsSource = layouts;
            
            types = layouts
                .Select(x => x.Form.Group)
                .Where(x => String.IsNullOrWhiteSpace(x))
                .Distinct()
                .OrderBy(x=>x)
                .Prepend("All")
                .ToList();
            
            filterOptionsControl.Options = types;
            filterOptionsControl.CreateRadioButtonsAndSetDefault(types.First());
            
            firstLoad = false;
        }
        
        // private void GetAverages()
        // {
        //     try
        //     {
        //         Task.Run(() =>
        //         {
        //             foreach (var layout in layouts)
        //             {
        //                 TimeSpan span = new TimeSpan();
        //                 CoreTable table = new Client<KanbanForm>().Query
        //                     (
        //                     new Filter<KanbanForm>(x => x.Form.ID).IsEqualTo(layout.FormID).And(x => x.FormOpen).IsNotEqualTo(null),
        //                     new Columns<KanbanForm>(x => x.FormOpen)
        //                     );
        //                 if (table.Rows.Any())
        //                 {
        //                     foreach (CoreRow row in table.Rows)
        //                     {
        //                         List<object> list = row.Values;
        //                         TimeSpan timespan = TimeSpan.Parse(list[0].ToString());
        //                         span = span + timespan;
        //                     }
        //                     TimeSpan average = span / table.Rows.Count();
        //                     layout.AverageTime = "Average time to complete: " + average.Minutes.ToString() + "m " + average.Seconds.ToString() + "s";
        //                     layout.AverageTimeRow = 30;
        //                     layout.ImageRowSpan = 2;
        //                 }
        //             }
        //             Device.BeginInvokeOnMainThread(() =>
        //             {
        //                 layoutsList.ItemsSource = null;
        //                 if (filterOptionsControl.CurrentOption == "All")
        //                 {
        //                     layoutsList.ItemsSource = layouts;
        //                 }
        //                 else
        //                 {
        //                     layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals(filterOptionsControl.CurrentOption));
        //                 }
        //             });
        //         });
        //     }
        //     catch { }
        // }

        private void LoadExistingForms()
        {
            //Task.Run(() =>
            //{
            try
            {
                List<IFormPickerQueryLoader> loaderList = new List<IFormPickerQueryLoader>()
                {
                new FormPickerQueryLoader<Kanban, KanbanLink, KanbanForm>(),
                new FormPickerQueryLoader<Job, JobLink, JobForm>()
                 };
                incompleteForms.Clear();
                completeForms.Clear();
                foreach (var loader in loaderList)
                {
                    List<ExistingFormShell> incomplete = loader.QueryIncomplete();
                    foreach (var v in incomplete)
                    {
                        incompleteForms.Add(v);
                    }
                    List<ExistingFormShell> complete = loader.QueryComplete();
                    foreach (var v in complete)
                    {
                        completeForms.Add(v);
                    }
                }
                SortForms(completeForms, FormCompletion.Complete);
                SortForms(incompleteForms, FormCompletion.Incomplete);
                Device.BeginInvokeOnMainThread(() =>
                {
                    myFormsButton.Alert = incompleteForms.Count > 0 ? incompleteForms.Count.ToString() : "";
                    RefreshMyForms();
                });
            }
            catch (Exception ex)
            {
                InABox.Mobile.MobileLogging.Log(ex);

            }
            //});
        }

        enum FormCompletion
        {
            Incomplete,
            Complete
        }

        private void SortForms(List<ExistingFormShell> shells, FormCompletion completion)
        {
            if (completion == FormCompletion.Complete && shells.Count > 0)
                shells.Sort((x, y) => y.DateCompleted.CompareTo(x.DateCompleted)); //descending
            else if (completion == FormCompletion.Incomplete && shells.Count > 0)
                shells.Sort((x, y) => x.DateStarted.CompareTo(y.DateStarted)); //ascending
        }

        private void ShowOrHideIncompleteFormsNotifications()
        {
            
        }

        private void RefreshMyForms()
        {
            incompleteFormsList.ItemsSource = null;
            completeFormsList.ItemsSource = null;
            incompleteFormsList.ItemsSource = incompleteForms;
            completeFormsList.ItemsSource = completeForms;
            incompleteBtn.Text = "Incomplete (" + incompleteForms.Count + ")";
            completeBtn.Text = "Complete (" + completeForms.Count + ")";
        }

        #endregion

        #region User Interaction

        #region New Forms Section
        private void NewButton_Clicked(object sender, EventArgs e)
        {
            templatesColumn.Width = GridLength.Star;
            formsColumn.Width = 0;

            existingFormsGrid.IsVisible = false;
            templatesGrid.IsVisible = true;

            ((VisualElement)newButton).BackgroundColor = Color.FromHex("#15C7C1");
            ((VisualElement)myFormsButton).BackgroundColor = Color.Default;
        }

        private void MyFormsButton_Clicked(object sender, EventArgs e)
        {
            templatesColumn.Width = 0;
            formsColumn.Width = GridLength.Star;

            existingFormsGrid.IsVisible = true;
            templatesGrid.IsVisible = false;

            ((VisualElement)newButton).BackgroundColor = Color.Default;
            ((VisualElement)myFormsButton).BackgroundColor = Color.FromHex("#15C7C1");
        }

        private void FilterOptionsControl_OnFilterOptionChanged(string filterOption)
        {
            try
            {
                if (filterOption == filterOptionsControl.CurrentOption)
                    return;

                filterOptionsControl.CurrentOption = filterOption;
                // if (filterOption == "All")
                // {
                //     layoutsList.ItemsSource = layouts;
                // }
                // else
                // {
                //     layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals(filterOption));
                // }
            }
            catch { }
        }
        #endregion

        #region My Forms Section
        private async void IncompleteFormsList_Tapped(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                var form = incompleteFormsList.SelectedItem as ExistingFormShell;
                DigitalFormLayout layout = new Client<DigitalFormLayout>().Query(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(form.FormID)
                    ).Rows.FirstOrDefault().ToObject<DigitalFormLayout>();

                if (form.Type == typeof(JobForm))
                    JobID = form.ParentID;
                else
                    JobID = Guid.Empty;

                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(layout, form.Type, addToTaskKanban, JobID, form, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
        }

        private async void CompleteFormsList_Tapped(object sender, EventArgs e)
        {
            using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
            {
                var form = completeFormsList.SelectedItem as ExistingFormShell;
                DigitalFormLayout layout = new Client<DigitalFormLayout>().Query(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(form.FormID)
                    ).Rows.FirstOrDefault().ToObject<DigitalFormLayout>();

                if (form.Type == typeof(JobForm))
                    JobID = form.ParentID;
                else
                    JobID = Guid.Empty;

                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(layout, form.Type, addToTaskKanban, JobID, form, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
        }

        private void Incomplete_Tapped(object sender, EventArgs e)
        {
            incompleteFormsColumn.Width = GridLength.Star;
            completeFormsColumn.Width = 0;

            incompleteFormsList.IsVisible = true;
            completeFormsList.IsVisible = false;

            incompleteBtn.BackgroundColor = Color.FromHex("#15C7C1");
            completeBtn.BackgroundColor = Color.Default;

            incompleteVisible = true;
            searchEnt.Text = "";
        }

        private void Complete_Tapped(object sender, EventArgs e)
        {
            completeFormsColumn.Width = GridLength.Star;
            incompleteFormsColumn.Width = 0;

            completeFormsList.IsVisible = true;
            incompleteFormsList.IsVisible = false;

            incompleteBtn.BackgroundColor = Color.Default;
            completeBtn.BackgroundColor = Color.FromHex("#15C7C1");

            incompleteVisible = false;
            searchEnt.Text = "";
        }

        private async void Delete_Tapped(object sender, EventArgs e)
        {
            var item = ((TappedEventArgs)e).Parameter as ExistingFormShell;
            if (item == null) return;

            string chosenOption = await DisplayActionSheet("Delete Form?", "Cancel", null, "Yes", "No");
            switch (chosenOption)
            {
                case "Yes":
                    break;
                default:
                    return;
            }

            DeleteForm(item);
            LoadExistingForms();
        }

        private void DeleteForm(ExistingFormShell item)
        {
            if (item.Type == typeof(KanbanForm))
                DeleteKanbanForm(item.ID);
            if (item.Type == typeof(JobForm))
                DeleteJobForm(item.ID);
        }

        private void DeleteJobForm(Guid id)
        {
            JobForm form = new JobForm { ID = id };
            new Client<JobForm>().Delete(form, "Deleted from Mobile App - My Forms section");
        }

        private void DeleteKanbanForm(Guid id)
        {
            KanbanForm form = new KanbanForm { ID = id };
            new Client<KanbanForm>().Delete(form, "Deleted from Mobile App - My Forms section");
        }

        #region Loading From History Section
        private void LayoutsList_Tapped(object sender, EventArgs e)
        {
            if (_searching)
                return;
            else
                LoadHost();
        }

        private async void LoadHost()
        {
            try
            {
                var digitalFormLayoutShell = layoutsList.SelectedItem as DigitalFormLayoutShell;
                DigitalFormLayout digitalFormLayout = new DigitalFormLayout();
                using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Loading"))
                {
                    _searching = true;

                    digitalFormLayout.ID = digitalFormLayoutShell.ID;
                    // digitalFormLayout.Description = digitalFormLayoutShell.Description;
                    // digitalFormLayout.Code = digitalFormLayoutShell.Code;
                    // digitalFormLayout.Form.AppliesTo = digitalFormLayoutShell.AppliesTo;
                    // digitalFormLayout.Form.ID = digitalFormLayoutShell.FormID;
                    // digitalFormLayout.Layout = digitalFormLayoutShell.Layout;
                    // digitalFormLayout.Form.Group.Description = digitalFormLayoutShell.FormGroupDescription;

                    RetainedResults.LastDigitalFormLayout = digitalFormLayout;
                }
                DigitalFormHost host = new DigitalFormHost(DigitalFormsHelper.LoadModel(digitalFormLayout, CheckType(), addToTaskKanban, JobID, null, addingToTask), JobID);
                Navigation.PushAsync(host);
            }
            catch (Exception ex)
            {
                InABox.Mobile.MobileLogging.Log(ex);
            }
        }

        private Type CheckType()
        {
            if (JobID != Guid.Empty)
                return typeof(JobForm);
            else
                return typeof(KanbanForm);
        }

        private IDigitalFormHostModel LoadModel(DigitalFormLayout layout, Type type, ExistingFormShell form = null)
        {
            if (type == typeof(JobForm))
            {
                var model = new DigitalFormHostModel<Job, JobLink, JobForm>();
                var job = new Job();

                var jobForm = new JobForm();
                jobForm.Form.ID = layout.Form.ID;

                if (form == null)
                {
                    job.ID = JobID;
                }
                else
                {
                    jobForm.ID = form.ID;
                    job.ID = form.ParentID;
                }

                model.LoadItems(job, jobForm, layout);
                return model;
            }
            else
            {
                var model = new DigitalFormHostModel<Kanban, KanbanLink, KanbanForm>();
                var kanban = new Kanban();

                var kanbanForm = new KanbanForm();

                kanbanForm.Form.ID = layout.Form.ID;
                if (form != null)
                {
                    kanbanForm.ID = form.ID;
                    kanban.ID = form.ParentID;
                }

                if (addingToTask)
                {
                    kanbanForm.Parent.ID = addToTaskKanban.ID;
                    kanban.ID = addToTaskKanban.ID;
                }

                model.LoadItems(kanban, kanbanForm, layout);
                return model;
            }
        }

        #endregion

        #region Searching
        private void SearchEnt_Changed(object sender, EventArgs e)
        {
            if (CheckEmptySearch())
                return;
            else
            {
                RunSearch();
            }
        }

        private bool CheckEmptySearch()
        {
            if (string.IsNullOrWhiteSpace(searchEnt.Text))
            {
                incompleteFormsList.ItemsSource = incompleteForms;
                completeFormsList.ItemsSource = completeForms;
                return true;
            }
            else
                return false;
        }

        private void RunSearch()
        {
            try
            {
                if (incompleteVisible)
                    RunSearchOnIncomplete();
                else
                    RunSearchOnHistory();
            }
            catch (Exception ex)
            {
                InABox.Mobile.MobileLogging.Log(ex);
            }
        }
        
        private void RunSearchOnIncomplete()
        {
            incompleteFormsList.ItemsSource = incompleteForms.Where(x =>x.Description.ToUpper().Contains(searchEnt.Text.ToUpper()));
        }
        
        private void RunSearchOnHistory()
        {
            completeFormsList.ItemsSource = completeForms.Where(x => x.Description.ToUpper().Contains(searchEnt.Text.ToUpper()));
        }
        
        #endregion
        #endregion

        #endregion

    }
}