/*

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

  Copyright (C) 2009-2012 Michael Möller <mmoeller@openhardwaremonitor.org>

*/

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Text;

using System.Diagnostics;

using System.Windows.Forms;

using System.Windows;

using OpenHardwareMonitor.Hardware;

using OpenHardwareMonitor.Utilities;

using System.Runtime.InteropServices;

using UacHelpers;

using System.ServiceModel;

using SharpDisplay;

namespace OpenHardwareMonitor.GUI

{

    public class SharpDisplay : ICallback, IDisposable

    {

        private IComputer computer;

        private PersistentSettings settings;

        private UnitManager unitManager;

        private List<SensorSharpDisplay> list = new List<SensorSharpDisplay>();

        private global::SharpDisplay.Client iClient;

        TextField iTextFieldTop;

        TextField iTextFieldBottom;

        TextField[] iTextFields;

        private int iNextSensorToDisplay = 0;

        private int iTickCounter = 0;

        public SharpDisplay(IComputer computer, PersistentSettings settings, UnitManager unitManager)

        {

            this.computer = computer;

            this.settings = settings;

            this.unitManager = unitManager;

            computer.HardwareAdded += new HardwareEventHandler(HardwareAdded);

            computer.HardwareRemoved += new HardwareEventHandler(HardwareRemoved);

            //Connect our client

            //Instance context is then managed by our client class

            iClient = new global::SharpDisplay.Client(this);

            //

            iTextFieldTop = new TextField(0);

            iTextFieldBottom = new TextField(1);

            iTextFields = new TextField[] { iTextFieldTop, iTextFieldBottom };

        }

        //From ICallback

        public void OnConnected()

        {

            //Debug.Assert(Thread.CurrentThread.IsThreadPoolThread);

            //Trace.WriteLine("Callback thread = " + Thread.CurrentThread.ManagedThreadId);

            //MessageBox.Show("OnConnected()", "Client");

        }

        //From ICallback

        public void OnCloseOrder()

        {

            iClient.Close();

        }

        private void HardwareRemoved(IHardware hardware)

        {

            hardware.SensorAdded -= new SensorEventHandler(SensorAdded);

            hardware.SensorRemoved -= new SensorEventHandler(SensorRemoved);

            foreach (ISensor sensor in hardware.Sensors)

                SensorRemoved(sensor);

            foreach (IHardware subHardware in hardware.SubHardware)

                HardwareRemoved(subHardware);

        }

        private void HardwareAdded(IHardware hardware)

        {

            foreach (ISensor sensor in hardware.Sensors)

                SensorAdded(sensor);

            hardware.SensorAdded += new SensorEventHandler(SensorAdded);

            hardware.SensorRemoved += new SensorEventHandler(SensorRemoved);

            foreach (IHardware subHardware in hardware.SubHardware)

                HardwareAdded(subHardware);

        }

        private void SensorAdded(ISensor sensor)

        {

            if (settings.GetValue(new Identifier(sensor.Identifier,

              "SharpDisplay").ToString(), false))

                Add(sensor, false);

        }

        private void SensorRemoved(ISensor sensor)

        {

            if (Contains(sensor))

                Remove(sensor, false);

        }

        public void Dispose()

        {

            foreach (SensorSharpDisplay icon in list)

                icon.Dispose();

            Quit();            

            //iServer.Stop();

            iClient.Close();

        }

        public void Redraw(bool aPacked, bool aDisplayTime)

        {

            const int KNumberOfTickBeforeSwitch = 4;

            const int KMaxCharacterPerLine = 16;

            string packedFirstLine = ""; //We have 16 chars per line on our VFD

            string packedSecondLine = "";

            int count = 0;

            string time = DateTime.Now.ToShortTimeString();

            //Update all sensors from our front view

            foreach (SensorSharpDisplay sensor in list)

            {

                count++;

                sensor.Update();

                if (aDisplayTime && count == 1)

                {

                    //First slot is take by time display

                    count++;

                    packedFirstLine = time + " ";

                }

                if (aPacked)

                {

                    //Build strings for packed mode

                    string packedText = "";

                    packedText = sensor.iFirstLine.Substring(0, 3) + ":" + sensor.iSecondLine;

                    if (count == 1)

                    {

                        packedFirstLine = packedText + " "; //Minimum one space to separate sensors on the same line

                    }

                    else if (count == 2)

                    {

                        //Add enough spaces to align to right hand side

                        while (packedFirstLine.Length + packedText.Length < KMaxCharacterPerLine)

                        {

                            packedFirstLine += " ";

                        }

                        packedFirstLine += packedText;

                    }

                    else if (count == 3)

                    {

                        packedSecondLine = packedText + " "; //Minimum one space to separate sensors on the same line

                    }

                    else if (count == 4)

                    {

                        //Add enough spaces to align to right hand side

                        while (packedSecondLine.Length + packedText.Length < KMaxCharacterPerLine)

                        {

                            packedSecondLine += " ";

                        }

                        packedSecondLine += packedText;

                    }

                }

                //SetText(sensor.iFirstLine, sensor.iSecondLine);

            }

            //Alternate between sensors 

            if (list.Count > 0)

            {

                if (aPacked)

                {

                    //string packedLine = "";

                    iTickCounter++;

                    if (iTickCounter == KNumberOfTickBeforeSwitch) //Move to the next sensor only every so many tick

                    {

                        iTickCounter = 0;

                        if (iNextSensorToDisplay == 1)

                        {

                            iNextSensorToDisplay = 0;

                        }

                        else

                        {

                            iNextSensorToDisplay = 1;

                        }

                    }

                    //TODO: Do something like that to cycle lines if ever we want to

                    //SetText(time, (iNextSensorToDisplay == 1 && packedSecondLine.Length > 0 ? packedSecondLine : packedFirstLine));

                    //Display packed sensors on our FrontView display

                    SetText(packedFirstLine, packedSecondLine);

                }

                else

                {

                    string secondLine = list[iNextSensorToDisplay].iSecondLine;

                    if (aDisplayTime)

                    {

                        //Add enough spaces

                        while (secondLine.Length + time.Length < KMaxCharacterPerLine)

                        {

                            secondLine += " ";

                        }

                        secondLine += time;

                    }

                    //Display current sensor on our FrontView display

                    SetText(list[iNextSensorToDisplay].iFirstLine, secondLine);

                    iTickCounter++;

                    if (iTickCounter == KNumberOfTickBeforeSwitch) //Move to the next sensor only every so many tick

                    {

                        iTickCounter = 0;

                        iNextSensorToDisplay++;

                    }

                }

            }

            if (iNextSensorToDisplay == list.Count)

            {

                //Go back to first sensor

                iNextSensorToDisplay = 0;

            }

        }

        public bool Contains(ISensor sensor)

        {

            foreach (SensorSharpDisplay icon in list)

                if (icon.Sensor == sensor)

                    return true;

            return false;

        }

        public void Add(ISensor sensor, bool balloonTip)

        {

            if (Contains(sensor))

            {

                return;

            }

            else

            {

                //SL:

                list.Add(new SensorSharpDisplay(this, sensor, balloonTip, settings, unitManager));

                //UpdateMainIconVisibilty();

                settings.SetValue(new Identifier(sensor.Identifier, "SharpDisplay").ToString(), true);

                iNextSensorToDisplay = 0;

                if (list.Count == 1)

                {

                    //Just added first sensor in FrontView, unable FrontView plug-in mode

                    Init();

                }

            }

        }

        public void Remove(ISensor sensor)

        {

            Remove(sensor, true);

            iNextSensorToDisplay = 0;

            if (list.Count == 0)

            {

                //No sensor to display in FrontView, just disable FrontView plug-in mode

                Uninit();

            }

        }

        private void Remove(ISensor sensor, bool deleteConfig)

        {

            if (deleteConfig)

            {

                settings.Remove(

                  new Identifier(sensor.Identifier, "SharpDisplay").ToString());

            }

            SensorSharpDisplay instance = null;

            foreach (SensorSharpDisplay icon in list)

                if (icon.Sensor == sensor)

                    instance = icon;

            if (instance != null)

            {

                list.Remove(instance);

                //UpdateMainIconVisibilty();

                instance.Dispose();

            }

        }

        private void UpdateMainIconVisibilty()

        {

            /*

            if (mainIconEnabled)

            {

                mainIcon.Visible = list.Count == 0;

            }

            else

            {

                mainIcon.Visible = false;

            }

             */

        }

        public void Init()

        {

            //iServer.SendMessage("init:");

        }

        public void Uninit()

        {

            //iServer.SendMessage("uninit:");

        }

        public void SetText(string aUpperLine, string aLowerLine)

        {

            //iServer.SendMessage("set-vfd-text:" + aUpperLine + "\n" + aLowerLine);

            iTextFieldTop.Text = aUpperLine;

            iTextFieldBottom.Text = aLowerLine;

            iClient.SetTexts(iTextFields);

        }

        public void Quit()

        {

            //iServer.SendMessage("quit:");

        }

        /*

        public bool IsMainIconEnabled

        {

            get { return mainIconEnabled; }

            set

            {

                if (mainIconEnabled != value)

                {

                    mainIconEnabled = value;

                    UpdateMainIconVisibilty();

                }

            }

        }*/

    }

}