using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace DMX2
{
	public class SequenceurLineaire : Sequenceur
	{
		public class Effet
		{

			string _nom;

			public Effet (string nom, Dictionary<Circuit,int> valeurs, TimeSpan duree, TimeSpan transition)
			{
				_nom = nom;
				_valeurs = new Dictionary<Circuit, int> (valeurs);
				_duree = duree;
				_transition = transition;
			}

			public string Nom {
				get {
					return _nom;
				}
				set {
					_nom = value;
				}
			}

			Dictionary<Circuit,int> _valeurs;

			public int this [Circuit index] {
				get {
					if (!_valeurs.ContainsKey (index))
						_valeurs.Add (index, 0);
					return _valeurs [index];
				}
			}

			public void RetireCircuit (Circuit c)
			{
				_valeurs.Remove (c);
			}

			TimeSpan _duree = TimeSpan.Zero ;
			TimeSpan _transition = TimeSpan.Zero;

			public TimeSpan Duree {
				get {
					return _duree;
				}
				set {
					_duree = value;
				}
			}

			public TimeSpan Transition {
				get {
					return _transition;
				}
				set {
					_transition = value;
				}
			}
		}

		TimeSpan timeStamp = TimeSpan.Zero;
		List<Circuit> circuitsSeq = new List<Circuit> ();
		List<Effet> effets = new List<Effet> ();
		Effet effetcourrant = null;
		bool enTransition = false;
		Dictionary<Circuit,int> valeurscourantes = new Dictionary<Circuit, int> ();
		Dictionary<Circuit,int> valeursinitiales = new Dictionary<Circuit, int> ();
		Dictionary<Circuit,bool> valeurschangees = new Dictionary<Circuit, bool> ();
		SeqLinUI ui = null;

		public SequenceurLineaire ()
		{
			effetcourrant = new Effet ("",valeurscourantes  , TimeSpan.Zero, TimeSpan.Zero);
		}

		public SequenceurLineaire (int id) :base (id)
		{

		}



		public TimeSpan TimeStamp {
			get {
				return timeStamp;
			}
		}

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

		public ReadOnlyCollection<Effet> Effets {
			get {
				return effets.AsReadOnly ();
			}
		}

		public void ChangeCircuits (System.Collections.Generic.List<Circuit> list)
		{
			lock (this) {
				foreach (var c in circuitsSeq.ToArray()) {
					if (!list.Contains (c))
						RetireCircuit (c);
				}
				foreach (var c in list)
					if (!circuitsSeq.Contains (c))
						AjouteCircuit (c);
				circuitsSeq = list;
			}
		}

		void AjouteCircuit (Circuit c)
		{
			valeurscourantes [c] = 0;
			valeursinitiales [c] = 0;
		}

		private void RetireCircuit (Circuit c)
		{
			foreach (var ef in effets) {
				ef.RetireCircuit (c);
			}
			circuitsSeq.Remove (c);
			valeurscourantes.Remove (c);
			valeursinitiales.Remove (c);
		}

		public override void MajCircuitsSupprimes ()
		{
			lock (this) {
				foreach (var c in circuitsSeq.ToArray()) {
					if (!Conduite.Courante.Circuits.Contains (c))
						RetireCircuit (c);
				}
			}
		}

		public override int ValeurCircuit (Circuit c)
		{
			if (!circuitsSeq.Contains (c)) 
				return 0;
			return valeurscourantes [c];
		}

		public void ChangeValeur (Circuit c, int value)
		{
			valeurschangees [c] = true;
			valeurscourantes [c] = value;
		}

		public bool EstChange (Circuit c)
		{
			return valeurschangees.ContainsKey (c);
		}

		bool paused=false;

		public bool Paused {
			get {
				return paused;
			}
			set {
				paused = value;
			}
		}

		public override void Tick (TimeSpan time)
		{
			if (paused) return;
			timeStamp += time;
		
			if (enTransition) {
				if (timeStamp < effetcourrant.Transition) {
					double progression = timeStamp.TotalMilliseconds /  effetcourrant.Transition.TotalMilliseconds;
					foreach (Circuit c in circuitsSeq) {
						if (valeurscourantes [c] != effetcourrant [c] && !valeurschangees.ContainsKey (c)) {
							valeurscourantes [c] = (int)(progression * (effetcourrant [c] - valeursinitiales [c]) + valeursinitiales [c]);
						}
					}
				} else {
					FinDeTransition ();
				}
			}
			if (effetcourrant.Duree != TimeSpan.Zero &&  timeStamp >= effetcourrant.Duree) {
				int index = effets.IndexOf (effetcourrant) + 1;
				if (index < effets.Count)
					ChangeEffetCourrant (index);
			}
		}



		public void FinDeTransition ()
		{
			enTransition = false;
			foreach (Circuit c in circuitsSeq)
				if(!valeurschangees.ContainsKey (c))
					valeurscourantes [c] = effetcourrant [c];
		}


		public SequenceurLineaire.Effet EffetCourrant {
			get {
				return effetcourrant;
			}
		}

		public int IndexEffetCourrant {
			get {
				return effets.IndexOf(effetcourrant);
			}
			set {
				if(value>=0 && value < effets.Count)
					ChangeEffetCourrant(value);
			}
		}

		void ChangeEffetCourrant (int index)
		{
			effetcourrant = effets [index];
			valeurschangees.Clear ();
			valeursinitiales = new Dictionary<Circuit, int> (valeurscourantes);
			enTransition = true;
			timeStamp = TimeSpan.Zero;
		}

		public int SauveEffet (string nom, TimeSpan duree, TimeSpan transition)
		{
			lock (this) {
				effets.Add (new Effet (nom, valeurscourantes, duree, transition));
				return effets.Count-1;
			}
		}

		public override System.Xml.XmlElement Save ()
		{
			throw new System.NotImplementedException ();
		}


		public override SequenceurUI GetUI ()
		{

			if (ui == null) {
				ui = new SeqLinUI (this);
				ui.Destroyed += UiDestroyed;
			}

			return ui;
		}

		void UiDestroyed (object sender, EventArgs e)
		{
			ui = null;
		}
	}
}