using System;

using Microsoft.Win32.SafeHandles;

using System.Text;

using System.Runtime.InteropServices;

using System.Threading;

using System.IO;

using System.Diagnostics;

namespace SoundGraph

{

    public class Server

    {

        [DllImport("kernel32.dll", SetLastError = true)]

        public static extern SafeFileHandle CreateNamedPipe(

           String pipeName,

           uint dwOpenMode,

           uint dwPipeMode,

           uint nMaxInstances,

           uint nOutBufferSize,

           uint nInBufferSize,

           uint nDefaultTimeOut,

           IntPtr lpSecurityAttributes);

        [DllImport("kernel32.dll", SetLastError = true)]

        public static extern int ConnectNamedPipe(

           SafeFileHandle hNamedPipe,

           IntPtr lpOverlapped);

        [DllImport("kernel32.dll", SetLastError = true)]

        public static extern int DisconnectNamedPipe(

           SafeFileHandle hNamedPipe);

        public const uint PIPE_ACCESS_DUPLEX = (0x00000003);

        public const uint FILE_FLAG_OVERLAPPED = (0x40000000);

        public const uint PIPE_ACCESS_OUTBOUND = (0x00000002);

        public const uint PIPE_ACCESS_INBOUND = (0x00000001);

        public const uint PIPE_TYPE_BYTE = (0x00000000);

        public const uint PIPE_UNLIMITED_INSTANCES = 255;

        public const int BUFFER_SIZE = 256;

        //

        public string iPipeNameOutbound;

        Thread iThreadOutbound;

        SafeFileHandle iPipeOutbound;

        public FileStream iStreamOutbound;

        //

        public string iPipeNameInbound;

        Thread iThreadInbound;

        SafeFileHandle iPipeInbound;

        public FileStream iStreamInbound;

        public Server(string aPipeNameOutbound, string aPipeNameInbound)

        {

            iPipeNameOutbound = aPipeNameOutbound;

            iPipeNameInbound = aPipeNameInbound;

        }

        /**

         * Start our services.

         */

        public void Start()

        {

            //Start outbound thread to send messages

            this.iThreadOutbound = new Thread(new ThreadStart(ThreadOutbound));

            this.iThreadOutbound.Start();

            //Start inbound thread to receive messages

            this.iThreadInbound = new Thread(new ThreadStart(ThreadInbound));

            this.iThreadInbound.Start();

        }

        /**

         * Outbound thread is sending messages to our client.

         */

        private void ThreadOutbound()

        {

            //Create our outbound named pipe

            iPipeOutbound = CreateNamedPipe(this.iPipeNameOutbound, PIPE_ACCESS_OUTBOUND /*| FILE_FLAG_OVERLAPPED*/, PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, BUFFER_SIZE, BUFFER_SIZE, 0, IntPtr.Zero);

            //Could not create named pipe

            if (iPipeOutbound.IsInvalid)

            {

                //TODO: error handling

                return;

            }

            //Will complete once our client connects

            int success = ConnectNamedPipe(iPipeOutbound, IntPtr.Zero);

            //could not connect client

            if (success == 0)

            {

                //TODO: error handling

                return;

            }

            //Client now connected create our stream

            iStreamOutbound = new FileStream(iPipeOutbound, FileAccess.Write, BUFFER_SIZE, false);

        }

        /**

         * Inbound thread is receiving messages from our client

         */

        private void ThreadInbound()

        {

            //Client client = (Client)clientObj;

            //clientse.stream = new FileStream(clientse.handle, FileAccess.ReadWrite, BUFFER_SIZE, true);

            iPipeInbound = CreateNamedPipe(this.iPipeNameInbound, PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, BUFFER_SIZE, BUFFER_SIZE, 0, IntPtr.Zero);

            //could not create named pipe

            if (iPipeInbound.IsInvalid)

                return;

            //Will complete once a client connects

            int success = ConnectNamedPipe(iPipeInbound, IntPtr.Zero);

            //could not connect client

            if (success == 0)

                return;

            //Client now connected create our inbound stream

            iStreamInbound = new FileStream(iPipeInbound, FileAccess.Read, BUFFER_SIZE, false);

            byte[] buffer = null;

            ASCIIEncoding encoder = new ASCIIEncoding();

            while (true)

            {                

                int bytesRead = 0;

                try

                {

                    buffer = new byte[BUFFER_SIZE];

                    bytesRead = iStreamInbound.Read(buffer, 0, BUFFER_SIZE);

                }

                catch

                {

                    //read error has occurred

                    break;

                }

                //client has disconnected

                if (bytesRead == 0)

                    break;

                //fire message received event

                //if (this.MessageReceived != null)

                //    this.MessageReceived(clientse, encoder.GetString(buffer, 0, bytesRead));

                int ReadLength = 0;

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

                {

                    //if (buffer[i].ToString("x2") != "cc")

                    if (buffer[i] != 0)

                    {

                        ReadLength++;

                    }

                    else

                        break;

                }

                if (ReadLength > 0)

                {

                    byte[] Rc = new byte[ReadLength];

                    Buffer.BlockCopy(buffer, 0, Rc, 0, ReadLength);

                    Console.WriteLine(encoder.GetString(Rc, 0, ReadLength));

                    Trace.WriteLine("Received " + ReadLength + " Bytes: " + encoder.GetString(Rc, 0, ReadLength));

                    buffer.Initialize();

                }

            }

            //clean up resources

            iStreamInbound.Close();

            iPipeInbound.Close();            

        }

        /**

         * Send a message to our client.

         */

        public void SendMessage(string message)

        {

                ASCIIEncoding encoder = new ASCIIEncoding();

                byte[] messageBuffer = encoder.GetBytes(message);

                if (iStreamOutbound.CanWrite)

                {

                    iStreamOutbound.Write(messageBuffer, 0, messageBuffer.Length);

                    iStreamOutbound.Flush();

                }

        }

        /**

         * 

         */

        public void Stop()

        {

            //clean up resources

            DisconnectNamedPipe(this.iPipeOutbound);

            //TODO: more cleanup

            this.iThreadOutbound.Abort();

        }

    }

}