//
// ElementTest.cs: NUnit Test Suite for gstreamer-sharp
//
// Authors:
//   Khaled Mohammed (khaled.mohammed@gmail.com)
//
// (C) 2006 Novell, Inc.
//

using System;
using NUnit.Framework;
using Gst;
using Gst.GLib;

[TestFixture]
public class ElementTest 
{
	[TestFixtureSetUp]
	public void Init() 
	{
		Application.Init();
	}

	[Test]
	public void TestLinkNoPads() 
	{
		Element src = new Bin("src");
		Element sink = new Bin("sink");

		Assert.IsFalse(src.Link(sink));
		Assert.IsFalse(Element.Link(src, sink));
	}

	public class PadAddElement : Gst.Element {
		public PadAddElement () : base () {
			Pad pad = new Pad("source", PadDirection.Src);
			CollectionAssert.IsEmpty(Pads);

			AddPad(pad);
			Assert.AreEqual(pad, GetStaticPad("source"));
			CollectionAssert.Contains(Pads, pad);

			RemovePad(pad);
			Assert.IsNull(GetStaticPad("source"));
			CollectionAssert.IsEmpty(Pads);
		}
	}

	[Test]
	public void TestAddRemovePad()
	{
		new PadAddElement ();
	}

	[Test]
	public void TestLink()
	{
		State state, pending;

		Element source = ElementFactory.Make("fakesrc", "source");
		Assert.IsNotNull(source);
		Element sink = ElementFactory.Make("fakesink", "sink");
		Assert.IsNotNull(sink);

		Assert.IsTrue(source.LinkPads("src", sink, "sink"));

		sink.SetState(State.Paused);
		source.SetState(State.Paused);
		sink.GetState(out state, out pending, Clock.TimeNone);
		Assert.AreEqual(state, State.Paused);

		sink.SetState(State.Playing);
		source.SetState(State.Playing);
		source.GetState(out state, out pending, Clock.TimeNone);
		Assert.AreEqual(state, State.Playing);

		sink.SetState(State.Null);
		source.SetState(State.Null);
		sink.GetState(out state, out pending, Clock.TimeNone);
		Assert.AreEqual(state, State.Null);

		Assert.AreEqual(source.GetStaticPad("src").Peer, sink.GetStaticPad("sink"));
		source.Unlink(sink);
		Assert.IsFalse(source.GetStaticPad("src").IsLinked);
	}
	
	public class TestSubclassesApp {
		static MainLoop loop;

		public class MySrc : Gst.Element {
			public MySrc () : base () {
				Init ();
			}
			
			public MySrc (IntPtr raw) : base (raw) {
				Init ();
			}
			
			private Pad src;
			private uint nbuffers = 0;
			
			private void Init () {
				src = new Pad (templ, "src");
				AddPad (src);
			}
			
			static Caps caps = Caps.FromString ("my/dummy-data");
			
			private void loop () {
				Gst.Buffer buf = new Gst.Buffer ();
				buf.Caps = caps;
				Gst.FlowReturn ret = src.Push (buf);
				nbuffers++;
				
				Assert.AreEqual (ret, Gst.FlowReturn.Ok);
				if (ret != Gst.FlowReturn.Ok) {
					src.StopTask ();
					this.PostMessage (Message.NewError (this, CoreError.Failed, "Oh no"));
				}

				if (nbuffers == 10) {
					Assert.IsTrue (src.PushEvent (Gst.Event.NewEos ()));
					src.PauseTask ();
				}
			}
			
			protected override StateChangeReturn OnChangeState (StateChange transition) {
				if (transition == StateChange.ReadyToPaused)
					src.StartTask (loop);
				else if (transition == StateChange.PausedToReady)
					src.StopTask ();
			
				return StateChangeReturn.Success;
			}
			
			static PadTemplate templ = new PadTemplate ("src", Gst.PadDirection.Src, Gst.PadPresence.Always, Caps.FromString ("my/dummy-data"));
			
			public static bool Register () {
				SetDetails ( (GType) typeof (MySrc), "long", "klass", "desc", "author");
				AddPadTemplate ( (GType) typeof (MySrc), templ);
				return ElementFactory.Register (null, "mysrc", (uint) Gst.Rank.None, (GType) typeof (MySrc));
			}
		}
		
		public class MySink : Gst.Element {
			public MySink () : base () {
				Init ();
			}
			
			public MySink (IntPtr raw) : base (raw) {
				Init ();
			}
			
			Gst.FlowReturn on_chain (Gst.Pad pad, Gst.Buffer buffer) {
				Assert.IsNotNull (buffer);
				return Gst.FlowReturn.Ok;
			}

			bool on_event (Gst.Pad pad, Gst.Event evnt) {
				if (evnt.Type == Gst.EventType.Eos) {
					this.PostMessage (Message.NewEos (this));
				}

				return true;
			}
			
			private void Init () {
				Pad pad = new Pad (templ, "sink");
				pad.ChainFunction = on_chain;
				pad.EventFunction = on_event;
				AddPad (pad);
			}
			
			static PadTemplate templ = new PadTemplate ("sink", Gst.PadDirection.Sink, Gst.PadPresence.Always, Caps.FromString ("my/dummy-data"));
			
			public static bool Register () {
				SetDetails ( (GType) typeof (MySink), "long", "klass", "desc", "author");
				AddPadTemplate ( (GType) typeof (MySink), templ);
				
				return ElementFactory.Register (null, "mysink", (uint) Gst.Rank.None, (GType) typeof (MySink));
			}
		}

		private static bool BusCb (Bus bus, Message message) {
			switch (message.Type) {
				case MessageType.Error:
					Enum err;
					string msg;
					
					message.ParseError (out err, out msg);
					Assert.Fail (String.Format ("Error message: {0}", msg));
					loop.Quit ();
					break;
				case MessageType.Eos:
					loop.Quit ();
					break;
			}
			return true;
		}
		
		public static void Run () {
		
			MySrc.Register ();
			MySink.Register ();
			
			MySrc mysrc = Gst.ElementFactory.Make ("mysrc") as MySrc;
			MySink mysink = Gst.ElementFactory.Make ("mysink") as MySink;
			
			Gst.Pipeline pipeline = new Pipeline ("pipeline");
			pipeline.Add (mysrc, mysink);
			Assert.IsTrue (mysrc.Link (mysink));
			
			loop = new MainLoop ();
			
			pipeline.Bus.AddWatch (new BusFunc (BusCb));
			pipeline.SetState (Gst.State.Playing);
			
			loop.Run ();

			pipeline.SetState (Gst.State.Null);
		}
	}

	[Test]
	public void TestSubclasses ()
	{
		TestSubclassesApp.Run ();			
	}
}