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

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

namespace PRS.Mobile
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class QAFormPicker 
    {
        #region Fields
        bool _searching = false;
        Kanban addToTaskKanban = new Kanban();
        List<DigitalFormLayoutShell2> layouts = new List<DigitalFormLayoutShell2>();
        List<String> types = new List<String>();
        private bool firstLoad = true;
        private bool incompleteVisible = true;
        private bool addingToTask = false;
        Guid JobID = Guid.Empty;
        List<ExistingFormShell> incompleteForms = new List<ExistingFormShell>();
        List<ExistingFormShell> completeForms = new List<ExistingFormShell>();
        #endregion

        #region Constructors
        public QAFormPicker(string appliesTo = "Kanban", Guid _jobid = new Guid()) //normal Forms Library - default is kanban type
        {
            InitializeComponent();
            JobID = _jobid;
            NavigationPage.SetHasBackButton(this, false);
            LoadScreen(appliesTo);
        }

        public QAFormPicker(Kanban _kanban) //used for adding forms to a task
        {
            InitializeComponent();
            addingToTask = true;
            addToTaskKanban = _kanban;
            NavigationPage.SetHasBackButton(this, false);
            LoadScreen("Kanban");
        }

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

        #region OnAppearing and Loading Screen
        protected override void OnAppearing()
        {
            try
            {
                _searching = false;
                if (RetainedResults.IsFormRetained)
                {
                    DigitalFormHost host = new DigitalFormHost(LoadModel(RetainedResults.LastDigitalFormLayout, CheckType()), JobID);
                    Navigation.PushAsync(host);
                }
                LoadExistingForms();
            }
            catch { }

            base.OnAppearing();
        }

        private async void LoadScreen(string appliesTo)
        {
            try
            {
                await Task.Run(() =>
                {
                    types.Add("All");
                    var forms = new Client<DigitalFormLayout>();
                    Filter<DigitalFormLayout> filter = new Filter<DigitalFormLayout>(x => x.Type).IsEqualTo(DFLayoutType.Mobile).And(x => x.Active).IsEqualTo(true).And(x => x.Form.Secure).IsEqualTo(false)
                        .And(x => x.Form.Active).IsEqualTo(true);
                    filter = filter.And(x => x.Form.AppliesTo).IsEqualTo(appliesTo);
                    Columns<DigitalFormLayout> columns = new Columns<DigitalFormLayout>(
                        x => x.Description, //0
                        x => x.ID, //1
                        x => x.Code, //2
                        x => x.Form.AppliesTo, //3
                        x => x.Form.ID, //4
                        x => x.Layout, //5
                        x => x.Form.Group.Description //6
                        );
                    var table = forms.Query(
                        filter,
                        columns
                        ,
                        new SortOrder<DigitalFormLayout>(x => x.Description)
                        );
                    foreach (CoreRow row in table.Rows)
                    {
                        List<object> list = row.Values;
                        if (list[0] == null) list[0] = ""; //0
                        if (list[1] == null) list[1] = Guid.Empty; //1
                        if (list[2] == null) list[2] = ""; //2
                        if (list[3] == null) list[3] = ""; //3
                        if (list[4] == null) list[4] = Guid.Empty; //4
                        if (list[5] == null) list[5] = ""; //5
                        if (list[6] == null) list[6] = ""; //6

                        DigitalFormLayoutShell2 layout = new DigitalFormLayoutShell2();
                        layout.Description = list[0].ToString();
                        layout.ID = Guid.Parse(list[1].ToString());
                        layout.Code = list[2].ToString();
                        layout.AppliesTo = list[3].ToString();
                        layout.FormID = Guid.Parse(list[4].ToString());
                        layout.Layout = list[5].ToString();
                        layout.FormGroupDescription = list[6].ToString();
                        layouts.Add(layout);

                        if (!types.Contains(layout.FormGroupDescription) && !string.IsNullOrWhiteSpace(layout.FormGroupDescription))
                        {
                            types.Add(layout.FormGroupDescription);
                        }
                    }
                    GetAverages(appliesTo);

                    Device.BeginInvokeOnMainThread(() =>
                    {
                        if (appliesTo == "Kanban")
                        {
                            layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals("Factory"));
                            filterOptionsControl.Options = types;
                            filterOptionsControl.CreateRadioButtonsAndSetDefault("Factory");
                        }
                        else
                        {
                            layoutsList.ItemsSource = layouts;
                            filterOptionsControl.Options = types;
                            filterOptionsControl.CreateRadioButtonsAndSetDefault(types.First());
                        }
                    });
                    filterOptionsControl.OnFilterOptionChanged += FilterOptionsControl_OnFilterOptionChanged;
                });
                firstLoad = false;
            }
            catch (Exception e)
            {
                string error = e.Message;
            }
        }

        private void GetAverages(string appliesTo)
        {
            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);
                        }
                    }
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        ShowOrHideIncompleteFormsNotifications();
                        RefreshMyForms();
                    });
                }
                catch { }
           //});
        }

        private void ShowOrHideIncompleteFormsNotifications()
        {
            if (incompleteForms.Count > 0)
            {
                notificationFrame.IsVisible = true;
                notificationColumn.Width = 40;
                numberOfIncompleteFormsLbl.Text = incompleteForms.Count.ToString();
            }
            else
            {
                notificationFrame.IsVisible = false;
                notificationColumn.Width = 0;
            }
        }

        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;

            newButton.BackgroundColor = Color.FromHex("#15C7C1");
            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;

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

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

            filterOptionsControl.CurrentOption = filterOption;
            if (filterOption == "All")
            {
                layoutsList.ItemsSource = layouts;
            }
            else
            {
                layoutsList.ItemsSource = layouts.Where(x => x.FormGroupDescription.Equals(filterOption));
            }
        }
        #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(LoadModel(layout, form.Type, form), 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(LoadModel(layout, form.Type, form), 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 = "";
        }

        #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 DigitalFormLayoutShell2;
                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(LoadModel(digitalFormLayout, CheckType()), JobID);
                Navigation.PushAsync(host);
            }
            catch { }
        }

        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)
            {
                string message = ex.Message;
            }
        }
        
        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
    }

    public class DigitalFormLayoutShell2
    {
        public Guid ID { get; set; }
        public string Description { get; set; }
        public string Code { get; set; }
        public string AppliesTo { get; set; }
        public Guid FormID { get; set; }
        public string Layout { get; set; }
        public string FormGroupDescription { get; set; }
        public string AverageTime { get; set; }
        public double AverageTimeRow { get; set; }
        public double ImageRowSpan { get; set; }
        public DigitalFormLayoutShell2()
        {
            ID = Guid.Empty;
            Description = "";
            Code = "";
            AppliesTo = "";
            FormID = Guid.Empty;
            Layout = "";
            FormGroupDescription = "";
            AverageTime = "";
            AverageTimeRow = 0;
            ImageRowSpan = 1;
        }
    }

    public class ExistingFormShell
    {
        public Guid ID { get; set; }
        public Guid ParentID { get; set; }
        public string Description { get; set; }
        public string Started { get; set; }
        public string Completed { get; set; }
        public DateTime DateStarted { get; set; }
        public DateTime DateCompleted { get; set; }
        public Type Type { get; set; }
        public Guid FormID { get; set; }
        public ExistingFormShell()
        {
            ID = Guid.Empty;
            ParentID = Guid.Empty;
            Description = "";
            Started = "";
            Completed = "";
            DateStarted = DateTime.MinValue;
            DateCompleted = DateTime.MinValue;
            FormID = Guid.Empty;
        }
    }
}