using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Threading;


namespace DMX2
{
	public class Conduite : IComparer<Circuit>, IDisposable
	{

		public static Conduite Courante = null;

		Timer timer = null;
		DateTime dernierTick;
		DateTime derniereMaj;
		string _name;
		int master=100;

		List<Circuit> circuits = new List<Circuit>();
		List<UniversDMX> univers = new List<UniversDMX>();

		List<DriverDMX> drivers = new List<DriverDMX>();


		public Conduite()
		{
			timer = new Timer(new TimerCallback(TimerTick),this, 1000,10);
			derniereMaj = dernierTick=DateTime.Now;

			// Crée l'univers par défaut
			var u = new UniversDMX();
			Patches.Add(u);
			u.Nom = "Univers par Défaut";
		}


		public ReadOnlyCollection<Circuit> Circuits {
			get {
				return circuits.AsReadOnly();
			}
		}

		public Circuit NouveauCircuit ()
		{
			lock (this) {
				Circuit c = new	Circuit ();
				circuits.Add (c);
				return c;
			}
		}

		public void SupprimeCircuits (IEnumerable<Circuit> lc)
		{
			lock (this) {
				foreach(var c in lc)
					circuits.Remove (c);
				foreach(var seq in Sequenceurs)
					seq.MajCircuitsSupprimes();
			}
		}


		public string Name {
			get {
				return _name;
			}
			set {
				_name = value;
			}
		}

		public int Master {
			get {
				return master;
			}
			set {
				master= value;
			}
		}

		public List<DriverDMX> Drivers {
			get {
				return drivers;
			}
		}

		int IComparer<Circuit>.Compare (Circuit x, Circuit y)
		{
				return Conduite.Courante.circuits.IndexOf(x) -
					Conduite.Courante.circuits.IndexOf(y);
		}

		List<Sequenceur> sequenceurs= new List<Sequenceur>();

		public ReadOnlyCollection<Sequenceur> Sequenceurs {
			get {
				return sequenceurs.AsReadOnly();
			}
		}

		public void AjoutSequenceur (Sequenceur seq)
		{
			lock (this) {
				sequenceurs.Add(seq);
			}
		}

		public List<UniversDMX> Patches {
			get {
				return univers;
			}
		}

		static public void TimerTick (object state)
		{
			Conduite.Courante.Tick();
		}

		void Tick ()
		{
			DateTime tickTime = DateTime.Now;
			TimeSpan deltaT = tickTime - dernierTick;
			dernierTick = tickTime;

			lock (this) {
				// 'Actionne' les sequenceurs
				foreach (var seq in sequenceurs) {
					seq.Tick (deltaT);				
				}

				// Mets a jour les valeurs circuits.
				foreach (var c in circuits) {
					int val = 0;
					foreach (var seq in Sequenceurs) {
						val = Math.Max (val, seq.ValeurCircuit (c));
					}
					c.ValeurCourante = val * master /100;
				}
			}
			// Cette fonction retourne quasi immédiatement, même si il y'a beaucoup a faire sur l'affichage

			if(tickTime - derniereMaj > TimeSpan.FromMilliseconds(50)){
				MainWindow.Win.ScheduleUpdate();
				derniereMaj = DateTime.Now;
			}


			if( deltaT > TimeSpan.FromMilliseconds(15) )
				Console.WriteLine ("{0} {1}", DateTime.Now - tickTime,deltaT);
		}

		#region IDisposable implementation
		bool disposed=false;

		public void Dispose()
		{
			disposed=true;
			if(timer!=null)
				timer.Dispose();
			foreach(var driver in Drivers)
				driver.Dispose();
			timer=null;
		}

		void IDisposable.Dispose ()
		{
			if(!disposed)
				Dispose();
		}
		#endregion


	}

	public class Circuit
	{
		static int maxid=1;
		string name;

		public const int SNLen= 8;

		public Circuit()
		{
			id=maxid++;
			Name = "Circuit n°" + id.ToString();
			ShortName = "Cir" + id.ToString();
		}

		public string Name {
			get {
				return name;
			}
			set {
				name = value;
			}
		}

		string shortName;

		public string ShortName {
			get {
				return shortName;
			}
			set {
				if (value.Length > SNLen)
					shortName = value.Substring(0,SNLen);
				else
					shortName = value;
			}
		}

		int id;

		public int ID {
			get {
				return id;
			}
		}

		int _curval;

		public int ValeurCourante {
			get {
				return _curval;
			}
			set {
				_curval = value;
			}
		}

	}


}