using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Windows.Storage;
using Windows.Storage.Streams;
using Windows.UI.Xaml.Controls;
using Windows.ApplicationModel.Resources.Core;

namespace ClassLibrary1
{
    public static class DataLoader
    {

        
        private static String epgFileName = "epg.json";
        private static String confFileName = "conf.txt";
        private static String Data;
        private static ObservableCollection<Channel> allChannels;
        private static ObservableCollection<Channel> selectedChannels;
        private static Dictionary<string,string> channelConf = new Dictionary<string,string>();//ordine dei canali + selezionato oppure no
        public static String data
        {
            get
            {
                return Data;
            }
        }

        //get datacron.json from internet;download successfully-> write in a file and parse it
        //                                 download failed->read the local datacrons.json
        //At FIRST start of the app, internet connection must be available.

        public static async Task loadJson()
        {
            bool noConnectionProblem = true;
            HttpResponseMessage response = new HttpResponseMessage();
            HttpClient http;



            try
            {
                http = new System.Net.Http.HttpClient();

               var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
               var urlString = loader.GetString("epgUrl");
                response = await http.GetAsync(urlString);

            }
            catch
            {
                noConnectionProblem = false;
            }


            if (noConnectionProblem && response.Content != null)
            {
                String text = await response.Content.ReadAsStringAsync();
                if (text.Contains("Rai"))//puo' capitare il caso in cui si è connessi ma cè prima l'autenticazione per la connessione
                {
                    await writeToFile(text,epgFileName);
                    Data = text;
                }
                else
                {
                    Data = await readData(epgFileName);
                    
                }
            }
            else
            {

                Data = await readData(epgFileName);
            }
            await loadConf();
          


        }

        private static async Task writeToFile(String data, String fileName)
        {
            
           try
           {
               StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;

               StorageFile sampleFile = await localFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
               await FileIO.WriteTextAsync(sampleFile, data);


           
            }
            catch (Exception e)
            {
                /* Windows.UI.Popups.MessageDialog dialog =

                         new Windows.UI.Popups.MessageDialog("Error on writing data.Please restart the App.");
                         //new Windows.UI.Popups.MessageDialog(e.Message+"\n\n"+e.StackTrace.ToString());


                 dialog.ShowAsync();*/
            }

        }

        private static async Task<String> readData(string fileName)
        {

            String ret = "";

           
            try
            {
                StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
                StorageFile file = await localFolder.GetFileAsync(fileName);
                ret = await FileIO.ReadTextAsync(file);
               
            }
            catch (Exception e)
            {

                /*Windows.UI.Popups.MessageDialog dialog =

                new Windows.UI.Popups.MessageDialog("Error on reading local data.If this is the first time the App is launched, make sure you are connected to Internet.");


                dialog.ShowAsync();*/


            }
            return ret;

        }

          public static ObservableCollection<Channel> getSelectedChannels(){

              if (allChannels == null || allChannels.Count == 0)
              {
                  allChannels = new ObservableCollection<Channel>();
                try
                {
                    if (Data != null && Data != "")
                    {
                        JsonTextReader jsReader = new JsonTextReader(new StringReader(Data));
                        JObject jobj = JObject.Load(jsReader);
                       
                        Channel channel;

                        foreach (var child in jobj.Children())
                        {
                            if (!((Newtonsoft.Json.Linq.JProperty)child).Name.Contains("France") && !((Newtonsoft.Json.Linq.JProperty)child).Name.Contains("Rai Yoyo") && !((Newtonsoft.Json.Linq.JProperty)child).Name.Contains("Rai News"))
                            {
                                channel = new Channel();

                                channel.parseJson(child);
                                //ordinamento di default
                                //poi sovrascritto in applyConf();
                                channel.order = getChannelOrderByName(channel.name);
                                allChannels.Add(channel);
                            }
                        }
                        applyConf();
                        allChannels = new ObservableCollection<Channel>(allChannels.OrderBy(ch => ch.order));
                        selectedChannels = new ObservableCollection<Channel>(allChannels.Where(ch => ch.isSelected));

                       // channels = new ObservableCollection<Channel>(planets.OrderBy<Planet, string>(pl => pl.Name));

                    }

                }
                catch (Exception e)
                {
                 

                }
            }

            return selectedChannels;
        }

          public static ObservableCollection<Channel> getAllChannels() {
              if (allChannels == null) {
                  getSelectedChannels();
              }
              return allChannels;
          }


          public static ObservableCollection<Programs> getProgramsByDate(System.DateTime date)
          {


              ObservableCollection<Programs> result = new ObservableCollection<Programs>();
              Programs fakePrograms;

              foreach (Channel ch in selectedChannels)
              {
                  if (date != DateTime.MaxValue)
                  {
                      if (ch.programs2Date.ContainsKey(date))
                      {
                          result.Add(ch.programs2Date[date]);
                      }
                      else {
                          fakePrograms = new Programs();//capita che alcuni canali non sono presenti per certe date mentre per altre si
                          fakePrograms.Add(new Program() { width = 60 * 24 * 4 });
                          fakePrograms.parent = ch;
                          result.Add(fakePrograms);

                      }
                  }
                  else {
                      result.Add(ch.programs2Date.Values.ElementAt(ch.programs2Date.Values.Count-1));
                  }

              }
               return result;
          }

          private static int getChannelOrderByName(String name) {
              
              switch (name) {
                  case "Rai 1": return 1;
                  case "Rai 2": return 2;
                  case "Rai 3": return 3;
                  case "Rai 4": return 4;
                  case "Rete 4": return 5;
                  case "Canale 5": return 6;
                  case "Italia 1": return 7;
                  case "La7": return 8;
                  case "MTV music": return 9;
                  default: return 100;

              }
          }

          public static void  saveConfig(Dictionary<String,String> conf){
              string confString = "";

              foreach (KeyValuePair<String, String> pair in conf) {
                  confString += pair.Key + "#" + pair.Value + "\n";
              }

              writeToFile(confString, confFileName);

        
          }

        public static void resetChannels(){
            allChannels = new ObservableCollection<Channel>(allChannels.OrderBy(ch => ch.order));
            foreach (Channel ch in allChannels) { 
                foreach(Programs p in ch.programs2Date.Values){
                    p.isVisible = false;
                }
            }
            selectedChannels = new ObservableCollection<Channel>(allChannels.Where(ch => ch.isSelected));

        }

        private static async Task  loadConf(){
            string str = await readData(confFileName);
            string[] splitted = str.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
            string[] splitted2;
            foreach (string s in splitted)
            {
                splitted2 = s.Split(new string[] { "#" }, StringSplitOptions.RemoveEmptyEntries);
                channelConf.Add(splitted2[0], splitted2[1] + "#" + splitted2[2]);
            }

        }

        private static  void applyConf() {
           
            
            if (allChannels != null)
            {
                string[] splitted2;
                
                foreach (Channel ch in allChannels) {
                    if (channelConf.ContainsKey(ch.name))
                    {
                        splitted2 = channelConf[ch.name].Split(new string[] { "#" }, StringSplitOptions.RemoveEmptyEntries);
                        ch.order = int.Parse(splitted2[0]);
                        ch.isSelected = bool.Parse(splitted2[1]);
                    }
                }
            }

          
        
        }

      


    }
}