using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using ApplicationServices;
using AppScaffolding;
using LibationFileManager;

namespace LibationWinForms.ProcessQueue
{
	internal partial class ProcessQueueControl : UserControl, ILogForm
	{
		private TrackedQueue<ProcessBook> Queue = new();
		private readonly LogMe Logger;
		private int QueuedCount
		{
			set
			{
				queueNumberLbl.Text = value.ToString();
				queueNumberLbl.Visible = value > 0;
			}
		}
		private int ErrorCount
		{
			set
			{
				errorNumberLbl.Text = value.ToString();
				errorNumberLbl.Visible = value > 0;
			}
		}

		private int CompletedCount
		{
			set
			{
				completedNumberLbl.Text = value.ToString();
				completedNumberLbl.Visible = value > 0;
			}
		}

		public Task QueueRunner { get; private set; }
		public bool Running => !QueueRunner?.IsCompleted ?? false;
		public ToolStripButton popoutBtn = new();

		public ProcessQueueControl()
		{
			InitializeComponent();

			var speedLimitMBps = Configuration.Instance.DownloadSpeedLimit / 1024m / 1024;
			numericUpDown1.Value = speedLimitMBps > numericUpDown1.Maximum || speedLimitMBps < numericUpDown1.Minimum ? 0 : speedLimitMBps;

			popoutBtn.DisplayStyle = ToolStripItemDisplayStyle.Text;
			popoutBtn.Name = "popoutBtn";
			popoutBtn.Text = "Pop Out";
			popoutBtn.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
			popoutBtn.Alignment = ToolStripItemAlignment.Right;
			popoutBtn.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
			statusStrip1.Items.Add(popoutBtn);

			Logger = LogMe.RegisterForm(this);

			virtualFlowControl2.RequestData += VirtualFlowControl1_RequestData;
			virtualFlowControl2.ButtonClicked += VirtualFlowControl2_ButtonClicked;

			Queue.QueuededCountChanged += Queue_QueuededCountChanged;
			Queue.CompletedCountChanged += Queue_CompletedCountChanged;

			Load += ProcessQueueControl_Load;
		}

		private void ProcessQueueControl_Load(object sender, EventArgs e)
		{
			if (DesignMode) return;

			runningTimeLbl.Text = string.Empty;
			QueuedCount = 0;
			ErrorCount = 0;
			CompletedCount = 0;
		}

		private bool isBookInQueue(DataLayer.LibraryBook libraryBook)
			=> Queue.Any(b => b?.LibraryBook?.Book?.AudibleProductId == libraryBook.Book.AudibleProductId);

		public void AddDownloadPdf(DataLayer.LibraryBook libraryBook)
			=> AddDownloadPdf(new List<DataLayer.LibraryBook>() { libraryBook });

		public void AddDownloadDecrypt(DataLayer.LibraryBook libraryBook)
			=> AddDownloadDecrypt(new List<DataLayer.LibraryBook>() { libraryBook });

		public void AddConvertMp3(DataLayer.LibraryBook libraryBook)
			=> AddConvertMp3(new List<DataLayer.LibraryBook>() { libraryBook });

		public void AddDownloadPdf(IEnumerable<DataLayer.LibraryBook> entries)
		{
			List<ProcessBook> procs = new();
			foreach (var entry in entries)
			{
				if (isBookInQueue(entry))
					continue;

				ProcessBook pbook = new(entry, Logger);
				pbook.PropertyChanged += Pbook_DataAvailable;
				pbook.AddDownloadPdf();
				procs.Add(pbook);
			}

			Serilog.Log.Logger.Information("Queueing {count} books", procs.Count);
			AddToQueue(procs);
		}

		public void AddDownloadDecrypt(IEnumerable<DataLayer.LibraryBook> entries)
		{
			List<ProcessBook> procs = new();
			foreach (var entry in entries)
			{
				if (isBookInQueue(entry))
					continue;

				ProcessBook pbook = new(entry, Logger);
				pbook.PropertyChanged += Pbook_DataAvailable;
				pbook.AddDownloadDecryptBook();
				pbook.AddDownloadPdf();
				procs.Add(pbook);
			}

			Serilog.Log.Logger.Information("Queueing {count} books", procs.Count);
			AddToQueue(procs);
		}
		
		public void AddConvertMp3(IEnumerable<DataLayer.LibraryBook> entries)
		{
			List<ProcessBook> procs = new();
			foreach (var entry in entries)
			{
				if (isBookInQueue(entry))
					continue;

				ProcessBook pbook = new(entry, Logger);
				pbook.PropertyChanged += Pbook_DataAvailable;
				pbook.AddConvertToMp3();
				procs.Add(pbook);
			}

			Serilog.Log.Logger.Information("Queueing {count} books", procs.Count);
			AddToQueue(procs);
		}
		private void AddToQueue(IEnumerable<ProcessBook> pbook)
		{
			BeginInvoke(() =>
			{
				Queue.Enqueue(pbook);
				if (!Running)
					QueueRunner = QueueLoop();
			});
		}

		DateTime StartingTime;
		private async Task QueueLoop()
		{
			try
			{
				Serilog.Log.Logger.Information("Begin processing queue");

				StartingTime = DateTime.Now;
				counterTimer.Start();

				bool shownServiceOutageMessage = false;

				while (Queue.MoveNext())
				{
					var nextBook = Queue.Current;

					Serilog.Log.Logger.Information("Begin processing queued item. {item_LibraryBook}", nextBook?.LibraryBook);

					var result = await nextBook.ProcessOneAsync();

					Serilog.Log.Logger.Information("Completed processing queued item: {item_LibraryBook}\r\nResult: {result}", nextBook?.LibraryBook, result);

					if (result == ProcessBookResult.ValidationFail)
						Queue.ClearCurrent();
					else if (result == ProcessBookResult.FailedAbort)
						Queue.ClearQueue();
					else if (result == ProcessBookResult.FailedSkip)
						nextBook.LibraryBook.Book.UpdateBookStatus(DataLayer.LiberatedStatus.Error);
					else if (result == ProcessBookResult.LicenseDeniedPossibleOutage && !shownServiceOutageMessage)
					{
						MessageBox.Show(@$"
You were denied a content license for {nextBook.LibraryBook.Book.Title}

This error appears to be caused by a temporary interruption of service that sometimes affects Libation's users. This type of error usually resolves itself in 1 to 2 days, and in the meantime you should still be able to access your books through Audible's website or app.
",
						"Possible Interruption of Service",
						MessageBoxButtons.OK,
						MessageBoxIcon.Asterisk);
						shownServiceOutageMessage = true;
					}
				}
				Serilog.Log.Logger.Information("Completed processing queue");

				Queue_CompletedCountChanged(this, 0);
				counterTimer.Stop();
				virtualFlowControl2.VirtualControlCount = Queue.Count;
				UpdateAllControls();
			}
			catch (Exception ex)
			{
				Serilog.Log.Logger.Error(ex, "An error was encountered while processing queued items");
			}
		}

		public void WriteLine(string text)
		{
			if (IsDisposed) return;

			var timeStamp = DateTime.Now;
			Invoke(() => logDGV.Rows.Add(timeStamp, text.Trim()));
		}

		#region Control event handlers

		private void Queue_CompletedCountChanged(object sender, int e)
		{
			int errCount = Queue.Completed.Count(p => p.Result is ProcessBookResult.FailedAbort or ProcessBookResult.FailedSkip or ProcessBookResult.FailedRetry or ProcessBookResult.ValidationFail);
			int completeCount = Queue.Completed.Count(p => p.Result is ProcessBookResult.Success);

			ErrorCount = errCount;
			CompletedCount = completeCount;
			UpdateProgressBar();
		}
		private void Queue_QueuededCountChanged(object sender, int cueCount)
		{
			QueuedCount = cueCount;
			virtualFlowControl2.VirtualControlCount = Queue.Count;
			UpdateProgressBar();
		}
		private void UpdateProgressBar()
		{
			toolStripProgressBar1.Maximum = Queue.Count;
			toolStripProgressBar1.Value = Queue.Completed.Count;
		}

		private async void cancelAllBtn_Click(object sender, EventArgs e)
		{
			Queue.ClearQueue();
			if (Queue.Current is not null)
				await Queue.Current.CancelAsync();
			virtualFlowControl2.VirtualControlCount = Queue.Count;
			UpdateAllControls();
		}

		private void btnClearFinished_Click(object sender, EventArgs e)
		{
			Queue.ClearCompleted();
			virtualFlowControl2.VirtualControlCount = Queue.Count;
			UpdateAllControls();

			if (!Running)
				runningTimeLbl.Text = string.Empty;
		}

		private void CounterTimer_Tick(object sender, EventArgs e)
		{
			string timeToStr(TimeSpan time)
			{
				string minsSecs = $"{time:mm\\:ss}";
				if (time.TotalHours >= 1)
					return $"{time.TotalHours:F0}:{minsSecs}";
				return minsSecs;
			}

			if (Running)
				runningTimeLbl.Text = timeToStr(DateTime.Now - StartingTime);
		}

		private void clearLogBtn_Click(object sender, EventArgs e)
		{
			logDGV.Rows.Clear();
		}

		private void LogCopyBtn_Click(object sender, EventArgs e)
		{
			string logText = string.Join("\r\n", logDGV.Rows.Cast<DataGridViewRow>().Select(r => $"{r.Cells[0].Value}\t{r.Cells[1].Value}"));
			Clipboard.SetDataObject(logText, false, 5, 150);
		}

		private void LogDGV_Resize(object sender, EventArgs e)
		{
			logDGV.Columns[1].Width = logDGV.Width - logDGV.Columns[0].Width;
		}

		#endregion

		#region View-Model update event handling

		/// <summary>
		/// Index of the first <see cref="ProcessBook"/> visible in the <see cref="VirtualFlowControl"/>
		/// </summary>
		private int FirstVisible = 0;
		/// <summary>
		/// Number of <see cref="ProcessBook"/> visible in the <see cref="VirtualFlowControl"/>
		/// </summary>
		private int NumVisible = 0;
		/// <summary>
		/// Controls displaying the <see cref="ProcessBook"/> state, starting with <see cref="FirstVisible"/> 
		/// </summary>
		private IReadOnlyList<ProcessBookControl> Panels;

		/// <summary>
		/// Updates the display of a single <see cref="ProcessBookControl"/> at <paramref name="queueIndex"/> within <see cref="Queue"/>
		/// </summary>
		/// <param name="queueIndex">index of the <see cref="ProcessBook"/> within the <see cref="Queue"/></param>
		/// <param name="propertyName">The nme of the property that needs updating. If null, all properties are updated.</param>
		private void UpdateControl(int queueIndex, string propertyName = null)
		{
			try
			{
				int i = queueIndex - FirstVisible;

				if (i > NumVisible || i < 0) return;

				var proc = Queue[queueIndex];

				Invoke(() =>
				{
					Panels[i].SuspendLayout();
					if (propertyName is null or nameof(proc.Cover))
						Panels[i].SetCover(proc.Cover);
					if (propertyName is null or nameof(proc.BookText))
						Panels[i].SetBookInfo(proc.BookText);

					if (proc.Result != ProcessBookResult.None)
					{
						Panels[i].SetResult(proc.Result);
						return;
					}

					if (propertyName is null or nameof(proc.Status))
						Panels[i].SetStatus(proc.Status);
					if (propertyName is null or nameof(proc.Progress))
						Panels[i].SetProgrss(proc.Progress);
					if (propertyName is null or nameof(proc.TimeRemaining))
						Panels[i].SetRemainingTime(proc.TimeRemaining);
					Panels[i].ResumeLayout();
				});
			}
			catch (Exception ex)
			{
				Serilog.Log.Logger.Error(ex, "Error updating the queued item's display.");
			}
		}

		private void UpdateAllControls()
		{
			int numToShow = Math.Min(NumVisible, Queue.Count - FirstVisible);

			for (int i = 0; i < numToShow; i++)
				UpdateControl(FirstVisible + i);
		}


		/// <summary>
		/// View notified the model that a botton was clicked
		/// </summary>
		/// <param name="queueIndex">index of the <see cref="ProcessBook"/> within <see cref="Queue"/></param>
		/// <param name="panelClicked">The clicked control to update</param>
		private async void VirtualFlowControl2_ButtonClicked(int queueIndex, string buttonName, ProcessBookControl panelClicked)
		{
			try
			{
				ProcessBook item = Queue[queueIndex];
				if (buttonName == nameof(panelClicked.cancelBtn))
				{
					if (item is not null)
						await item.CancelAsync();
					Queue.RemoveQueued(item);
					virtualFlowControl2.VirtualControlCount = Queue.Count;
				}
				else if (buttonName == nameof(panelClicked.moveFirstBtn))
				{
					Queue.MoveQueuePosition(item, QueuePosition.Fisrt);
					UpdateAllControls();
				}
				else if (buttonName == nameof(panelClicked.moveUpBtn))
				{
					Queue.MoveQueuePosition(item, QueuePosition.OneUp);
					UpdateControl(queueIndex);
					if (queueIndex > 0)
						UpdateControl(queueIndex - 1);
				}
				else if (buttonName == nameof(panelClicked.moveDownBtn))
				{
					Queue.MoveQueuePosition(item, QueuePosition.OneDown);
					UpdateControl(queueIndex);
					if (queueIndex + 1 < Queue.Count)
						UpdateControl(queueIndex + 1);
				}
				else if (buttonName == nameof(panelClicked.moveLastBtn))
				{
					Queue.MoveQueuePosition(item, QueuePosition.Last);
					UpdateAllControls();
				}
			}
			catch(Exception ex)
			{
				Serilog.Log.Logger.Error(ex, "Error handling button click from queued item");
			}
		}

		/// <summary>
		/// View needs updating
		/// </summary>
		private void VirtualFlowControl1_RequestData(int firstIndex, int numVisible, IReadOnlyList<ProcessBookControl> panelsToFill)
		{
			FirstVisible = firstIndex;
			NumVisible = numVisible;
			Panels = panelsToFill;
			UpdateAllControls();
		}

		/// <summary>
		/// Model updates the view
		/// </summary>
		private void Pbook_DataAvailable(object sender, PropertyChangedEventArgs e)
		{
			int index = Queue.IndexOf((ProcessBook)sender);
			UpdateControl(index, e.PropertyName);
		}

		#endregion

		private void numericUpDown1_ValueChanged(object sender, EventArgs e)
		{
			var newValue = (long)(numericUpDown1.Value * 1024 * 1024);

			var config = Configuration.Instance;
			config.DownloadSpeedLimit = newValue;
			if (config.DownloadSpeedLimit > newValue)
				numericUpDown1.Value =
					numericUpDown1.Value == 0.01m ? config.DownloadSpeedLimit / 1024m / 1024
					: 0;

			numericUpDown1.Increment =
				numericUpDown1.Value > 100 ? 10
				: numericUpDown1.Value > 10 ? 1
				: numericUpDown1.Value > 1 ? 0.1m
				: 0.01m;

			numericUpDown1.DecimalPlaces =
				numericUpDown1.Value >= 10 ? 0
				: numericUpDown1.Value >= 1 ? 1
				: 2;
		}
	}
	public class NumericUpDownSuffix : NumericUpDown
	{
		[Description("Suffix displayed after numeric value."), Category("Data")]
		[Browsable(true)]
		[EditorBrowsable(EditorBrowsableState.Always)]
		[DisallowNull]
		public string Suffix
		{
			get => _suffix;
			set
			{
				base.Text = string.IsNullOrEmpty(_suffix) ? base.Text : base.Text.Replace(_suffix, value);
				_suffix = value;
				ChangingText = true;
			}
		}
		private string _suffix = string.Empty;
		public override string Text
		{
			get => string.IsNullOrEmpty(Suffix) ? base.Text : base.Text.Replace(Suffix, string.Empty);
			set
			{
				if (Value == Minimum)
					base.Text = "∞";
				else
					base.Text = value + Suffix;
			}
		}
	}
}