using ClassLibrary1;
using GuidaTv.Common;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using Windows.ApplicationModel.Background;
using Windows.Data.Xml.Dom;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Notifications;
using Windows.UI.ViewManagement;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Media.Animation;
using Windows.UI.Xaml.Navigation;

// The Grouped Items Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234231

namespace GuidaTv
{
    /// <summary>
    /// A page that displays a grouped collection of items.
    /// </summary>
    public sealed partial class GroupedItemsPage : GuidaTv.Common.LayoutAwarePage
    {

        private int rowBlocks = 10;//numero di righe da visualizzare
        private bool allVisible = false;
        private bool showing = false;
        public int count = 1;

        private int lastvisible = 0;
        private static GroupedItemsPage instance;

        private bool centerAfterLoad = false;
   
        private string backgroundTaskName = "PockeTVguideBackgroundLiveTiles";
        private string backgroundTaskEntryPoint = "TileBackground.TileBackgroundUpdater";
        private DateTime currentDate;
       // private bool scrollingWithChannels = false;

        public GroupedItemsPage()
        {
            this.InitializeComponent();

            instance = this;
           
            Window.Current.SizeChanged += WindowSizeChanged;

            // tileUpdater.EnableNotificationQueue(true);
        }

        private void WindowSizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
        {
            ApplicationViewState myViewState = ApplicationView.Value;
            if (myViewState == ApplicationViewState.Snapped && this.channelList.ItemsSource != null)
            {
                foreach (Channel ch in (ObservableCollection<Channel>)this.channelList.ItemsSource)
                {
                    ch.highlightNowProgram();
                   
                }
            }

        }


        private void Custom_HorizontalOffsetChanded(DependencyObject source, DependencyPropertyChangedEventArgs e)
        {
            if (this.timebar != null && this.programListScrollviewer != null)
            {
                this.timebar.scrollToHorizontalOffset((double)e.NewValue);
                this.programListScrollviewer.ScrollToHorizontalOffset((double)e.NewValue);
            }
        }

        private void scrollTo(double hOffset)
        {
            this.tmp.HorizontalOffset = this.programListScrollviewer.HorizontalOffset;
            this.hScrollDoubleAnimation.To = hOffset;
            this.hScrollAnimation.Begin(); // THROWS EXCEPTION
        }

        private void centerNow()
        {
            this.timebar.highlightNow();
            scrollTo((DateTime.Now.TimeOfDay.TotalMinutes * 4)-300);
        }



        /// <summary>
        /// Populates the page with content passed during navigation.  Any saved state is also
        /// provided when recreating a page from a prior session.
        /// </summary>
        /// <param name="navigationParameter">The parameter value passed to
        /// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
        /// </param>
        /// <param name="pageState">A dictionary of state preserved by this page during an earlier
        /// session.  This will be null the first time a page is visited.</param>
        /// 
        protected override async void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)
        {
            // TODO: Create an appropriate data model for your problem domain to replace the sample data
            //  var sampleDataGroups = SampleDataSource.GetGroups((String)navigationParameter);
            // this.DefaultViewModel["Groups"] = sampleDataGroups;


            if (DataLoader.data == null || DataLoader.data == "")
            {
                progressRing.Visibility = Visibility.Visible;
                progressRing.IsActive = true;
                await DataLoader.loadJson();

            }

            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();
            if (channels != null)
            {
                channelList.ItemsSource = channels;

                List<ObservableCollection<Programs>> allprograms = new List<ObservableCollection<Programs>>();
                foreach (DateTime d in channels[0].programs2Date.Keys)
                {
                    allprograms.Add(DataLoader.getProgramsByDate(d));
                }
                programList.ItemsSource = allprograms;
                programList.UpdateLayout();



                if (channels[0].programs2Date.ContainsKey(DateTime.Now.Date))
                {

                    showProgramsByDate(DateTime.Now.Date);

                }
                else //non ha l'epg di oggi. ha letto i dati da file(o il server ritorna un epg non aggiornato)
                {    //mostro l'epg più recente
                    var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
                    warningBar.showWarning(loader.GetString("dataNotUpdatedMessage"));
                    showProgramsByDate(channels[0].programs2Date.Keys.ElementAt(channels[0].programs2Date.Keys.Count - 1));


                }

                this.itemListView.ItemsSource = channels;
                RegisterBackgroundTasks();
            }



        }

      

        private void showProgramsByDate(DateTime date) {
            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();
            

            if (channels[0].programs2Date.ContainsKey(date))
            {
              
                /*foreach (Channel ch in channels) {//rimette a invisibile tutti i programmi
                    foreach (Programs ps in ch.programs2Date.Values) {
                        ps.isVisible = false;
                    }
                   
                    
                }*/
                this.channelListScrollviewer.ScrollToVerticalOffset(0);

                allVisible = false;
                lastvisible = 0;
                count = 1;
                this.currentDate = date;

                for (int i = 0; i < programList.Items.Count; i++)
                {


                    if (this.programList.ItemContainerGenerator.ContainerFromIndex(i) != null)
                    {
                        this.programList.ItemContainerGenerator.ContainerFromIndex(i).SetValue(VisibilityProperty, Visibility.Collapsed);
                    }
                }
                if (this.programList.ItemContainerGenerator.ContainerFromIndex(channels[0].programs2Date.Keys.ToList().IndexOf(this.currentDate)) != null)
                {
                    this.programList.ItemContainerGenerator.ContainerFromIndex(channels[0].programs2Date.Keys.ToList().IndexOf(this.currentDate)).SetValue(VisibilityProperty, Visibility.Visible);
                    this.programList.SelectedIndex = channels[0].programs2Date.Keys.ToList().IndexOf(this.currentDate);
                }
               //DataLoader.getProgramsByDate(date);
                this.prevButton.IsEnabled = false;
                this.nextButton.IsEnabled = false;
               
                setDateText();
                showPrograms();
                highlightNow();
                if (date == DateTime.Now.Date)
                {
                    centerAfterLoad = true;
                }
            }
        }


        private void setDateText()
        {
           
            string text = currentDate.Date.ToString("F", System.Globalization.CultureInfo.CurrentCulture);
            text = text.Substring(0, 1).ToUpper() + text.Substring(1, text.Length - 10);
            this.date.Text = text;
        }

        /*mostra righe di programmi in blocchi di 10*/
        private void showPrograms()
        {
            if (!allVisible && !showing)
            {
                this.warningBar.disableRefresh();
                showing = true;
                progressRing.Visibility = Visibility.Visible;
                progressRing.IsActive = true;
              
                DispatcherTimer timer = new DispatcherTimer();
                timer.Interval = new TimeSpan(0, 0, 0, 0, 500);
                timer.Tick += timer_Tick;
                timer.Start();
              
            }

        }
     

        void timer_Tick(object sender, object e)
        {   
         try{
            if (this.channelList.Items != null && this.channelList.Items.Count != 0)
            {

                if (this.channelList.Items.Count > lastvisible && count <= rowBlocks)
                {

                    var currentPrograms = (programList.Items[programList.SelectedIndex] as ObservableCollection<Programs>)[lastvisible];
                   
                     progressRingText.Text = currentPrograms.parent != null ? currentPrograms.parent.name : "";
                   
                    
                    currentPrograms.isVisible = true;
                        
                        //this.pro.UpdateLayout();
                        lastvisible++;
                        count++;
                    
                }
                else
                {
                    ((DispatcherTimer)sender).Stop();
                    progressRing.Visibility = Visibility.Collapsed;
                    
                   
                    progressRing.IsActive = false;
                    showing = false;
                    this.warningBar.enableRefresh();
                    count = 1;
                    this.prevButton.IsEnabled = true;
                    this.nextButton.IsEnabled = true;
                    if (lastvisible == this.channelList.Items.Count)
                    {
                        allVisible = true;
                        
                    }


                    if (centerAfterLoad)
                    {
                        centerAfterLoad = false;
                        centerNow();
                    }
                }
                 


                 }
             }
             catch { }

        }
        /*sincronizza lo scroller dei programmi con quello dei canali e quello della timebar*/
        private void Scrollviewer_ViewChanged(object sender, ScrollViewerViewChangedEventArgs e)
        {


         
          //  this.channelListScrollviewer.ScrollToVerticalOffset(programListScrollviewer.VerticalOffset);
            this.timebar.scrollToHorizontalOffset(programListScrollviewer.HorizontalOffset);
           
           
           
          
        }



        private void programList_ProgramSelected(object sender, ClassLibrary1.Program selected)
        {

            this.selectedDetails.DataContext = selected;


        }





        /*a intervalli regolari, per ogni canale identifica il programma attualmente in onda(necessario per live tile e snappedview)*/
        private void highlightNow()
        {
            DispatcherTimer t = new DispatcherTimer();
            t.Interval = new TimeSpan(0, 1, 0);
            t.Tick += t_Tick;
            t.Start();
        }

        void t_Tick(object sender, object e)
        {

            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();

            foreach (Channel ch in channels)
            {
                ch.highlightNowProgram();
                this.timebar.highlightNow();

            }
        }

        private void warningBar_RefreshButtonPressed_1(object sender, EventArgs args)
        {
                
            
                showProgramsByDate(this.currentDate);
           
            
        }


 


        private void channelListScrollviewer_ViewChanged_1(object sender, ScrollViewerViewChangedEventArgs e)
        {  //  this.programListScrollviewer.ScrollToVerticalOffset(this.channelListScrollviewer.VerticalOffset);
            if ((lastvisible - 7) * 75 < Math.Abs(this.channelListScrollviewer.VerticalOffset))
            {

                showPrograms();

            }
            
        }


        private void prevButton_Tapped_1(object sender, TappedRoutedEventArgs e)
        {
            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();
            DateTime yesterday = this.currentDate.AddDays(-1);
            if (channels[0].programs2Date.ContainsKey(yesterday)) {
                this.currentDate = yesterday;
                showProgramsByDate(this.currentDate);
                if (!channels[0].programs2Date.ContainsKey(this.currentDate.AddDays(-1))) {
                    this.prevButton.IsEnabled = false;
                }
            }

            
        }

        private void nextButton_Tapped_1(object sender, TappedRoutedEventArgs e)
        {
            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();

            if (channels[0].programs2Date.ContainsKey(this.currentDate.AddDays(1)))
            {
                this.currentDate = this.currentDate.AddDays(1);
                showProgramsByDate(this.currentDate);
                if (!channels[0].programs2Date.ContainsKey(this.currentDate.AddDays(1)))
                {
                    this.nextButton.IsEnabled = false;
                }
            }
        }

        private void hScrollDoubleAnimation_Completed_1(object sender, object e)
        {
            this.timebar.scrollToHorizontalOffset(this.programListScrollviewer.HorizontalOffset);
            this.fakeScrollviewer.ScrollToHorizontalOffset(this.programListScrollviewer.HorizontalOffset);
        }


        private async void RegisterBackgroundTasks()
        {  

            try
            {
                var result = await BackgroundExecutionManager.RequestAccessAsync();
                if (result == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
                    result == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity)
                {
                    foreach (var task in BackgroundTaskRegistration.AllTasks)
                    {
                        if (task.Value.Name == backgroundTaskName)
                            task.Value.Unregister(true);
                    }

                    BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
                    builder.Name = backgroundTaskName;
                    builder.TaskEntryPoint = backgroundTaskEntryPoint;
                    builder.SetTrigger(new TimeTrigger(15, false));
                    IBackgroundCondition condition = new SystemCondition(SystemConditionType.InternetAvailable);
                    builder.AddCondition(condition);
                    IBackgroundTaskRegistration res = builder.Register();
                    // res.Completed += OnCompleted;
                }
            }
            catch (Exception e)
            {

            }

        }

        private void ScrollBar_ValueChanged_1(object sender, RangeBaseValueChangedEventArgs e)
        {
            this.programListScrollviewer.ScrollToHorizontalOffset(e.NewValue);
        }

        private void fakeScrollviewer_ViewChanged_1(object sender, ScrollViewerViewChangedEventArgs e)
        {
            this.programListScrollviewer.ScrollToHorizontalOffset(this.fakeScrollviewer.HorizontalOffset);
        }


        /*selection panel*/
        private void SelectChannels_Tapped_1(object sender, TappedRoutedEventArgs e)
        {
            this.ChannelSelection.ItemsSource = new ObservableCollection<Channel>(DataLoader.getSelectedChannels());
            this.selectionPanel.Visibility = Visibility.Visible;
            this.BottomAppBar.IsOpen = false;
        }

        private void closeSelectionPopupButton_Tapped_1(object sender, TappedRoutedEventArgs e)
        {
           
            this.selectionPanel.Visibility = Visibility.Collapsed;
           
        }

        private void saveSelectionPopupButton_Tapped_1(object sender, TappedRoutedEventArgs e)
        {   ObservableCollection<Channel> channels = this.ChannelSelection.ItemsSource as ObservableCollection<Channel>;
        Dictionary<String, String> dic = new Dictionary<string, string>();
             for (int i = 0; i < channels.Count; i++)
             {
                 channels[i].order = i;
                dic.Add(channels[i].name, i + "#" + channels[i].isSelected);

            }
             DataLoader.saveConfig(dic);//scrive su file
             DataLoader.resetChannels();//riordina e rimette isVisible a tutti i programs
             refresh();
             this.selectionPanel.Visibility = Visibility.Collapsed;
            
        }

        private void refresh() {
            allVisible = false;
            showing = false;
            count = 1;
            lastvisible = 0;


            ObservableCollection<Channel> channels = DataLoader.getSelectedChannels();
            channelList.ItemsSource = channels;
            List<ObservableCollection<Programs>> allprograms = new List<ObservableCollection<Programs>>();
            foreach (DateTime d in channels[0].programs2Date.Keys)
            {
                allprograms.Add(DataLoader.getProgramsByDate(d));
            }
            programList.ItemsSource = allprograms;
            programList.UpdateLayout();
            showProgramsByDate(this.currentDate);
            this.itemListView.ItemsSource = channels;

        }

       

      



    }
}