using ImGuiNET;
using SDL2Demo;
using SDL2Demo.Forms;
using SDL2Demo.Jobs;
using SDL2Demo.Net;
using SDL2Demo.SdlWrapper;
using skyscraper5.Docsis;
using skyscraper5.Dvb.DataBroadcasting.SkyscraperVfs;
using skyscraper5.Dvb.Descriptors;
using skyscraper5.Dvb.Psi.Model;
using skyscraper5.Mhp.Descriptors;
using skyscraper5.Mhp.Si;
using skyscraper5.Mhp.Si.Model;
using skyscraper5.Mpeg2.Descriptors;
using skyscraper5.Mpeg2.Psi.Model;
using skyscraper5.Scte35;
using skyscraper5.Skyscraper.Equipment;
using skyscraper5.Skyscraper.IO.CrazycatStreamReader;
using skyscraper5.Skyscraper.Net;
using skyscraper5.Skyscraper.Scraper;
using skyscraper5.src.Skyscraper.FrequencyListGenerator;
using skyscraper5.Teletext.Wss;
using skyscraper8.Skyscraper.Drawing;
using skyscraper8.Skyscraper.FrequencyListGenerator;
using skyscraper8.UI.ImGui.Forms;
using SkyscraperUI;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using testdrid.SdlWrapper;
using static SDL2Demo.Jobs.Blindscan;

namespace SDL2Demo.Jobs
{
	internal class InheritedBlindscanUiJunction : ISkyscraperUiJunction, IRenderable
	{

		#region During TS scraping

		DateTime prev, next;
		private bool secondTick;
		public void Render()
		{
			prev = next;
			next = DateTime.Now;
			secondTick = prev.Second != next.Second;

			RenderPat();
			RenderSdt();
			RenderNit();
			RenderCat();
			RenderPmt();
			RenderTdt();
			RenderEit();
			RenderAit();
			RenderTot();
			RenderBat();
			RenderObjectCarousels();
			RenderMpe();
			RenderDataCarousels();
		}

		private void ResetWindows()
		{
			HasSdt = false;
			sdtDisplay = null;
			sdtTableUuid = null;
			HasPat = false;
			TsType = 0;
			patDisplay = null;
			patTableUuid = null;
			HasPmt = false;
			pmtTabBarUuid = null;
			nitDisplay = null;
			nitTableUuid = null;
			HasNit = false;
			streamTypes = null;
			caTableUuid = null;
			caDisplay = null;
			HasCat = false;
			tdtDisplay = null;
			HasTdt = false;
			eitDisplay = null;
			aitDisplay = null;
			aitTableUuid = null;
			HasAit = false;
			totTime = null;
			totDescriptor = null;
			totDisplayUuid = null;
			HasTot = false;
			batDisplay = null;
			HasBat = false;
			displayObjectCarouselRoots = null;
			HasDsmCc = false;
			trafficInfoComparer = null;
			mpeTableUuid = null;
			mpeDisplays = null;
			trafficInfoComparer = null;
			mpeTableUuid = null;
			mpeDisplays = null;
			HasMpe = false;
			dsmCcDisplay = null;
			objectCarouselTableUuid = null;
			if (framegrabWindows != null)
			{
				while (framegrabWindows.Count > 0)
				{
					PictureWindow pictureWindow = framegrabWindows.Dequeue();
					pictureWindow.Dispose();
				}
			}
		}

		private void SafeText(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				ImGui.Text("<null>");
				return;
			}

			if (string.IsNullOrWhiteSpace(s))
			{
				ImGui.Text("[null]");
				return;
			}

			if (s.Contains("% "))
				s = s.Replace("% ", "%% ");

			ImGui.Text(s);
		}

		#region EIT
		private struct EitEventCoordinate
		{
			public DateTime StartTime;
			public ushort NetworkId;
			public ushort ServiceId;
		}

		private struct EitDay
		{
			public DateTime Date;
			public bool Visible;
			public Guid tableGuid;
		}

		private class EitDayComparer : IComparer<EitDay>
		{
			public int Compare(EitDay x, EitDay y)
			{
				return x.Date.CompareTo(y.Date);
			}
		}

		private class EitEventCoordinateComparer : IComparer<EitEventCoordinate>
		{
			public int Compare(EitEventCoordinate x, EitEventCoordinate y)
			{
				return x.StartTime.Ticks.CompareTo(y.StartTime.Ticks);
			}
		}

		private bool HasEit;
		private SortedList<EitDay, SortedList<EitEventCoordinate, string>> eitDisplay;
		private void RenderEit()
		{
			if (eitDisplay == null)
				return;

			if (ImGui.Begin("Event Information Table"))
			{
				lock (eitDisplay)
				{
					foreach (KeyValuePair<EitDay, SortedList<EitEventCoordinate, string>> keyValuePair in eitDisplay)
					{
						EitDay day = keyValuePair.Key;
						if (ImGui.CollapsingHeader(keyValuePair.Key.Date.ToLongDateString(), ref day.Visible))
						{
							if (day.tableGuid == Guid.Empty)
								day.tableGuid = Guid.NewGuid();
							ImGui.BeginTable(day.ToString(), 3,
								ImGuiTableFlags.SizingFixedFit | ImGuiTableFlags.NoSavedSettings);
							foreach (KeyValuePair<EitEventCoordinate, string> valuePair in keyValuePair.Value)
							{
								ImGui.TableNextRow();
								ImGui.TableSetColumnIndex(0);
								SafeText(valuePair.Key.StartTime.ToShortTimeString());
								ImGui.TableSetColumnIndex(1);
								string sName = ResolveServiceDisplayName(valuePair.Key.ServiceId);
								SafeText(sName);
								ImGui.TableSetColumnIndex(2);
								SafeText(valuePair.Value);
							}

							ImGui.EndTable();
						}
					}
				}

				ImGui.End();
			}
		}

		public void NotifyEvent(EitEvent eitEvent)
		{
			if (eitDisplay == null)
				eitDisplay = new SortedList<EitDay, SortedList<EitEventCoordinate, string>>(new EitDayComparer());

			TsType = 1;
			HasEit = true;

			EitDay date = new EitDay();
			date.Date = eitEvent.StartTime.Date;
			date.Visible = true;
			lock (eitDisplay)
			{
				if (!eitDisplay.ContainsKey(date))
				{
					eitDisplay[date] = new SortedList<EitEventCoordinate, string>(new EitEventCoordinateComparer());
				}

				SortedList<EitEventCoordinate, string> sortedList = eitDisplay[date];

				EitEventCoordinate coordinate = new EitEventCoordinate();
				coordinate.StartTime = eitEvent.StartTime;
				coordinate.NetworkId = eitEvent.OriginalNetworkId;
				coordinate.ServiceId = eitEvent.ServiceId;
				if (!sortedList.ContainsKey(coordinate))
				{
					sortedList.Add(coordinate, eitEvent.EventName);
				}
			}
		}

		#endregion EIT


		#region SDT

		private bool HasSdt;

		private string ResolveServiceDisplayName(ushort serviceId)
		{
			if (sdtDisplay == null)
				return String.Format("0x{0:X4}", serviceId);

			lock (sdtDisplay)
			{
				if (sdtDisplay.ContainsKey(serviceId))
				{
					string v = sdtDisplay[serviceId].ServiceName;
					if (string.IsNullOrEmpty(v))
						return "???";
					else
						return v;
				}
			}

			return String.Format("0x{0:X4}", serviceId);
		}

		private SdtCoordinate ResolveService(ushort serviceId)
		{
			if (sdtDisplay == null)
				return new SdtCoordinate();

			lock (sdtDisplay)
			{
				if (sdtDisplay.ContainsKey(serviceId))
				{
					return sdtDisplay[serviceId];
				}
			}

			return new SdtCoordinate();
		}

		private struct SdtCoordinate
		{
			public string ProviderName;
			public string ServiceName;
			public bool FreeCaMode;
			public ushort[] CaIdentifiers;
			public ServiceDescriptor.ServiceTypeCoding? ServiceType;
		}

		private SortedList<ushort, SdtCoordinate> sdtDisplay;
		private string sdtTableUuid;
		private void RenderSdt()
		{
			if (sdtDisplay == null)
				return;

			if (string.IsNullOrEmpty(sdtTableUuid))
				sdtTableUuid = Guid.NewGuid().ToString();


			ImGui.Begin("Service Description Table");
			if (ImGui.BeginTable(sdtTableUuid, 4, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
			{
				ImGui.TableSetupColumn("Service ID");
				ImGui.TableSetupColumn("Name");
				ImGui.TableSetupColumn("Provider");
				ImGui.TableSetupColumn("CA");
				ImGui.TableHeadersRow();

				lock (sdtDisplay)
				{
					foreach (KeyValuePair<ushort, SdtCoordinate> keyValuePair in sdtDisplay)
					{
						ImGui.TableNextRow();
						ImGui.TableSetColumnIndex(0);
						SafeText(String.Format("{0:X4}", keyValuePair.Key));

						ImGui.TableSetColumnIndex(1);
						SafeText(keyValuePair.Value.ServiceName);

						ImGui.TableSetColumnIndex(2);
						SafeText(keyValuePair.Value.ProviderName);

						ImGui.TableSetColumnIndex(3);
						bool ca = keyValuePair.Value.FreeCaMode;
						ImGui.BeginDisabled(true);
						ImGui.Checkbox("", ref ca);
						ImGui.EndDisabled();
					}
				}

				ImGui.EndTable();
				ImGui.End();
			}
		}

		public void NotifySdtService(SdtService sdtService)
		{
			TsType = 1;
			HasSdt = true;
			if (sdtDisplay == null)
				sdtDisplay = new SortedList<ushort, SdtCoordinate>();

			if (sdtDisplay.ContainsKey(sdtService.ServiceId))
				return;

			SdtCoordinate child = new SdtCoordinate();
			child.ProviderName = sdtService.ServiceProviderName;
			child.ServiceName = sdtService.ServiceName;
			child.FreeCaMode = sdtService.FreeCaMode;
			child.CaIdentifiers = sdtService.CaIdentifiers;
			child.ServiceType = sdtService.ServiceType;

			lock (sdtDisplay)
			{
				sdtDisplay.Add(sdtService.ServiceId, child);
			}
		}

		#endregion

		#region PAT
		private class PatEntry
		{
			public ushort programId;
			public ProgramMapping pmt;
			public string PmtViewUuid;
		}

		private bool HasPat;
		private int TsType;
		private SortedList<int, PatEntry> patDisplay;
		public void NotifyPatProgram(int pmtPid, ushort programId)
		{
			HasPat = true;
			TsType = 1;

			if (patDisplay == null)
				patDisplay = new SortedList<int, PatEntry>();

			if (patDisplay.ContainsKey(pmtPid))
				return;

			PatEntry patEntry = new PatEntry();
			patEntry.programId = programId;
			lock (patDisplay)
			{
				patDisplay.Add(pmtPid, patEntry);
			}
		}

		private string patTableUuid;
		public void RenderPat()
		{
			if (patDisplay == null)
				return;

			if (string.IsNullOrEmpty(patTableUuid))
				patTableUuid = Guid.NewGuid().ToString();
			if (ImGui.Begin("Program Allocation Table"))
			{
				if (ImGui.BeginTable(patTableUuid, 2, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
				{
					ImGui.TableSetupColumn("PMT PID");
					ImGui.TableSetupColumn("Service");
					ImGui.TableHeadersRow();

					lock (patDisplay)
					{
						foreach (KeyValuePair<int, PatEntry> keyValuePair in patDisplay)
						{
							string k = String.Format("0x{0:X4}", keyValuePair.Key);
							string v = ResolveServiceDisplayName(keyValuePair.Value.programId);
							if (v == null)
								v = "???";

							ImGui.TableNextRow();
							ImGui.TableSetColumnIndex(0);
							SafeText(k);

							ImGui.TableSetColumnIndex(1);
							SafeText(v);
						}
					}
					ImGui.EndTable();
				}
				ImGui.End();
			}
		}
		#endregion

		#region PMT

		private bool HasPmt;
		public void NotifyPmtProgram(ProgramMapping result, int pmtPid)
		{
			HasPmt = true;
			TsType = 1;

			if (!patDisplay.ContainsKey(pmtPid))
				return;

			PatEntry patEntry = patDisplay[pmtPid];
			if (patEntry.pmt != null)
				return;

			patEntry.pmt = result;
		}


		private string pmtTabBarUuid;
		public void RenderPmt()
		{
			if (!HasPmt)
				return;

			if (string.IsNullOrEmpty(pmtTabBarUuid))
				pmtTabBarUuid = Guid.NewGuid().ToString();

			if (ImGui.Begin("Program Map Table"))
			{
				if (ImGui.BeginTabBar(pmtTabBarUuid, ImGuiTabBarFlags.FittingPolicyScroll | ImGuiTabBarFlags.TabListPopupButton))
				{
					lock (patDisplay)
					{
						foreach (KeyValuePair<int, PatEntry> keyValuePair in patDisplay)
						{
							if (ImGui.BeginTabItem(ResolveServiceDisplayName(keyValuePair.Value.programId)))
							{
								if (string.IsNullOrEmpty(keyValuePair.Value.PmtViewUuid))
									keyValuePair.Value.PmtViewUuid = Guid.NewGuid().ToString();

								if (keyValuePair.Value.pmt == null)
									continue;

								ProgramMapping pmt = keyValuePair.Value.pmt;

								SafeText(String.Format("Service ID: 0x{0:X4}", pmt.ProgramNumber));

								ImGui.BeginTable(keyValuePair.Value.PmtViewUuid, 2, ImGuiTableFlags.NoSavedSettings);
								ImGui.TableSetupColumn("PID");
								ImGui.TableSetupColumn("Type");
								ImGui.TableHeadersRow();

								ImGui.TableNextRow();
								ImGui.TableSetColumnIndex(0);
								SafeText(String.Format("0x{0:X4}", keyValuePair.Key));

								ImGui.TableSetColumnIndex(1);
								SafeText("PMT");

								ImGui.TableNextRow();
								ImGui.TableSetColumnIndex(0);
								SafeText(String.Format("0x{0:X4}", keyValuePair.Value.pmt.PcrPid));

								ImGui.TableSetColumnIndex(1);
								SafeText("PCR");

								foreach (ProgramMappingStream programMappingStream in pmt.Streams)
								{
									ImGui.TableNextRow();
									ImGui.TableSetColumnIndex(0);
									SafeText(String.Format("0x{0:X4}", programMappingStream.ElementaryPid));

									ImGui.TableSetColumnIndex(1);
									SafeText(StreamTypeAsString(programMappingStream, pmt.RegistrationFormatIdentifier));
								}

								ImGui.EndTable();
								ImGui.EndTabItem();
							}
						}
					}
					ImGui.EndTabBar();
				}
				ImGui.End();
			}
		}

		private string StreamTypeAsString(ProgramMappingStream stream, uint? parentRegistrationFormatIdentifier)
		{
			if (streamTypes != null)
			{
				if (streamTypes.ContainsKey(stream.ElementaryPid))
				{
					return streamTypes[stream.ElementaryPid];
				}
			}
			if (stream.StreamType == PmtStreamType.H262)
				return "MPEG-2 Video";
			if (stream.AvcStillPresent.HasValue)
				return "MPEG-4 Video (still frame)";
			if (stream.AudioType.HasValue)
			{
				switch (stream.AudioType)
				{
					case AudioType.CleanEffects: return "Audio (no effects)";
					case AudioType.HearingImpaired: return "Audio (for hearing impaired)";
					case AudioType.VisualImpairedCommentary: return "Audio (for visually impaired)";
				}
			}

			if (stream.StreamType == PmtStreamType.AvcVideoStream)
			{
				return "MPEG-4 Video";
			}

			if (stream.StreamType == PmtStreamType.Iso11172Audio)
			{
				return "Audio";
			}

			if (stream.StreamType == PmtStreamType.Iso13818_3Audio)
				return "MPEG-2 Audio";
			if (stream.StreamType == PmtStreamType.Iso13818_7AudioADTS)
				return "AAC Audio";
			if (stream.StreamType == PmtStreamType.HevcVideoStream)
				return "H.265 Video";
			if (stream.StreamType == PmtStreamType.Iso13818_1PesPackets && stream.Ac4ChannelMode.HasValue)
				return "Dolby AC-4 Audio";
			if (stream.StreamType == PmtStreamType.Iso13818_1PesPackets && stream.BSID.HasValue)
				return "Dolby AC-3 Audio";
			if (stream.StreamType == PmtStreamType.Iso14496_3Audio && stream.AacProfileAndLevel.HasValue)
				return "AAC Audio";
			if ((int)stream.StreamType == 0x81 && stream.ComponentType.HasValue)
				return "Dolby AC-3 Audio";
			if (stream.Teletexts != null)
				return "Teletext";
			if (stream.StreamType == PmtStreamType.Iso13818_1PesPackets && stream.Subtitlings != null && stream.Subtitlings.Length > 0)
				return "Subtitle";
			if (stream.DataBroadcastId == 0x0007)
				return "Object Carousel";
			if (stream.StreamType == PmtStreamType.Iso13818_1PesPackets && stream.VbiData != null)
				return "Teletext";
			if ((byte)stream.StreamType == 0x89 && stream.AncillaryDataDescriptor != null && stream.AncillaryDataDescriptor.RdsOnly)
				return "Radio Data Service";
			if (stream.DataBroadcastId.HasValue && stream.DataBroadcastId.Value == 0x0005 /*&& stream.StreamType == PmtStreamType.Iso13818_6TypeD*/)
				return "Multiprotocol Encapsulation";
			if (stream.DataBroadcastId == 0x0106)
				return "MHEG-5";
			if (stream.DataBroadcastId == 0x000b)
				return "IP/MAC Notification";

			if (stream.RelatedContentDescriptorPresent.HasValue)
				if (stream.RelatedContentDescriptorPresent.Value && stream.StreamType == PmtStreamType.Iso13818_1PrivateSections)
					return "Related Content Table Information";

			if (stream.NumT2MiStreams.HasValue && stream.StreamType == PmtStreamType.Iso13818_1PesPackets)
				return "T2-MI";

			return String.Format("??? (Type 0x{0:X2})", (int)stream.StreamType);
		}

		#endregion

		#region NIT

		private class NitNetworkMeta
		{
			public ushort ONID;
			public string DisplayUUID;

			public override string ToString()
			{
				return String.Format("Network 0x{0:X4}", ONID);
			}

			public bool Equals(NitNetworkMeta other)
			{
				return ONID == other.ONID;
			}

			public override bool Equals(object? obj)
			{
				return obj is NitNetworkMeta other && Equals(other);
			}

			public override int GetHashCode()
			{
				return ONID.GetHashCode();
			}
		}

		private class NitCoordinateComparer : IComparer<NitNetworkMeta>
		{
			public int Compare(NitNetworkMeta x, NitNetworkMeta y)
			{
				return x.ONID.CompareTo(y.ONID);
			}
		}

		private SortedList<NitNetworkMeta, SortedList<ushort, NitTransportStream>> nitDisplay;
		private string nitTableUuid;
		private bool HasNit;

		public void NotifyNit(NitTransportStream transportStream)
		{
			TsType = 1;
			HasNit = true;

			if (nitDisplay == null)
				nitDisplay = new SortedList<NitNetworkMeta, SortedList<ushort, NitTransportStream>>(new NitCoordinateComparer());

			NitNetworkMeta nnm = new NitNetworkMeta();
			nnm.ONID = transportStream.OriginalNetworkId;
			if (!nitDisplay.ContainsKey(nnm))
			{
				lock (nitDisplay)
				{
					nitDisplay.Add(nnm, new SortedList<ushort, NitTransportStream>());
				}
			}

			SortedList<ushort, NitTransportStream> nitTransportStreams = nitDisplay[nnm];
			if (nitTransportStreams.ContainsKey(transportStream.TransportStreamId))
				return;

			lock (nitTransportStreams)
			{
				nitTransportStreams.Add(transportStream.TransportStreamId, transportStream);
			}
		}

		private string GetFrequencyString(NitTransportStream nts)
		{
			if (nts.Frequency.HasValue && nts.Polarization.HasValue)
				return String.Format("{0} Mhz, {1}", nts.Frequency.Value / 100, nts.Polarization.ToString().Substring(0, 1));

			return "???";
		}

		private void RenderNit()
		{
			if (nitDisplay == null)
				return;

			if (string.IsNullOrWhiteSpace(nitTableUuid))
				nitTableUuid = Guid.NewGuid().ToString();

			if (ImGui.Begin("Network Information Table"))
			{
				lock (nitDisplay)
				{
					foreach (KeyValuePair<NitNetworkMeta, SortedList<ushort, NitTransportStream>> keyValuePair in nitDisplay)
					{
						if (ImGui.CollapsingHeader(keyValuePair.Key.ToString()))
						{
							if (string.IsNullOrEmpty(keyValuePair.Key.DisplayUUID))
								keyValuePair.Key.DisplayUUID = Guid.NewGuid().ToString();
							if (ImGui.BeginTable(keyValuePair.Key.DisplayUUID, 4, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
							{
								lock (keyValuePair.Value)
								{
									foreach (KeyValuePair<ushort, NitTransportStream> nitTransportStream in keyValuePair
												 .Value)
									{
										ImGui.TableNextRow();
										ImGui.TableSetColumnIndex(0);
										SafeText(nitTransportStream.Value.DeliveryMethod.ToString().Replace('_', '_'));

										ImGui.TableSetColumnIndex(1);
										if (nitTransportStream.Value.OrbitalPosition.HasValue &&
											nitTransportStream.Value.East.HasValue)
										{
											SafeText(String.Format("{0:F1} °{1}",
												nitTransportStream.Value.OrbitalPosition.Value,
												nitTransportStream.Value.East.Value ? "E" : "W"));
										}

										ImGui.TableSetColumnIndex(2);
										SafeText(GetFrequencyString(nitTransportStream.Value));

										ImGui.TableSetColumnIndex(3);
										if (nitTransportStream.Value.SymbolRate.HasValue)
											SafeText(String.Format("{0} ksym/s",
												nitTransportStream.Value.SymbolRate / 10));
									}
								}
							}
							ImGui.EndTable();
						}
					}
				}
				ImGui.End();
			}
		}

		#endregion

		#region MPE

		private IpTrafficInfoComparer trafficInfoComparer;
		private string mpeTableUuid;
		private List<KeyValuePair<IpTrafficInfo, IpPerformanceInfo>> mpeDisplays;
		private bool HasMpe;

		public void NotifyMpeTraffic(IpTrafficInfo iti, int ipv4PacketLength)
		{
			if (trafficInfoComparer == null)
				trafficInfoComparer = new IpTrafficInfoComparer();
			HasMpe = true;
			if (mpeDisplays == null)
				mpeDisplays = new List<KeyValuePair<IpTrafficInfo, IpPerformanceInfo>>();

			lock (mpeDisplays)
			{
				foreach (KeyValuePair<IpTrafficInfo, IpPerformanceInfo> line in mpeDisplays)
				{
					if (line.Key.Equals(iti))
					{
						line.Value.CountPacket(ipv4PacketLength);
						return;
					}
				}

				KeyValuePair<IpTrafficInfo, IpPerformanceInfo> newChild = new KeyValuePair<IpTrafficInfo, IpPerformanceInfo>(iti, new IpPerformanceInfo());
				newChild.Value.CountPacket(ipv4PacketLength);
				mpeDisplays.Add(newChild);
			}
		}


		
		private void RenderMpe()
		{
			if (mpeDisplays == null)
				return;
			
			if (secondTick)
			{
				lock (mpeDisplays)
				{
					foreach (KeyValuePair<IpTrafficInfo, IpPerformanceInfo> line in mpeDisplays)
					{
						line.Value.UpdatePerSeconds();
					}
				}
			}

			string windowName = String.Format("{0} Encapsulation", TsType == 1 ? "Multiprotocol" : "Generic Stream");
			if (ImGui.Begin(windowName))
			{
				if (mpeDisplays != null)
				{
					if (mpeDisplays.Count > 0)
					{
						SafeText(String.Format("Communication parties: {0}", mpeDisplays.Count));
					}
				}
				if (string.IsNullOrEmpty(mpeTableUuid))
					mpeTableUuid = Guid.NewGuid().ToString();
				if (ImGui.BeginTable(mpeTableUuid, 5, ImGuiTableFlags.SizingFixedFit | ImGuiTableFlags.NoSavedSettings))
				{
					ImGui.TableSetupColumn("Protocol");
					ImGui.TableSetupColumn("Source IP");
					ImGui.TableSetupColumn("Destination IP");
					ImGui.TableSetupColumn("Packets");
					ImGui.TableSetupColumn("Traffic");
					ImGui.TableHeadersRow();

					lock (mpeDisplays)
					{
						mpeDisplays.Sort(trafficInfoComparer);
						foreach (KeyValuePair<IpTrafficInfo, IpPerformanceInfo> ipPerformanceInfo in mpeDisplays)
						{

							ImGui.TableNextRow();
							ImGui.TableSetColumnIndex(0);
							SafeText(IpTrafficInfo.GetProtocolName(ipPerformanceInfo.Key.Protocol));

							ImGui.TableSetColumnIndex(1);
							SafeText(RenderIp(ipPerformanceInfo, false));

							ImGui.TableSetColumnIndex(2);
							SafeText(RenderIp(ipPerformanceInfo, true));

							ImGui.TableSetColumnIndex(3);
							SafeText(ipPerformanceInfo.Value.TotalPackets.ToString());

							ImGui.TableSetColumnIndex(4);
							SafeText(String.Format("{0:F1} kb/s",
								(double)ipPerformanceInfo.Value.BytesPerSecond / 1000.0));
						}
					}

					ImGui.EndTable();
				}
				ImGui.End();
			}
		}

		private string RenderIp(KeyValuePair<IpTrafficInfo, IpPerformanceInfo> ipPerformanceInfo, bool destination)
		{
			if (!destination)
			{
				if (string.IsNullOrEmpty(ipPerformanceInfo.Key.SourceName))
					return ipPerformanceInfo.Key.Source.ToString();
				else
					return ipPerformanceInfo.Key.SourceName;
			}
			else
			{
				if (string.IsNullOrEmpty(ipPerformanceInfo.Key.TargetName))
					return ipPerformanceInfo.Key.Target.ToString();
				else
					return ipPerformanceInfo.Key.TargetName;
			}
		}

		#endregion

		#region AIT

		private SortedList<ApplicationIdentifier, AitApplication> aitDisplay;
		private string aitTableUuid;
		private bool HasAit;
		public void NotifyAit(AitApplication aitApplication)
		{
			TsType = 1;
			HasAit = true;

			if (aitDisplay == null)
				aitDisplay = new SortedList<ApplicationIdentifier, AitApplication>(new ApplicationIdentifierComparer());

			lock (aitDisplay)
			{
				if (!aitDisplay.ContainsKey(aitApplication.ApplicationIdentifier))
				{
					aitDisplay.Add(aitApplication.ApplicationIdentifier, aitApplication);
				}
			}
		}

		private void RenderAit()
		{
			if (aitDisplay == null)
				return;

			if (ImGui.Begin("Application Identification Table"))
			{
				if (string.IsNullOrEmpty(aitTableUuid))
					aitTableUuid = Guid.NewGuid().ToString();

				if (ImGui.BeginTable(aitTableUuid, 2, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
				{
					ImGui.TableSetupColumn("Application Name");
					ImGui.TableSetupColumn("Transport");
					ImGui.TableHeadersRow();

					lock (aitDisplay)
					{
						foreach (KeyValuePair<ApplicationIdentifier, AitApplication> keyValuePair in aitDisplay)
						{
							ImGui.TableNextRow();
							ImGui.TableSetColumnIndex(0);
							SafeText(keyValuePair.Value.TryGetName());

							ImGui.TableSetColumnIndex(1);
							foreach (TransportProtocolDescriptor transportProtocolDescriptor in keyValuePair.Value.TransportProtocols)
							{
								SafeText(transportProtocolDescriptor.Selector.ToString());
							}
						}
					}

					ImGui.EndTable();
				}
				ImGui.End();
			}
		}
		#endregion

		#region DSM-CC Modules

		private struct DsmCcModuleIdentifier
		{
			public int pid;
			public ushort moduleId;
			public byte moduleVersion;

		}

		private sealed class DsmCcModuleIdentifierComparer : IComparer<DsmCcModuleIdentifier>
		{
			public int Compare(DsmCcModuleIdentifier x, DsmCcModuleIdentifier y)
			{
				var pidComparison = x.pid.CompareTo(y.pid);
				if (pidComparison != 0) return pidComparison;
				var moduleIdComparison = x.moduleId.CompareTo(y.moduleId);
				if (moduleIdComparison != 0) return moduleIdComparison;
				return x.moduleVersion.CompareTo(y.moduleVersion);
			}
		}


		private SortedList<DsmCcModuleIdentifier, double> dsmCcDisplay;
		private string objectCarouselTableUuid;

		public void DsmCcModuleAdd(int elementaryPid, ushort moduleInfoModuleId, byte moduleInfoModuleVersion)
		{
			TsType = 1;
			HasDsmCc = true;

			if (dsmCcDisplay == null)
				dsmCcDisplay = new SortedList<DsmCcModuleIdentifier, double>(new DsmCcModuleIdentifierComparer());

			DsmCcModuleIdentifier id = new DsmCcModuleIdentifier();
			id.pid = elementaryPid;
			id.moduleId = moduleInfoModuleId;
			id.moduleVersion = moduleInfoModuleVersion;
			lock (dsmCcDisplay)
			{
				dsmCcDisplay.Add(id, 0);
			}
		}

		public void DsmCcModuleProgress(int elementaryPid, ushort moduleInfoModuleId, byte moduleInfoModuleVersion,
			double moduleInfoDownloadProgress)
		{
			TsType = 1;
			HasDsmCc = true;

			if (dsmCcDisplay == null)
				return;

			DsmCcModuleIdentifier id = new DsmCcModuleIdentifier();
			id.pid = elementaryPid;
			id.moduleId = moduleInfoModuleId;
			id.moduleVersion = moduleInfoModuleVersion;
			if (!dsmCcDisplay.ContainsKey(id))
				return;
			lock (dsmCcDisplay)
			{
				dsmCcDisplay[id] = moduleInfoDownloadProgress;
			}
		}

		public void DsmCcModuleComplete(int elementaryPid, ushort moduleModuleId, byte moduleModuleVersion)
		{
			DsmCcModuleIdentifier id = new DsmCcModuleIdentifier();
			id.pid = elementaryPid;
			id.moduleId = moduleModuleId;
			id.moduleVersion = moduleModuleVersion;
			lock (dsmCcDisplay)
			{
				dsmCcDisplay.Remove(id);
			}
		}


		private void RenderDataCarousels()
		{
			if (dsmCcDisplay == null)
				return;
			if (dsmCcDisplay.Count == 0)
				return;

			if (ImGui.Begin("Digital Storage Media Command & Control, Data Carousels"))
			{
				if (string.IsNullOrEmpty(objectCarouselTableUuid))
				{
					objectCarouselTableUuid = Guid.NewGuid().ToString();
				}

				if (ImGui.BeginTable(objectCarouselTableUuid, 4, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
				{
					ImGui.TableSetupColumn("PID");
					ImGui.TableSetupColumn("Module ID");
					ImGui.TableSetupColumn("Version");
					ImGui.TableSetupColumn("Progress");
					ImGui.TableHeadersRow();

					lock (dsmCcDisplay)
					{
						foreach (KeyValuePair<DsmCcModuleIdentifier, double> keyValuePair in dsmCcDisplay)
						{
							ImGui.TableNextRow();
							ImGui.TableSetColumnIndex(0);
							SafeText(String.Format("{0}", keyValuePair.Key.pid));

							ImGui.TableSetColumnIndex(1);
							SafeText(String.Format("{0}", keyValuePair.Key.moduleId));

							ImGui.TableSetColumnIndex(2);
							SafeText(String.Format("{0}", keyValuePair.Key.moduleVersion));

							ImGui.TableSetColumnIndex(3);
							ImGui.SetNextItemWidth(100);
							ImGui.ProgressBar(Convert.ToSingle(keyValuePair.Value) / 100.0f, Vector2.Zero, String.Format("{0}%", keyValuePair.Value));
						}
					}
					ImGui.EndTable();
				}
				ImGui.End();
			}

		}

		#endregion

		public void NotifyWss(ushort programNumber, WssDataBlock wssDataBlock)
		{
		}

		#region Stream Type Autodetection

		private Dictionary<int, string> streamTypes;

		public void NotifyStreamTypeDetection(string contestantTag, int pid)
		{
			if (streamTypes == null)
				streamTypes = new Dictionary<int, string>();
			streamTypes[pid] = contestantTag;
		}

		#endregion

		#region BAT
		private struct DisplayableBat
		{
			public string Name;
			public List<LinkageDescriptor> Linkages;
			public string TableUuid;
			public HashSet<BatTransportStream> TransportStreams;
		}

		private SortedList<ushort, DisplayableBat> batDisplay;
		private bool HasBat;

		public void NotifyBat(BatBouquet batBouquet)
		{
			TsType = 1;
			HasBat = true;

			if (batDisplay == null)
				batDisplay = new SortedList<ushort, DisplayableBat>();

			if (batDisplay.ContainsKey(batBouquet.BouquetId))
				return;

			DisplayableBat child = new DisplayableBat();
			child.Name = batBouquet.TryGetName();
			child.Linkages = batBouquet.Linkages;
			child.TableUuid = Guid.NewGuid().ToString();
			child.TransportStreams = new HashSet<BatTransportStream>();

			lock (batDisplay)
			{
				batDisplay[batBouquet.BouquetId] = child;
			}
		}
		

		public void NotifyBatTs(ushort batBouquetBouquetId, BatTransportStream child)
		{
			TsType = 1;
			HasBat = true;

			if (batDisplay == null)
				return;
			if (!batDisplay.ContainsKey(batBouquetBouquetId))
				return;

			batDisplay[batBouquetBouquetId].TransportStreams.Add(child);
		}

		private void RenderBat()
		{
			if (batDisplay == null)
				return;

			if (batDisplay.Count == 0)
				return;

			if (ImGui.Begin("Bouquet Association Table"))
			{
				lock (batDisplay)
				{
					foreach (KeyValuePair<ushort, DisplayableBat> keyValuePair in batDisplay)
					{
						if (ImGui.CollapsingHeader(String.Format("Bouquet #{0} - {1}", keyValuePair.Key, keyValuePair.Value.Name)))
						{
							if (ImGui.BeginTable(keyValuePair.Value.TableUuid, 5, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
							{
								ImGui.TableSetupColumn("L/TS");
								ImGui.TableSetupColumn("ONID");
								ImGui.TableSetupColumn("TSID");
								ImGui.TableSetupColumn("Service");
								ImGui.TableSetupColumn("");
								ImGui.TableHeadersRow();

								lock (keyValuePair.Value.Linkages)
								{
									foreach (LinkageDescriptor linkageDescriptor in keyValuePair.Value.Linkages)
									{
										ImGui.TableNextRow();
										ImGui.TableSetColumnIndex(0);
										SafeText("Link");

										ImGui.TableSetColumnIndex(1);
										SafeText(String.Format("{0:X4}", linkageDescriptor.OriginalNetworkId));

										ImGui.TableSetColumnIndex(2);
										SafeText(String.Format("{0:X4}", linkageDescriptor.TransportStreamId));

										ImGui.TableSetColumnIndex(3);
										SafeText(ResolveServiceDisplayName(linkageDescriptor.ServiceId));

										ImGui.TableSetColumnIndex(4);
										SafeText(linkageDescriptor.LinkageType.ToString());
									}
								}

								lock (keyValuePair.Value.TransportStreams)
								{
									foreach (BatTransportStream valueTransportStream in keyValuePair.Value.TransportStreams)
									{
										ImGui.TableNextRow();
										ImGui.TableSetColumnIndex(0);
										SafeText("TS");

										ImGui.TableSetColumnIndex(1);
										SafeText(String.Format("{0:X4}", valueTransportStream.OriginalNetworkId));

										ImGui.TableSetColumnIndex(2);
										SafeText(String.Format("{0:X4}", valueTransportStream.TransportStreamId));

										if (valueTransportStream.ServiceList != null)
										{
											foreach (ServiceListDescriptor.Service service in valueTransportStream.ServiceList)
											{
												ImGui.TableNextRow();
												ImGui.TableSetColumnIndex(0);
												SafeText("Service");

												ImGui.TableSetColumnIndex(3);
												SafeText(ResolveServiceDisplayName(service.ServiceId));

												ImGui.TableSetColumnIndex(4);
												SafeText(service.ServiceType.ToString());
											}
										}
									}
								}
								ImGui.EndTable();
							}
						}
					}
				}
				ImGui.End();
			}
		}

		#endregion

		#region DSM-CC Object Carousel
		private SortedList<int, VfsDirectory> displayObjectCarouselRoots;
		private bool HasDsmCc;

		private string GetServiceNameFromPid(int pid)
		{
			lock (patDisplay)
			{
				foreach (KeyValuePair<int, PatEntry> keyValuePair in patDisplay)
				{
					PatEntry patEntry = keyValuePair.Value;
					if (patEntry.pmt == null)
						continue;

					foreach (ProgramMappingStream programMappingStream in patEntry.pmt.Streams)
					{
						if (programMappingStream.ElementaryPid == pid)
						{
							return ResolveServiceDisplayName(patEntry.programId);
						}
					}
				}
			}

			return "???";
		}

		public void DsmCcVfs(VfsFile vfsFile)
		{
			TsType = 1;
			HasDsmCc = true;
			if (displayObjectCarouselRoots == null)
				displayObjectCarouselRoots = new SortedList<int, VfsDirectory>();
			if (displayObjectCarouselRoots.ContainsKey(vfsFile.SourcePid))
				return;

			VfsDirectory masterDirectory = vfsFile.ParentDirectory;
			while (masterDirectory.ParentDirectory != null)
				masterDirectory = masterDirectory.ParentDirectory;

			lock (displayObjectCarouselRoots)
			{
				displayObjectCarouselRoots.Add(vfsFile.SourcePid, masterDirectory);
			}
		}

		private void RenderObjectCarousels()
		{
			if (displayObjectCarouselRoots == null)
				return;

			if (ImGui.Begin("Digital Storage Media - Command & Control, Object Carousels"))
			{
				lock (displayObjectCarouselRoots)
				{
					foreach (KeyValuePair<int, VfsDirectory> displayObjectCarouselRoot in displayObjectCarouselRoots)
					{
						string name = String.Format("Object Carousel in PID 0x{1:X4} (Service: {0})", GetServiceNameFromPid(displayObjectCarouselRoot.Key), displayObjectCarouselRoot.Key);
						if (ImGui.CollapsingHeader(name))
						{
							RenderDirectoryNode(displayObjectCarouselRoot.Value);
						}
					}
				}
			}
		}

		private void RenderDirectoryNode(VfsDirectory directory)
		{
			if (!directory.SkyscrpaerUiData.ContainsKey("UUID"))
				directory.SkyscrpaerUiData.Add("UUID", Guid.NewGuid().ToString());

			string dname = directory.Name;
			if (string.IsNullOrEmpty(dname) && directory.ParentDirectory == null)
				dname = "<root directory>";

			if (ImGui.TreeNode(directory.SkyscrpaerUiData["UUID"].ToString(), dname))
			{
				foreach (VfsDirectory subdirectory in directory.subdirectories)
				{
					RenderDirectoryNode(subdirectory);
				}

				foreach (VfsFile directoryFile in directory.files)
				{
					SafeText(directoryFile.Name);
				}

				foreach (VfsEvent directoryEvent in directory.events)
				{
					SafeText(directoryEvent.Name);
				}
				ImGui.TreePop();
			}
		}
		#endregion

		#region TOT

		private DateTime? totTime;
		private LocalTimeOffsetDescriptor totDescriptor;
		private string totDisplayUuid;
		private bool HasTot;

		public void NotifyTot(DateTime utcTime, LocalTimeOffsetDescriptor ltod)
		{
			TsType = 1;
			HasTot = true;

			totTime = utcTime;
			totDescriptor = ltod;
		}

		private void RenderTot()
		{
			if (!totTime.HasValue)
				return;

			if (ImGui.Begin("Time Offset Table"))
			{
				SafeText(totTime.ToString());

				if (totDescriptor != null)
				{
					if (totDescriptor.Valid)
					{
						if (string.IsNullOrEmpty(totDisplayUuid))
							totDisplayUuid = Guid.NewGuid().ToString();

						if (ImGui.BeginTable(totDisplayUuid, 3, ImGuiTableFlags.SizingFixedFit | ImGuiTableFlags.NoSavedSettings))
						{
							ImGui.TableSetupColumn("Region");
							ImGui.TableSetupColumn("Polarity");
							ImGui.TableSetupColumn("Offset");
							ImGui.TableHeadersRow();

							foreach (LocalTimeOffsetDescriptor.LocalTime totDescriptorLocalTimeOffset in totDescriptor.LocalTimeOffsets)
							{
								ImGui.TableNextRow();
								ImGui.TableSetColumnIndex(0);
								SafeText(totDescriptorLocalTimeOffset.CountryCode);

								ImGui.TableSetColumnIndex(1);
								bool b = totDescriptorLocalTimeOffset.LocalTimeOffsetPolarity;
								ImGui.BeginDisabled(true);
								ImGui.Checkbox("", ref b);
								ImGui.EndDisabled();

								ImGui.TableSetColumnIndex(2);
								SafeText(totDescriptorLocalTimeOffset.LocalTimeOffset.ToString());
							}
							ImGui.EndTable();
						}
					}
				}
				ImGui.End();
			}
		}
		#endregion

		#region TDT
		private DateTime? tdtDisplay;
		private bool HasTdt;
		public void NotifyTdt(DateTime utcTime)
		{
			TsType = 1;
			HasTdt = true;
			tdtDisplay = utcTime;
		}

		private void RenderTdt()
		{
			if (tdtDisplay.HasValue)
			{
				if (ImGui.Begin("Time and Date Table"))
				{
					SafeText(tdtDisplay.Value.ToString());
					ImGui.End();
				}
			}
		}
		#endregion

		#region CAT
		private string caTableUuid;
		private HashSet<CaDescriptor> caDisplay;
		private bool HasCat;
		public void NotifyCat(CaDescriptor caDescriptor)
		{
			TsType = 1;
			HasCat = true;

			if (caDisplay == null)
				caDisplay = new HashSet<CaDescriptor>();

			lock (caDisplay)
			{
				caDisplay.Add(caDescriptor);
			}
		}

		private void RenderCat()
		{
			if (caDisplay == null)
				return;

			if (ImGui.Begin("Conditional Access Table"))
			{
				if (string.IsNullOrEmpty(caTableUuid))
					caTableUuid = Guid.NewGuid().ToString();

				if (ImGui.BeginTable(caTableUuid, 3, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.SizingFixedFit))
				{
					ImGui.TableSetupColumn("CA System");
					ImGui.TableSetupColumn("ECM/EMM PID");
					ImGui.TableSetupColumn("Private Data");
					ImGui.TableHeadersRow();
					lock (caDisplay)
					{
						foreach (CaDescriptor caDescriptor in caDisplay)
						{
							ImGui.TableNextRow();
							ImGui.TableSetColumnIndex(0);
							SafeText(CaSystemNames.GetHumanReadableName(caDescriptor.CaSystemId));

							ImGui.TableSetColumnIndex(1);
							SafeText(String.Format("{0:X4}", caDescriptor.CaPid));

							ImGui.TableSetColumnIndex(2);
							if (caDescriptor.PrivateData != null)
							{
								if (caDescriptor.PrivateData.Length != 0)
									SafeText(BitConverter.ToString(caDescriptor.PrivateData));
							}
						}
					}
					ImGui.EndTable();
				}
				ImGui.End();
			}
		}
		#endregion

		public void NotifyScte35(ushort programNumber, SpliceInsert spliceInsert)
		{

		}

		public void NotifyScte35(ushort programNumber, TimeSignal spliceInsert)
		{
		}

		public void SetMemorySaverMode(bool saveMemory)
		{

		}

		public void NotifyDocsisCarrier(DocsisEnvironment docsisEnvironment)
		{
			throw new NotImplementedException();
		}

		public void NotifyDocsisFrequency(uint? frequency, bool isUpstream, object mmm)
		{
			throw new NotImplementedException();
		}

		private bool gseMode;
		public void SetGseMode()
		{
			gseMode = true;
		}

		#region Framegrabs

		private Queue<PictureWindow> framegrabWindows;
		private int windowSpawnX = 100;
		public void ShowFramegrab(int currentNetworkId, int transportStreamId, ushort mappingProgramNumber,
			int mappingStreamElementaryPid, byte[] imageData)
		{
			if (framegrabWindows == null)
				framegrabWindows = new Queue<PictureWindow>();

			Tasks.EnqueueTask(() =>
			{
				string resolveServiceDisplayName = ResolveServiceDisplayName(mappingProgramNumber);
				if (string.IsNullOrEmpty(resolveServiceDisplayName))
					resolveServiceDisplayName = String.Format("Framegrab of Service #{0:X4}");
				else
					resolveServiceDisplayName = String.Format("Framegrab of \"{0}\"", resolveServiceDisplayName);

				if (PictureWindow.Renderer == null)
					return;

				Renderer renderer = PictureWindow.Renderer;
				string displayName = resolveServiceDisplayName;

				PictureWindow child = new PictureWindow(renderer, displayName, imageData);
				child.SetPosition(windowSpawnX, windowSpawnX);
				child.SetTaskQueue(Tasks, jobContext.Renderables);

				jobContext.Renderables.Add(child);
				framegrabWindows.Enqueue(child);
			});
		}
		#endregion

		public void NotifyBlockstreamCarrier()
		{
			throw new NotImplementedException();
		}

		#region Database Callbacks
		public IEnumerable<HumanReadableService> GetServices()
		{
			if (HasPmt)
			{
				foreach (var (pmtPid, patValue) in patDisplay)
				{
					ushort serviceId = patValue.programId;
					SdtCoordinate sdt = ResolveService(serviceId);
					string providerName = sdt.ProviderName;
					string serviceName = sdt.ServiceName;
					ushort? caId = ResolveCaId(patValue.pmt, sdt);
					ServiceDescriptor.ServiceTypeCoding? serviceType = sdt.ServiceType;
					yield return new HumanReadableService(serviceId, providerName, serviceName, caId, serviceType.GetValueOrDefault());
				}
			}
		}

		private ushort? ResolveCaId(ProgramMapping patValuePmt, SdtCoordinate sdt)
		{
			if (patValuePmt != null)
			{
				if (patValuePmt.CaSystemId.HasValue)
					return patValuePmt.CaSystemId.Value;

				foreach (ProgramMappingStream stream in patValuePmt.Streams)
				{
					if (stream.CaSystemId.HasValue)
						return stream.CaSystemId;
				}
			}

			if (sdt.CaIdentifiers != null)
			{
				if (sdt.CaIdentifiers.Length > 0)
					return sdt.CaIdentifiers[0];
			}

			return null;
		}
		#endregion
		#endregion


		#region During Blindscan
		private FoundFrequenciesWindow2 foundFrequenciesWindow;
		public void OnBlindscanOpenFoundFrquenciesWindow(List<BlindscanSearchResult> foundFrequencies, STD_TYPE tunerMetadataType)
		{
			foundFrequenciesWindow = new FoundFrequenciesWindow2(foundFrequencies);
			
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Add(foundFrequenciesWindow);
			});
		}

		public void OnBlindscanJobDone(bool success)
		{
			jobContext.Puppets[0].AutoMoveToHome();
			jobContext.Puppets[1].AutoMoveToHome();
			jobContext.Puppets[2].AutoMoveTo(new Point(0, 720 / 2));
			jobContext.Puppets[3].AutoMoveTo(new Point(1280 / 2, 0));

			jobContext.ReadyForNextJob = true;
		}

		public void OnBlindscanErrorMessage(string blindscanningLowHorizontalAreaFailed)
		{
			throw new NotImplementedException();
		}

		public void OnBlindscanBandComplete()
		{
			foreach (CharSet jobContextPuppet in jobContext.Puppets) 
				jobContextPuppet.AutoMoveToHome();
		}

		private BlindscanProgressWindow _blindscanProgressWindow;
		public void OnBlindscanBeforeBLScan(int minimum, int currentProgress, int maximum)
		{
			_blindscanProgressWindow = new BlindscanProgressWindow();
			_blindscanProgressWindow.Start = minimum;
			_blindscanProgressWindow.Progress = minimum;
			_blindscanProgressWindow.End = maximum;
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Add(_blindscanProgressWindow);
			});
		}

		public void OnBlindscanAfterBLScan()
		{
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Remove(_blindscanProgressWindow);
				_blindscanProgressWindow = null;
			});
		}

		public void OnBlindscanSearchResult1Callback(BlindscanSearchResult searchResult, int polarityIndex,
			int lnbTypeMinimumFrequency, int lnbTypeMaximumFrequency)
		{
			Blindscan.BlindscanResult blindscanResult = new Blindscan.BlindscanResult(searchResult.SearchResult, lnbTypeMinimumFrequency, lnbTypeMaximumFrequency);
			jobContext.Puppets[blindscanResult.sr1.Pol].AutoMoveTo(blindscanResult.Position);
			lock (jobContext.PressurePlates)
			{
				jobContext.PressurePlates.Add(blindscanResult);
			}

			_blindscanProgressWindow.Progress = searchResult.SearchResult.Freq;

			SoundPlayer.PlaySoundFile("lock.wav");
		}

		private Point GetFrequencyPosition(SearchResult searchResult, int satPositionMinFreq, int satPositionMaxFreq)
		{
			int x = 0, y = 0;

			if (searchResult.Pol == 0)
			{
				//Horizontal
				int w = (searchResult.Freq / 1000) - satPositionMinFreq;
				int hundert = 1280;
				int g = (satPositionMaxFreq - satPositionMinFreq);

				x = w * hundert / g;
				y = 720 / 2;
			}
			else
			{
				//Vertical
				int w = (searchResult.Freq / 1000) - satPositionMinFreq;
				int hundert = 720;
				int g = (satPositionMaxFreq - satPositionMinFreq);

				x = 1280 / 2;
				y = w * hundert / g;
			}

			Point position = new Point(x, y);
			return position;
		}

		public void OnBlindscanBeforeSetChannel(BlindscanSearchResult blindscanResult, LnbType lnb)
		{
			Point point = GetFrequencyPosition(blindscanResult.SearchResult, lnb.MinimumFrequency, lnb.MaximumFrequency);
			jobContext.Puppets[2 + blindscanResult.SearchResult.Pol].AutoMoveTo(point);
		}

		public void OnScrapeBandComplete()
		{
			jobContext.Puppets[0].AutoMoveToHome();
			jobContext.Puppets[1].AutoMoveToHome();
			jobContext.Puppets[2].AutoMoveToHome();
			jobContext.Puppets[3].AutoMoveToHome();
			
		}

		public void OnBlindscanScrapeTransponderComplete(BlindscanSearchResult blindscanResult)
		{
			lock (jobContext.PressurePlates)
			{
				foreach (IPressurePlate pressurePlate in jobContext.PressurePlates)
				{
					Blindscan.BlindscanResult result = pressurePlate as Blindscan.BlindscanResult;
					if (result.Satellite)
					{
						if (result.GetFrequency() == blindscanResult.GetFrequency())
						{
							jobContext.PressurePlates.Remove(result);
							break;
						}
					}
					else
					{
						throw new NotImplementedException("non satellite pressure plate.");
					}
				}
			}
		}

		private SdlScottPlotWindowRfSpectrum rfSpectrumWindow;
		public void OnBlindscanBeginRfSpectrum()
		{
			Tasks.EnqueueTask(() =>
			{
				rfSpectrumWindow = new SdlScottPlotWindowRfSpectrum(jobContext.ImgUiDevice);
				jobContext.Renderables.Add(rfSpectrumWindow);
			});
		}

		public void OnBlindscanRfSpectrumEnqueueSample(SatelliteDeliverySystemDescriptor.PolarizationEnum polarization, int frequency, double rf)
		{
			Tasks.EnqueueTask(() =>
			{
				rfSpectrumWindow.EnqueueSample(polarization, frequency, rf);
			});
		}

		public void OnBlindscanEndRfSpectrum()
		{
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Remove(rfSpectrumWindow);
				rfSpectrumWindow.Dispose();
				rfSpectrumWindow = null;
			});
		}

		private IqWindow iqWindow;
		public void OnBlindscanBeginIqSpectrum(IqChartData result)
		{
			Tasks.EnqueueTask(() =>
			{
				iqWindow = new IqWindow(jobContext.ImgUiDevice, result);
				jobContext.Renderables.Add(iqWindow);
			});
		}

		public void OnBlindscanEndIq()
		{
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Remove(iqWindow);
				iqWindow.Dispose();
				iqWindow = null;
			});
		}

		public void OnBlindscanLockFail(SearchResult satelliteSr, BlindscanResultState resultState)
		{
			SoundPlayer.PlaySoundFile("fail.wav");
		}

		public void OnBlindscanFilterSetUp()
		{
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Add(this);
			});
			foundFrequenciesWindow.allowZapNow = true;
			foundFrequenciesWindow.statusPacketsInQueue = 0;
			foundFrequenciesWindow.statusPacketsInTotal = 0;
		}

		public void OnBlindscanScrapeStopCondition()
		{
			foundFrequenciesWindow.allowZapNow = false;
		}

		public void OnBlindscanAfterPacketDrain()
		{
			Tasks.EnqueueTask(() =>
			{
				jobContext.Renderables.Remove(this);
				ResetWindows();
			});
		}

		public void OnBlindscanPacketError(int errorCount, int length)
		{
			throw new NotImplementedException();
		}

		public void OnBlindscanPacketOk(int numPackets, int packetsQueueCount)
		{
			foundFrequenciesWindow.statusPacketsInTotal += (uint)numPackets;
			foundFrequenciesWindow.statusPacketsInQueue = packetsQueueCount;
		}

		public bool IsZapNowRequested()
		{
			if (foundFrequenciesWindow.zapNowRequested)
			{
				foundFrequenciesWindow.zapNowRequested = false;
				return true;
			}

			return false;
		}

		public bool MayAutoZap()
		{
			return !foundFrequenciesWindow.doNotAutoZap;
		}

		public TaskQueue Tasks { get; set; }

		internal JobContext jobContext;
		#endregion       
	}
}