prs/prs.desktop/Panels/Quotes/QuotePanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;

namespace PRSDesktop
{
    /// <summary>
    ///     Interaction logic for JobPanel.xaml
    /// </summary>
    public partial class QuotePanel : UserControl, IPanel<Quote>
    {
        
        private enum PageIndex
        {
            Details = 00,
            Documents,
            Spreadsheets,
            Diagrams,
            Takeoffs,
            Designs,
            CostSheets,
            Proposals,
            Contract,

        }
        
        private QuoteDetails QuoteDetailsPage;
        private QuoteDocuments QuoteDocumentsPage;
        private QuoteSpreadsheets QuoteSpreadsheetsPage;
        private QuoteDiagrams QuoteDiagramsPage;
        private QuoteTakeoffs QuoteTakeoffsPage;
        private QuoteDesigns QuoteDesignsPage;
        private QuoteCostSheets QuoteCostSheetsPage;
        private QuoteProposals QuoteProposalsPage;
        private QuoteContracts QuoteContractsPage;

        
        private QuoteScreenSettings settings;
        private readonly DispatcherTimer timer = new();
        
        private int CurrentPage = -1;
        private DateTime lastselection = DateTime.MaxValue;
        private IDataModelSource modelsource;

        public QuotePanel()
        {
            InitializeComponent();
            Quotes.OnDoubleClick += OpenQuote;
        }

        public bool IsReady { get; set; }

        public event DataModelUpdateEvent OnUpdateDataModel;

        public Dictionary<string, object[]> Selected()
        {
            var result = new Dictionary<string, object[]> { { typeof(Job).EntityName(), Quotes.SelectedRows } };

            return (PageIndex)QuotePages.SelectedIndex switch
            {
                PageIndex.Details => QuoteDetailsPage.Selected(),
                PageIndex.Documents => new Dictionary<string, object[]> { { typeof(QuoteDocument).EntityName(), QuoteDocumentsPage.SelectedRows } },
                PageIndex.Spreadsheets => new Dictionary<string, object[]> { { typeof(QuoteSpreadsheet).EntityName(), QuoteSpreadsheetsPage.SelectedRows } },
                PageIndex.Diagrams => QuoteDiagramsPage.Selected(),
                PageIndex.Takeoffs => new Dictionary<string, object[]> { { typeof(QuoteTakeoff).EntityName(), QuoteTakeoffsPage.SelectedRows } },
                PageIndex.Designs => QuoteDesignsPage.Selected(),
                PageIndex.CostSheets => QuoteCostSheetsPage.Selected(),
                PageIndex.Proposals => QuoteProposalsPage.Selected(),
                PageIndex.Contract => QuoteContractsPage.Selected()
            };

        }

        public void Setup()
        {
            QuoteDiagramSymbolCache.Refresh();
            settings = new UserConfiguration<QuoteScreenSettings>().Load();
            SplitPanel.View = settings.ViewType == ScreenViewType.Register
                ? DynamicSplitPanelView.Master
                : settings.ViewType == ScreenViewType.Details
                    ? DynamicSplitPanelView.Detail
                    : DynamicSplitPanelView.Combined;

            SplitPanel.AnchorWidth = settings.AnchorWidth;

            Diagrams.Visibility = ClientFactory.IsSupported<QuoteDiagram>() ? Visibility.Visible : Visibility.Collapsed;

            var sc = new Dictionary<Guid, string> { { Guid.Empty, "All Quotes" } };
            var statuses = new Client<QuoteStatus>().Query();
            foreach (var row in statuses.Rows)
                sc[row.Get<QuoteStatus, Guid>(x => x.ID)] = row.Get<QuoteStatus, string>(x => x.Description);
            QuoteStatus.ItemsSource = sc;
            if (sc.ContainsKey(settings.QuoteStatus))
                QuoteStatus.SelectedValue = settings.QuoteStatus;
            else
                QuoteStatus.SelectedValue = sc.Keys.First();

            Quotes.OnSelectItem += Quotes_OnSelectItem;
            Quotes.ColumnsTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
            Quotes.Refresh(true, false);
        }

        public void Shutdown()
        {
        }

        public void Refresh()
        {
            if (!timer.IsEnabled)
            {
                timer.Interval = new TimeSpan(0, 0, 0, 0, 100);
                timer.Tick += Timer_Tick;
                timer.IsEnabled = true;
            }

            Quotes.Refresh(false, true);
            lastselection = DateTime.MinValue;
        }

        public void CreateToolbarButtons(IPanelHost host)
        {
        }

        public string SectionName => "Quotes";

        public DataModel DataModel(Selection selected)
        {
            //Guid[] ids = Quotes.ExtractValues<Guid>(x => x.ID, selected).ToArray();
            //return new QuoteDataModel(new Filter<Quote>(x => x.ID).InList(ids));
            if (modelsource == null)
            {
                var row = Quotes.SelectedRows.FirstOrDefault();
                var quoteid = row != null ? row.Get<Quote, Guid>(x => x.ID) : CoreUtils.FullGuid;
                return new QuoteDataModel(new Filter<Quote>(x => x.ID).IsEqualTo(quoteid));
            }

            return modelsource.DataModel(selected);
        }

        public void Heartbeat(TimeSpan time)
        {
        }

        private void OpenQuote(object sender, HandledEventArgs args)
        {
            if (SplitPanel.View != DynamicSplitPanelView.Detail)
            {
                SplitPanel.View = DynamicSplitPanelView.Detail;
                settings.ViewType = SplitPanel.View == DynamicSplitPanelView.Master
                    ? ScreenViewType.Register
                    : SplitPanel.View == DynamicSplitPanelView.Combined
                        ? ScreenViewType.Combined
                        : ScreenViewType.Details;
                new UserConfiguration<QuoteScreenSettings>().Save(settings);
            }

            args.Handled = true;
        }


        private void Timer_Tick(object sender, EventArgs e)
        {
            if (lastselection < DateTime.Now.AddMilliseconds(-500))
            {
                lastselection = DateTime.MaxValue;

                var row = Quotes.SelectedRows.FirstOrDefault();
                var quoteid = row != null ? row.Get<Quote, Guid>(x => x.ID) : CoreUtils.FullGuid;

                var page = (PageIndex)QuotePages.SelectedIndex;
                switch (page)
                {
                    case PageIndex.Details : 
                        RefreshPanel(Details, ref QuoteDetailsPage, quoteid, row != null);
                        break;
                    case PageIndex.Documents : 
                        RefreshGrid(Documents, ref QuoteDocumentsPage, quoteid, row != null);
                        break;
                    case PageIndex.Spreadsheets : 
                        RefreshGrid(Spreadsheets, ref QuoteSpreadsheetsPage, quoteid, row != null);
                        break;
                    case PageIndex.Diagrams : 
                        RefreshPanel(Diagrams, ref QuoteDiagramsPage, quoteid, row != null);
                        break;
                    case PageIndex.Takeoffs : 
                        RefreshGrid(Takeoffs, ref QuoteTakeoffsPage, quoteid, row != null);
                        break;
                    case PageIndex.Designs : 
                        RefreshPanel(Designs, ref QuoteDesignsPage, quoteid, row != null);
                        break;
                    case PageIndex.CostSheets : 
                        RefreshPanel(CostSheets, ref QuoteCostSheetsPage, quoteid, row != null);
                        break;
                    case PageIndex.Proposals : 
                        RefreshPanel(Proposals, ref QuoteProposalsPage, quoteid, row != null);
                        break;
                    case PageIndex.Contract : 
                        RefreshPanel(Contract, ref QuoteContractsPage, quoteid, row != null);
                        break;
                }
            }
        }

        private void RefreshPanel<T>(TabItem container, ref T panel, Guid quoteid, bool data) where T : IBasePanel, IQuotePage, new()
        {
            if (panel == null)
            {
                panel = new T();
                panel.IsReady = false;
                panel.ParentID = CoreUtils.FullGuid;
                panel.Setup();
                panel.IsReady = true;
                container.Content = panel;
            }

            if (QuotePages.SelectedIndex != CurrentPage)
            {
                modelsource = panel;
                OnUpdateDataModel?.Invoke(panel.SectionName, panel.DataModel(Selection.None));
                CurrentPage = QuotePages.SelectedIndex;
            }

            panel.ParentID = quoteid;
            panel.Refresh();
        }

        private void RefreshGrid<T>(TabItem container, ref T grid, Guid quoteid, bool data)
            where T : IDynamicGrid, IQuotePage, IDataModelSource, new()
        {
            var bInitialised = false;
            if (grid == null)
            {
                grid = new T();
                container.Content = grid;
            }
            else
            {
                bInitialised = true;
            }

            if (QuotePages.SelectedIndex != CurrentPage)
            {
                modelsource = grid;
                OnUpdateDataModel?.Invoke(grid.SectionName, grid.DataModel(Selection.None));
                CurrentPage = QuotePages.SelectedIndex;
            }

            grid.ParentID = quoteid;
            grid.Refresh(!bInitialised, data);
        }

        private void Quotes_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            if (SplitPanel.View != DynamicSplitPanelView.Master)
                lastselection = DateTime.Now;
        }

        public Dictionary<Type, CoreTable> DataEnvironment()
        {
            var env = new Dictionary<Type, CoreTable>();
            env[typeof(Job)] = Quotes.Data;
            return env;
        }

        private void QuotePages_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.Source == QuotePages)
                lastselection = DateTime.MinValue;
        }

        private void QuoteStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (IsReady)
            {
                settings.QuoteStatus = (Guid)QuoteStatus.SelectedValue;
                new UserConfiguration<QuoteScreenSettings>().Save(settings);
                Quotes.StatusID = (Guid)QuoteStatus.SelectedValue;
            }
        }


        private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
        {
            settings.ViewType = SplitPanel.View == DynamicSplitPanelView.Master ? ScreenViewType.Register :
                SplitPanel.View == DynamicSplitPanelView.Detail ? ScreenViewType.Details : ScreenViewType.Combined;
            settings.AnchorWidth = SplitPanel.AnchorWidth;

            var newTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
            if (Quotes.ColumnsTag != newTag)
            {
                Quotes.ColumnsTag = newTag;
                Quotes.Refresh(true, true);
            }

            new UserConfiguration<QuoteScreenSettings>().Save(settings);

            if (settings.ViewType == ScreenViewType.Details)
                lastselection = DateTime.Now;
        }


    }
}