using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Xml;

using System.IO;

namespace SatChanGen

{

	class MediaPortal

	{

		public static string Polarisation(Channel aChannel)

		{

			switch (aChannel.Polarisation)

			{

				case "H":

					return "1";

				case "V":

					return "2";

				case "L": //Check that on KingOfSat

					return "3";

				case "R": //Check that on KingOfSat

					return "4";

				default:

					{

						Debug.Write("WARNING: Unknown Polarisation " + aChannel.Polarisation + " for " + aChannel.Name + "\n");

						return "-1";

					}

			}

			/*

			"Not Set",

            "Not Defined",

            "Horizontal",

            "Vertical",

            "Circular Left",

            "Circular Right"

			 */

		}

		public static string Modulation(Channel aChannel)

		{

			//Those can be worked out from TvLibrary FormDVBSTuningDetail.Designer.cs

			switch (aChannel.Modulation)

			{

				case "QPSK":

					return "20";

				case "8PSK":

					return "27";

				default:

				{

					Debug.Write("WARNING: Unknown modulation " + aChannel.Modulation + " for " + aChannel.Name + "\n");

					return "-1";

				}

			}

			/*

			"Not Set",

			"Not Defined",

			"16 QAM",

			"32 QAM",

			"64 QAM",

			"80 QAM",

			"96 QAM",

			"112 QAM",

			"128 QAM",

			"160 QAM",

			"192 QAM",

			"224 QAM",

			"256 QAM",

			"320 QAM",

			"384 QAM",

			"448 QAM",

			"512 QAM",

			"640 QAM",

			"768 QAM",

			"896 QAM",

			"1024 QAM",

			"QPSK",

			"BPSK",

			"OQPSK",

			"8 VSB",

			"16 VSB",

			"Analog Amplitude",

			"Analog Frequency",

			"8 PSK",

			"RF",

			"16 APSK",

			"32 APSK",

			"QPSK2 (DVB-S2)",

			"8 PSK2 (DVB-S2)",

			"DirectTV"

			 */

		}

		public static string FEC(Channel aChannel)

		{

			//Those can be worked out from TvLibrary FormDVBSTuningDetail.Designer.cs

			switch (aChannel.FEC)

			{

				case "1/2":

					return "1";

				case "2/3":

					return "2";

				case "3/4":

					return "3";

				case "3/5":

					return "4";

				case "4/5":

					return "5";

				case "5/6":

					return "6";

				case "5/11":

					return "7";

				case "7/8":

					return "8";

				case "1/4":

					return "9";

				case "1/3":

					return "10";

				case "2/5":

					return "11";

				case "6/7":

					return "12";

				case "8/9":

					return "13";

				case "9/10":

					return "14";

				default:

				{

					Debug.Write("WARNING: Unknown FEC " + aChannel.FEC + " for " + aChannel.Name + "\n");

					return "-1";

				}

			}

		}

        //

        //

        //

		public static void Export(List<Channel> aChannels, List<string> aTunerCards,  string aFileName, bool aAddMapping)

		{

            //Create a dictionary for our groups

            Dictionary<string, List<Channel>> groups = new Dictionary<string, List<Channel>>();

			XmlDocument xmlDoc = new XmlDocument();

            XmlDeclaration xmlDeclaration = xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null);

            xmlDoc.AppendChild(xmlDeclaration);

			XmlNode rootElement = xmlDoc.CreateElement("tvserver");			

			AddAttribute(rootElement, "version", "1.0");

			xmlDoc.AppendChild(rootElement);

			//Create our channel element

			XmlNode nodechannels = xmlDoc.CreateElement("channels");			

			rootElement.AppendChild(nodechannels);

			int channelId = 0;

            int channelMapId = 0;

			foreach (Channel channel in aChannels)

			{

                //Create group if needed

                if (!groups.ContainsKey(channel.Category)) 

                {

                    //KeyValuePair<string, List<Channel>> entry=new KeyValuePair<string, List<Channel>>();

                    groups.Add(channel.Category, new List<Channel>());

                }

                //Add that channel to its group

                groups[channel.Category].Add(channel);

                //Create and populate channel element

				channelId++;

				XmlNode nodechannel = xmlDoc.CreateElement("channel");

				AddAttribute(nodechannel, "GrabEpg", "True");

				AddAttribute(nodechannel, "IdChannel", channelId);

				AddAttribute(nodechannel, "IsRadio", "False");

				AddAttribute(nodechannel, "IsTv", "True");

                AddAttribute(nodechannel, "LastGrabTime", "2000-1-1 0:0:0");

				//AddAttribute(nodechannel, "SortOrder", channel.SortOrder);

                //AddAttribute(nodechannel, "TimesWatched", "0");

                AddAttribute(nodechannel, "TotalTimeWatched", "2000-1-1 0:0:0");

                AddAttribute(nodechannel, "VisibleInGuide", !channel.Name.StartsWith("."));

				AddAttribute(nodechannel, "DisplayName", channel.Name);

				AddAttribute(nodechannel, "ChannelNumber", channelId);

                if (aAddMapping)

                {

                    //I don't think we can get mapping to work without having corresponding server and card definition elements

                    XmlNode nodeMaps = xmlDoc.CreateElement("mappings");

                    foreach (string tuner in aTunerCards)

                    {

                        channelMapId++;

                        XmlNode nodeMap = xmlDoc.CreateElement("map");

                        AddAttribute(nodeMap, "IdCard", tuner);

                        AddAttribute(nodeMap, "IdChannel", channelId);

                        AddAttribute(nodeMap, "IdChannelMap", channelMapId);

                        nodeMaps.AppendChild(nodeMap);

                    }

                    nodechannel.AppendChild(nodeMaps);

                }

				XmlNode nodeTuningDetails = xmlDoc.CreateElement("TuningDetails");

				XmlNode nodeTune = xmlDoc.CreateElement("tune");

				AddAttribute(nodeTune, "IdChannel", channelId);

				AddAttribute(nodeTune, "IdTuning", channelId);

				AddAttribute(nodeTune, "Bandwidth", "8"); //Weird

				AddAttribute(nodeTune, "ChannelNumber", "10000");

				AddAttribute(nodeTune, "ChannelType", "3"); //Bad hard coding, does it means DVB-S

				AddAttribute(nodeTune, "CountryId", "31"); //Is that Germany?

				AddAttribute(nodeTune, "Diseqc", "0"); //Disabled

				AddAttribute(nodeTune, "FreeToAir", "False"); //Can we get that from KingOfSat? Does it matter?

				AddAttribute(nodeTune, "Frequency", ((Int32)(Convert.ToDouble(channel.Frequency)*1000)).ToString());

				AddAttribute(nodeTune, "MajorChannel", "-1");

				AddAttribute(nodeTune, "MinorChannel", "-1");

				AddAttribute(nodeTune, "Modulation", Modulation(channel));

				AddAttribute(nodeTune, "Name", channel.Name);

				AddAttribute(nodeTune, "NetworkId", channel.NetworkID);

				AddAttribute(nodeTune, "PmtPid", channel.PMT);

				AddAttribute(nodeTune, "Polarisation", Polarisation(channel));

				AddAttribute(nodeTune, "Provider", channel.Provider); //Does that matter? Should really be SKY or CSAT

				AddAttribute(nodeTune, "ServiceId", channel.SID);

				AddAttribute(nodeTune, "SwitchingFrequency", "11700000"); //Does it matter?

				AddAttribute(nodeTune, "Symbolrate", channel.SymbolRate);

				AddAttribute(nodeTune, "TransportId", channel.TransponderID);

				AddAttribute(nodeTune, "TuningSource", "0"); //Is that needed?

				AddAttribute(nodeTune, "VideoSource", "0"); //Is that needed?

				AddAttribute(nodeTune, "AudioSource", "0"); //Is that needed?

				AddAttribute(nodeTune, "IsVCRSignal", "False");

				AddAttribute(nodeTune, "SatIndex", "-1");

				AddAttribute(nodeTune, "InnerFecRate", FEC(channel));

				AddAttribute(nodeTune, "Band", "0"); //Needed?

				AddAttribute(nodeTune, "Pilot", "-1");

				AddAttribute(nodeTune, "RollOff", "-1");

				AddAttribute(nodeTune, "Url", "");

				AddAttribute(nodeTune, "Bitrate", "0"); //Should we bother putting it in there?

				nodeTuningDetails.AppendChild(nodeTune);

				nodechannel.AppendChild(nodeTuningDetails);

				nodechannels.AppendChild(nodechannel);				

			}

            //Create groups element

            XmlNode nodeChannelGroups = xmlDoc.CreateElement("channelgroups");

            rootElement.AppendChild(nodeChannelGroups);

            int groupSortOrder = 0;

            foreach (KeyValuePair<string, List<Channel>> group in groups)

            {

                //Create group element

                XmlNode nodeChannelGroup = xmlDoc.CreateElement("channelgroup");

                AddAttribute(nodeChannelGroup, "GroupName", group.Key);

                AddAttribute(nodeChannelGroup, "SortOrder", groupSortOrder.ToString());

                XmlNode nodeGroupMap = xmlDoc.CreateElement("mappings");

                nodeChannelGroup.AppendChild(nodeGroupMap);

                nodeChannelGroups.AppendChild(nodeChannelGroup);

                //Sort by name

                List<Channel> sortedChannels = group.Value.OrderBy(o => o.Name).ToList();

                //Add each channel to its group

                int channelSortOrder = 0;

                foreach (Channel channel in sortedChannels)

                {

                    XmlNode nodeMap = xmlDoc.CreateElement("map");

                    AddAttribute(nodeMap, "ChannelName", channel.Name);

                    AddAttribute(nodeMap, "SortOrder", channelSortOrder.ToString());

                    nodeGroupMap.AppendChild(nodeMap);

                    channelSortOrder++;

                }

                groupSortOrder++;

            }

            using (TextWriter sw = new StreamWriter(aFileName, false, Encoding.UTF8)) //Set encoding

            {

                xmlDoc.Save(sw);

            }

			//xmlDoc.Save(aFileName);

		}

		private static void AddAttribute(XmlNode node, string tagName, string tagValue)

		{

			XmlAttribute attr = node.OwnerDocument.CreateAttribute(tagName);

			attr.InnerText = tagValue;

			node.Attributes.Append(attr);

		}

		private static void AddAttribute(XmlNode node, string tagName, int tagValue)

		{

			AddAttribute(node, tagName, tagValue.ToString());

		}

		// store DateTime Values as strings. Improves readability

		private static void AddAttribute(XmlNode node, string tagName, DateTime tagValue)

		{

			AddAttribute(node, tagName,

						 String.Format("{0}-{1}-{2} {3}:{4}:{5}", tagValue.Year, tagValue.Month, tagValue.Day, tagValue.Hour,

									   tagValue.Minute, tagValue.Second));

		}

		private static void AddAttribute(XmlNode node, string tagName, bool tagValue)

		{

			AddAttribute(node, tagName, tagValue.ToString());

		}

	}

}