using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;

using System.IO;
using System.ServiceModel.Syndication;
using System.Xml;
using Microsoft.Phone.Tasks;
using System.Text.RegularExpressions;

namespace NotizieTL
{
    public partial class MainPage : PhoneApplicationPage
    {
        List<Articolo> listArticoli1;
        List<Articolo> listArticoli3;

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            // Set the data context of the listbox control to the sample data
            DataContext = App.ViewModel;
            this.Loaded += new RoutedEventHandler(MainPage_Loaded);
        }

        // Load data for the ViewModel Items
        private void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            if (!App.ViewModel.IsDataLoaded)
            {
                App.ViewModel.LoadData();
            }
        }


        private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
        {
            // WebClient is used instead of HttpWebRequest in this code sample because 
            // the implementation is simpler and easier to use, and we do not need to use 
            // advanced functionality that HttpWebRequest provides, such as the ability to send headers.
            WebClient webClient1 = new WebClient();
            WebClient webClient3 = new WebClient();

            // Subscribe to the DownloadStringCompleted event prior to downloading the RSS feed.
            webClient1.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClient1_DownloadStringCompleted);
            webClient3.DownloadStringCompleted += new DownloadStringCompletedEventHandler(webClient3_DownloadStringCompleted);

            // Download the RSS feed. DownloadStringAsync was used instead of OpenStreamAsync because we do not need 
            // to leave a stream open, and we will not need to worry about closing the channel. 
            webClient1.DownloadStringAsync(new System.Uri("http://tuttolavoro.indicitalia.it/RSS/app.xml"));
            webClient3.DownloadStringAsync(new System.Uri("http://www.wki.it/marketing/app/tuttolavoroApp_Rel_news.xml"));
        }

        // Click handler that runs when the 'Load Feed' or 'Refresh Feed' button is clicked. 
        //private void loadFeedButton_Click(object sender, System.Windows.RoutedEventArgs e)
        //{
            
        //}

        // Event handler which runs after the feed is fully downloaded.
        private void webClient1_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedList1(e.Result);
            }
        }

        private void webClient3_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    // Showing the exact error message is useful for debugging. In a finalized application, 
                    // output a friendly and applicable string to the user instead. 
                    MessageBox.Show(e.Error.Message);
                });
            }
            else
            {
                // Save the feed into the State property in case the application is tombstoned. 
                this.State["feed"] = e.Result;

                UpdateFeedList3(e.Result);
            }
        }

        // This method determines whether the user has navigated to the application after the application was tombstoned.
        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            // First, check whether the feed is already saved in the page state.
            if (this.State.ContainsKey("feed"))
            {
                // Get the feed again only if the application was tombstoned, which means the ListBox will be empty.
                // This is because the OnNavigatedTo method is also called when navigating between pages in your application.
                // You would want to rebind only if your application was tombstoned and page state has been lost. 
                if (feedListBoxNews1.Items.Count == 0)
                {
                    UpdateFeedList1(State["feed"] as string);
                }

                if (feedListBoxNews3.Items.Count == 0)
                {
                    UpdateFeedList3(State["feed"] as string);
                }

            }
        }

        // This method sets up the feed and binds it to our ListBox. 
        private void UpdateFeedList1(string feedXML)
        {
            listArticoli1 = new List<Articolo>();
            Articolo a;

            while (feedXML.Contains("<item>"))
            {
                int i = feedXML.IndexOf("<item>"); //rappresenta l'indice iniziale del blocco item
                int j = feedXML.IndexOf("</item>");    //rappresenta l'indice finale del blocco item
                int k = j-i; //rappresenta la lunghezza della stringa racchiusa dal blocco item
                String item = feedXML.Substring(i, k);

                int it = item.IndexOf("<title>") + 7;
                int ft = item.IndexOf("</title>");
                String title = item.Substring(it, ft - it);

                int il = item.IndexOf("<link>") + 6;
                int fl = item.IndexOf("</link>");
                String link = (item.Substring(il, fl - il)).Replace("amp;","");

                int id = item.IndexOf("<description>") + 13;
                int fd = item.IndexOf("</description>");
                String description1 = item.Substring(id, fd - id);
                String descriptionComplete = HtmlToPlainText(description1);
                descriptionComplete = descriptionComplete.Remove(descriptionComplete.LastIndexOf("\r"));
                if (descriptionComplete.StartsWith("\r\n"))
                    descriptionComplete = descriptionComplete.Remove(0, 2);
                //String description = descriptionComplete;
                String description = descriptionComplete.Substring(0, 125);
                description = description.Remove(description.LastIndexOf(" "));
                description += "...";

                int idp = item.IndexOf("<pubDate>") + 9;
                int fdp = item.IndexOf("</pubDate>");
                String dataPub = item.Substring(idp, fdp - idp);

                a = new Articolo(title, link, description, dataPub);
                listArticoli1.Add(a);

                feedXML = feedXML.Substring(feedXML.IndexOf("/pubDate") + 16);

                Boolean b = true;
            }

            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            //SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1 or later versions, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews1.ItemsSource = listArticoli1;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        private void UpdateFeedList3(string feedXML)
        {
            listArticoli3 = new List<Articolo>();
            Articolo a;

            while (feedXML.Contains("<Item>"))
            {
                int i = feedXML.IndexOf("<Item>") + 8; //rappresenta l'indice iniziale del blocco item
                int j = feedXML.IndexOf("</Item>");    //rappresenta l'indice finale del blocco item
                int k = j - i; //rappresenta la lunghezza della stringa racchiusa dal blocco item
                String item = feedXML.Substring(i, k);

                int it = item.IndexOf("<Name>") + 6;
                int ft = item.IndexOf("</Name>");
                String title = item.Substring(it, ft - it);
                
                int id = item.IndexOf("<Descp>") + 7;
                int fd = item.IndexOf("</Descp>");
                String description = item.Substring(id, fd - id);

                int ii = item.IndexOf("<Icon>") + 6;
                int fi = item.IndexOf("</Icon>");
                String icona = item.Substring(ii, fi - ii);

                int il = item.IndexOf("<Link>") + 6;
                int fl = item.IndexOf("</Link>");
                String link = item.Substring(il, fl - il);

                //int idp = item.IndexOf("<pubDate>") + 9;
                //int fdp = item.IndexOf("</pubDate>");
                //String dataPub = item.Substring(idp, fdp - idp);
                

                a = new Articolo(title, link, description, "1/1/2013", icona);
                listArticoli3.Add(a);

                feedXML = feedXML.Substring(feedXML.IndexOf("/Link") + 11);

                Boolean b = true;


                //int i = feedXML.IndexOf("<item>")+8; //rappresenta l'indice iniziale del blocco item
                //int j = feedXML.IndexOf("</item>");    //rappresenta l'indice finale del blocco item
                //int k = j - i; //rappresenta la lunghezza della stringa racchiusa dal blocco item
                //String item = feedXML.Substring(i, k);

                //int it = item.IndexOf("<title>")+7;
                //int ft = item.IndexOf("</title>");
                //String title = item.Substring(it, ft - it);

                //int il = item.IndexOf("<link>") + 6;
                //int fl = item.IndexOf("</link>");
                //String link = item.Substring(il, fl - il);

                //int id = item.IndexOf("<description>") + 13;
                //int fd = item.IndexOf("</description>");
                //String description = item.Substring(id, fd - id);

                //int idp = item.IndexOf("<pubDate>") + 9;
                //int fdp= item.IndexOf("</pubDate>");
                //String dataPub = item.Substring(idp, fdp - idp);

                //a = new Articolo(title, link, description, dataPub);
                //listArticoli.Add(a);

                //feedXML = feedXML.Substring(feedXML.IndexOf("/pubDate")+16);

                //Boolean b = true;
            }

            // Load the feed into a SyndicationFeed instance.
            StringReader stringReader = new StringReader(feedXML);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            //SyndicationFeed feed = SyndicationFeed.Load(xmlReader);

            // In Windows Phone OS 7.1 or later versions, WebClient events are raised on the same type of thread they were called upon. 
            // For example, if WebClient was run on a background thread, the event would be raised on the background thread. 
            // While WebClient can raise an event on the UI thread if called from the UI thread, a best practice is to always 
            // use the Dispatcher to update the UI. This keeps the UI thread free from heavy processing.
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                // Bind the list of SyndicationItems to our ListBox.
                feedListBoxNews3.ItemsSource = listArticoli3;

                //loadFeedButton.Content = "Refresh Feed";
            });
        }

        // The SelectionChanged handler for the feed items 
        private void feedListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ListBox listBox = sender as ListBox;

            if (listBox != null && listBox.SelectedItem != null)
            {
                // Get the SyndicationItem that was tapped.
                Articolo sItem = (Articolo)listBox.SelectedItem;

                // Set up the page navigation only if a link actually exists in the feed item.
                if (sItem.Link != null)
                {
                    // Get the associated URI of the feed item.
                    Uri uri = new Uri(sItem.Link);

                    // Create a new WebBrowserTask Launcher to navigate to the feed item. 
                    // An alternative solution would be to use a WebBrowser control, but WebBrowserTask is simpler to use. 
                    WebBrowserTask webBrowserTask = new WebBrowserTask();
                    webBrowserTask.Uri = uri;
                    webBrowserTask.Show();
                }
            }
        }

        private static string HtmlToPlainText(string html)
        {
            const string tagWhiteSpace = @"(>|$)(\W|\n|\r)+<";//matches one or more (white space or line breaks) between '>' and '<'
            const string stripFormatting = @"<[^>]*(>|$)";//match any character between '<' and '>', even when end tag is missing
            const string lineBreak = @"<(br|BR)\s{0,1}\/{0,1}>";//matches: <br>,<br/>,<br />,<BR>,<BR/>,<BR />
            var lineBreakRegex = new Regex(lineBreak, RegexOptions.Multiline);
            var stripFormattingRegex = new Regex(stripFormatting, RegexOptions.Multiline);
            var tagWhiteSpaceRegex = new Regex(tagWhiteSpace, RegexOptions.Multiline);

            var text = html;
            //Decode html specific characters
            text = System.Net.HttpUtility.HtmlDecode(text);
            //Remove tag whitespace/line breaks
            text = tagWhiteSpaceRegex.Replace(text, "><");
            //Replace <br /> with line breaks
            text = lineBreakRegex.Replace(text, Environment.NewLine);
            //Strip formatting
            text = stripFormattingRegex.Replace(text, string.Empty);

            return text;
        }

        


    }
}