//

// 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.Windows.Forms;

using SharpDisplay;

using System.ServiceModel;

using System.ServiceModel.Channels;

namespace SharpDisplayClient

{

    /// <summary>

    /// Client side Sharp Display callback implementation.

    /// </summary>

    [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]

    public class Callback : ICallback, IDisposable

    {

        private MainForm MainForm { get; set; }

        public Callback(MainForm aMainForm)

        {

            MainForm = aMainForm;

        }

        /// <summary>

        /// Not used I believe.

        /// </summary>

        public void OnConnected()

        {

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

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

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

        }

        public void OnCloseOrder()

        {

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

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

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

            MainForm.CloseConnectionThreadSafe();

            MainForm.CloseThreadSafe();

        }

        //From IDisposable

        public void Dispose()

        {

        }

    }

    /// <summary>

    /// Client side implementation of our Sharp Display Service.

    /// </summary>

    [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]

    public class Client : DuplexClientBase<IService>

    {

        public string SessionId { get { return InnerChannel.SessionId; } }

        public Client(ICallback aCallback)

            : base(new InstanceContext(aCallback), new NetTcpBinding(SecurityMode.None, true), new EndpointAddress("net.tcp://localhost:8001/DisplayService"))

        { }

        public void SetName(string aClientName)

        {

            Channel.SetName(aClientName);

        }

        public void SetLayout(TableLayout aLayout)

        {

            Channel.SetLayout(aLayout);

        }

        public void SetField(DataField aField)

        {

            Channel.SetField(aField);

        }

        public void SetFields(System.Collections.Generic.IList<DataField> aFields)

        {

            Channel.SetFields(aFields);

        }

        public int ClientCount()

        {

            return Channel.ClientCount();

        }

        public bool IsReady()

        {

            return State == CommunicationState.Opened || State == CommunicationState.Created;

        }

    }

    /// <summary>

    /// Handle connection with our Sharp Display Server.

    /// If the connection is faulted it will attempt to restart it.

    /// </summary>

    public class DisplayClient

    {

        private Client iClient;

        private Callback iCallback;

        private bool resetingConnection = false;

        private MainForm MainForm { get; set; }

        public string SessionId { get { return iClient.SessionId; } }

        public string Name { get; private set; }

        private TableLayout Layout { get; set; }

        private System.Collections.Generic.IList<DataField> Fields { get; set; }

        public DisplayClient(MainForm aMainForm)

        {

            MainForm = aMainForm;

            Name = "";

            Fields = new DataField[]{};

        }

        /// <summary>

        /// Initialize our server connection.

        /// </summary>

        public void Open()

        {

            iCallback = new Callback(MainForm);

            iClient = new Client(iCallback);

        }

        /// <summary>

        /// Terminate our server connection.

        /// </summary>

        public void Close()

        {

            iClient.Close();

            iClient = null;

            iCallback.Dispose();

            iCallback = null;

        }

        /// <summary>

        /// Tells whether a server connection is available.

        /// </summary>

        /// <returns>True if a server connection is available. False otherwise.</returns>

        public bool IsReady()

        {

            return (iClient != null && iCallback != null && iClient.IsReady());

        }

        /// <summary>

        /// Check if our server connection is available and attempt reset it if it isn't.

        /// This is notably dealing with timed out connections.

        /// </summary>

        public void CheckConnection()

        {

            if (!IsReady() && !resetingConnection)

            {

                //Try to reconnect

                Open();

                //Avoid stack overflow in case of persisting failure

                resetingConnection = true;

                try

                {

                    //On reconnect there is a bunch of properties we need to reset

                    if (Name != "")

                    {

                        iClient.SetName(Name);

                    }

                    SetLayout(Layout);

                    iClient.SetFields(Fields);

                }

                finally

                {

                    //Make sure our this state does not get out of sync

                    resetingConnection = true;

                }

            }

        }

        /// <summary>

        /// Set our client's name.

        /// Client's name is typically user friendly.

        /// It does not have to be unique.

        /// </summary>

        /// <param name="aClientName">Our client name.</param>

        public void SetName(string aClientName)

        {

            Name = aClientName;

            CheckConnection();

            iClient.SetName(aClientName);

        }

        /// <summary>

        /// Set your client fields' layout.

        /// </summary>

        /// <param name="aLayout">The layout to apply for this client.</param>

        public void SetLayout(TableLayout aLayout)

        {

            Layout = aLayout;

            CheckConnection();

            iClient.SetLayout(aLayout);

        }

        /// <summary>

        /// Set the specified field.

        /// </summary>

        /// <param name="aField"></param>

        /// <returns>True if the specified field was set client side. False means you need to redefine all your fields using CreateFields.</returns>

        public bool SetField(DataField aField)

        {

            int i = 0;

            bool fieldFound = false;

            foreach (DataField field in Fields)

            {

                if (field.Index == aField.Index)

                {

                    //Update our field then

                    Fields[i] = aField;

                    fieldFound = true;

                    break;

                }

                i++;

            }

            if (!fieldFound)

            {

                //Field not found, make sure to use CreateFields first after setting your layout.

                return false;

            }

            CheckConnection();

            iClient.SetField(aField);

            return true;

        }

        /// <summary>

        /// Use this function when updating existing fields.

        /// </summary>

        /// <param name="aFields"></param>

        public bool SetFields(System.Collections.Generic.IList<DataField> aFields)

        {

            int fieldFoundCount = 0;

            foreach (DataField fieldUpdate in aFields)

            {

                int i = 0;

                foreach (DataField existingField in Fields)

                {

                    if (existingField.Index == fieldUpdate.Index)

                    {

                        //Update our field then

                        Fields[i] = fieldUpdate;

                        fieldFoundCount++;

                        //Move on to the next field

                        break;

                    }

                    i++;

                }

            }

            //

            if (fieldFoundCount!=aFields.Count)

            {

                //Field not found, make sure to use CreateFields first after setting your layout.

                return false;

            }

            CheckConnection();

            iClient.SetFields(aFields);

            return true;

        }

        /// <summary>

        /// Use this function when creating your fields.

        /// This must be done at least once after setting your layout.

        /// </summary>

        /// <param name="aFields"></param>

        public void CreateFields(System.Collections.Generic.IList<DataField> aFields)

        {

            Fields = aFields;

            CheckConnection();

            iClient.SetFields(aFields);

        }

        /// <summary>

        /// Provide the number of clients currently connected to our server.

        /// </summary>

        /// <returns>Number of clients currently connected to our server.</returns>

        public int ClientCount()

        {

            CheckConnection();

            return iClient.ClientCount();

        }

    }

}