//

// Copyright (C) 2014-2015 Stéphane Lenclud.

//

// This file is part of SharpDisplayManager.

//

// SharpDisplayManager is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// SharpDisplayManager is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with SharpDisplayManager.  If not, see <http://www.gnu.org/licenses/>.

//

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

//

using System.Runtime.InteropServices;

//using System.Runtime.Serialization;

using MiniDisplayInterop;

namespace SharpDisplayManager

{

    /// <summary>

    /// Provide access to our display hardware through MiniDisplay API.

    /// </summary>

    public class Display

    {

		public delegate void OnOpenedHandler(Display aDisplay);

		public event OnOpenedHandler OnOpened;

		public delegate void OnClosedHandler(Display aDisplay);

		public event OnClosedHandler OnClosed;

		//Our display device handle

		IntPtr iDevice;

		//static functions

		public static int TypeCount()

		{

			return MiniDisplay.TypeCount();

		}

		public static string TypeName(MiniDisplay.Type aType)

		{

			IntPtr ptr = MiniDisplay.TypeName(aType);

			string str = Marshal.PtrToStringUni(ptr);

			return str;

		}

        //Constructor

        public Display()

        {

            iDevice = IntPtr.Zero;

        }

        //

        public bool Open(MiniDisplay.Type aType)

        {

			if (IsOpen())

			{

				//Already open return an error

				return false;

			}

            iDevice = MiniDisplay.Open(aType);

            bool success = iDevice != IntPtr.Zero;

			if (success)

			{

				//Broadcast opened event

				OnOpened(this);

			}

			return success;

        }

        public void Close()

        {

			if (!IsOpen())

			{

				//Pointless

				return;

			}

			//

            MiniDisplay.Close(iDevice);

            iDevice = IntPtr.Zero;

			//Broadcast closed event

			OnClosed(this);

        }

        public bool IsOpen()

        {

            return iDevice != IntPtr.Zero;

        }

        public void Clear()

        {

            MiniDisplay.Clear(iDevice);

        }

        public void Fill()

        {

            MiniDisplay.Fill(iDevice);

        }

        public void SwapBuffers()

        {

            MiniDisplay.SwapBuffers(iDevice);

        }

        public int MaxBrightness()

        {

            return MiniDisplay.MaxBrightness(iDevice);

        }

        public int MinBrightness()

        {

            return MiniDisplay.MinBrightness(iDevice);

        }

        public void SetBrightness(int aBrightness)

        {

            if (!IsOpen()) return;

            MiniDisplay.SetBrightness(iDevice, aBrightness);

        }

        public int WidthInPixels()

        {

            return MiniDisplay.WidthInPixels(iDevice);

        }

        public int HeightInPixels()

        {

            return MiniDisplay.HeightInPixels(iDevice);

        }

        public void SetPixel(int aX, int aY, uint aValue)

        {

            MiniDisplay.SetPixel(iDevice,aX,aY,aValue);

        }

        public void RequestPowerSupplyStatus()

        {

            MiniDisplay.SendRequest(iDevice, MiniDisplay.Request.PowerSupplyStatus);

        }

        public void RequestDeviceId()

        {

            MiniDisplay.SendRequest(iDevice, MiniDisplay.Request.DeviceId);

        }

        public void RequestFirmwareRevision()

        {

            MiniDisplay.SendRequest(iDevice, MiniDisplay.Request.FirmwareRevision);

        }

        public void PowerOn()

        {

            MiniDisplay.PowerOn(iDevice);

        }

        public void PowerOff()

        {

            MiniDisplay.PowerOff(iDevice);

        }

        public bool SupportPowerOnOff()

        {

            return MiniDisplay.SupportPowerOnOff(iDevice);

        }

        public void ShowClock()

        {

            MiniDisplay.ShowClock(iDevice);

        }

        public void HideClock()

        {

            MiniDisplay.HideClock(iDevice);

        }

        public bool SupportClock()

        {

            return MiniDisplay.SupportClock(iDevice);

        }

        public bool PowerSupplyStatus()

        {

            bool res = MiniDisplay.PowerSupplyStatus(iDevice);

            return res;

        }

        public MiniDisplay.Request AttemptRequestCompletion()

        {

            return MiniDisplay.AttemptRequestCompletion(iDevice);

        }

        public MiniDisplay.Request CurrentRequest()

        {

            return MiniDisplay.CurrentRequest(iDevice);

        }

        public bool IsRequestPending()

        {

            return CurrentRequest() != MiniDisplay.Request.None;

        }

		//

		public int IconCount(MiniDisplay.IconType aIcon)

		{

			return MiniDisplay.IconCount(iDevice,aIcon);

		}

		public int IconStatusCount(MiniDisplay.IconType aIcon)

		{

			return MiniDisplay.IconStatusCount(iDevice, aIcon);

		}

		public void SetIconStatus(MiniDisplay.IconType aIcon, int aIndex, int aStatus)

		{

			MiniDisplay.SetIconStatus(iDevice, aIcon, aIndex, aStatus);

		}

		public void SetIconOn(MiniDisplay.IconType aIcon, int aIndex)

		{

			MiniDisplay.SetIconStatus(iDevice, aIcon, aIndex, IconStatusCount(aIcon) - 1);

		}

		public void SetIconOff(MiniDisplay.IconType aIcon, int aIndex)

		{

			MiniDisplay.SetIconStatus(iDevice, aIcon, aIndex, 0);

		}

		public void SetAllIconsStatus(int aStatus)

		{

			foreach (MiniDisplay.IconType icon in Enum.GetValues(typeof(MiniDisplay.IconType)))

			{

				int count=IconCount(icon);

				for (int i = 0; i < count; i++)

				{

					SetIconStatus(icon,i,aStatus);

				}

			}

		}

		/// <summary>

		/// Set all elements of an icon to the given status.

		/// </summary>

		/// <param name="aIcon"></param>

		/// <param name="aStatus"></param>

		public void SetIconStatus(MiniDisplay.IconType aIcon, int aStatus)

		{

			int iconCount = IconCount(aIcon);

			for (int i = 0; i < iconCount; i++)

			{

				SetIconStatus(aIcon, i, aStatus);

			}

		}

		/// <summary>

		/// Set all elements of an icon to be either on or off.

		/// </summary>

		/// <param name="aIcon"></param>

		/// <param name="aOn"></param>		

		public void SetIconOnOff(MiniDisplay.IconType aIcon, bool aOn)

		{

			if (aOn)

			{

				SetIconOn(aIcon);

			}

			else

			{

				SetIconOff(aIcon);

			}

		}

		/// <summary>

		/// Set all elements of an icon to there maximum status.

		/// </summary>

		/// <param name="aIcon"></param>

		public void SetIconOn(MiniDisplay.IconType aIcon)

		{

			int iconCount = IconCount(aIcon);

			for (int i = 0; i < iconCount; i++)

			{

				SetIconStatus(aIcon, i, IconStatusCount(aIcon) - 1);

			}

		}

		/// <summary>

		/// Turn off all elements of an icon.

		/// </summary>

		/// <param name="aIcon"></param>

		public void SetIconOff(MiniDisplay.IconType aIcon)

		{

			int iconCount = IconCount(aIcon);

			for (int i = 0; i < iconCount; i++)

			{

				SetIconStatus(aIcon, i, 0);

			}

		}

        public string Vendor()

        {

            IntPtr ptr = MiniDisplay.Vendor(iDevice);

            string str = Marshal.PtrToStringUni(ptr);

            return str;

        }

        public string Product()

        {

            IntPtr ptr = MiniDisplay.Product(iDevice);

            string str = Marshal.PtrToStringUni(ptr);

            return str;

        }

        public string SerialNumber()

        {

            IntPtr ptr = MiniDisplay.SerialNumber(iDevice);

            string str = Marshal.PtrToStringUni(ptr);

            return str;

        }

        public string DeviceId()

        {

            IntPtr ptr = MiniDisplay.DeviceId(iDevice);

            string str = Marshal.PtrToStringAnsi(ptr);

            return str;

        }

        public string FirmwareRevision()

        {

            IntPtr ptr = MiniDisplay.FirmwareRevision(iDevice);

            string str = Marshal.PtrToStringAnsi(ptr);

            return str;

        }

    }

}