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

    {

        [Flags]

        public enum EFileAccess : uint

        {

            //

            // Standart Section

            //

            AccessSystemSecurity = 0x1000000,   // AccessSystemAcl access type

            MaximumAllowed = 0x2000000,     // MaximumAllowed access type

            Delete = 0x10000,

            ReadControl = 0x20000,

            WriteDAC = 0x40000,

            WriteOwner = 0x80000,

            Synchronize = 0x100000,

            StandardRightsRequired = 0xF0000,

            StandardRightsRead = ReadControl,

            StandardRightsWrite = ReadControl,

            StandardRightsExecute = ReadControl,

            StandardRightsAll = 0x1F0000,

            SpecificRightsAll = 0xFFFF,

            FILE_READ_DATA = 0x0001,        // file & pipe

            FILE_LIST_DIRECTORY = 0x0001,       // directory

            FILE_WRITE_DATA = 0x0002,       // file & pipe

            FILE_ADD_FILE = 0x0002,         // directory

            FILE_APPEND_DATA = 0x0004,      // file

            FILE_ADD_SUBDIRECTORY = 0x0004,     // directory

            FILE_CREATE_PIPE_INSTANCE = 0x0004, // named pipe

            FILE_READ_EA = 0x0008,          // file & directory

            FILE_WRITE_EA = 0x0010,         // file & directory

            FILE_EXECUTE = 0x0020,          // file

            FILE_TRAVERSE = 0x0020,         // directory

            FILE_DELETE_CHILD = 0x0040,     // directory

            FILE_READ_ATTRIBUTES = 0x0080,      // all

            FILE_WRITE_ATTRIBUTES = 0x0100,     // all

            //

            // Generic Section

            //

            GenericRead = 0x80000000,

            GenericWrite = 0x40000000,

            GenericExecute = 0x20000000,

            GenericAll = 0x10000000,

            SPECIFIC_RIGHTS_ALL = 0x00FFFF,

            FILE_ALL_ACCESS =

            StandardRightsRequired |

            Synchronize |

            0x1FF,

            FILE_GENERIC_READ =

            StandardRightsRead |

            FILE_READ_DATA |

            FILE_READ_ATTRIBUTES |

            FILE_READ_EA |

            Synchronize,

            FILE_GENERIC_WRITE =

            StandardRightsWrite |

            FILE_WRITE_DATA |

            FILE_WRITE_ATTRIBUTES |

            FILE_WRITE_EA |

            FILE_APPEND_DATA |

            Synchronize,

            FILE_GENERIC_EXECUTE =

            StandardRightsExecute |

              FILE_READ_ATTRIBUTES |

              FILE_EXECUTE |

              Synchronize

        }

        [Flags]

        public enum EFileShare : uint

        {

            /// <summary>

            /// 

            /// </summary>

            None = 0x00000000,

            /// <summary>

            /// Enables subsequent open operations on an object to request read access. 

            /// Otherwise, other processes cannot open the object if they request read access. 

            /// If this flag is not specified, but the object has been opened for read access, the function fails.

            /// </summary>

            Read = 0x00000001,

            /// <summary>

            /// Enables subsequent open operations on an object to request write access. 

            /// Otherwise, other processes cannot open the object if they request write access. 

            /// If this flag is not specified, but the object has been opened for write access, the function fails.

            /// </summary>

            Write = 0x00000002,

            /// <summary>

            /// Enables subsequent open operations on an object to request delete access. 

            /// Otherwise, other processes cannot open the object if they request delete access.

            /// If this flag is not specified, but the object has been opened for delete access, the function fails.

            /// </summary>

            Delete = 0x00000004

        }

        public enum ECreationDisposition : uint

        {

            /// <summary>

            /// Creates a new file. The function fails if a specified file exists.

            /// </summary>

            New = 1,

            /// <summary>

            /// Creates a new file, always. 

            /// If a file exists, the function overwrites the file, clears the existing attributes, combines the specified file attributes, 

            /// and flags with FILE_ATTRIBUTE_ARCHIVE, but does not set the security descriptor that the SECURITY_ATTRIBUTES structure specifies.

            /// </summary>

            CreateAlways = 2,

            /// <summary>

            /// Opens a file. The function fails if the file does not exist. 

            /// </summary>

            OpenExisting = 3,

            /// <summary>

            /// Opens a file, always. 

            /// If a file does not exist, the function creates a file as if dwCreationDisposition is CREATE_NEW.

            /// </summary>

            OpenAlways = 4,

            /// <summary>

            /// Opens a file and truncates it so that its size is 0 (zero) bytes. The function fails if the file does not exist.

            /// The calling process must open the file with the GENERIC_WRITE access right. 

            /// </summary>

            TruncateExisting = 5

        }

        [Flags]

        public enum EFileAttributes : uint

        {

            None = 0x00000000,

            Readonly = 0x00000001,

            Hidden = 0x00000002,

            System = 0x00000004,

            Directory = 0x00000010,

            Archive = 0x00000020,

            Device = 0x00000040,

            Normal = 0x00000080,

            Temporary = 0x00000100,

            SparseFile = 0x00000200,

            ReparsePoint = 0x00000400,

            Compressed = 0x00000800,

            Offline = 0x00001000,

            NotContentIndexed = 0x00002000,

            Encrypted = 0x00004000,

            Write_Through = 0x80000000,

            Overlapped = 0x40000000,

            NoBuffering = 0x20000000,

            RandomAccess = 0x10000000,

            SequentialScan = 0x08000000,

            DeleteOnClose = 0x04000000,

            BackupSemantics = 0x02000000,

            PosixSemantics = 0x01000000,

            OpenReparsePoint = 0x00200000,

            OpenNoRecall = 0x00100000,

            FirstPipeInstance = 0x00080000

        }

        [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);

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

        public static extern SafeFileHandle CreateFile(

           string lpFileName,

           EFileAccess dwDesiredAccess,

           EFileShare dwShareMode,

           IntPtr lpSecurityAttributes,

           ECreationDisposition dwCreationDisposition,

           EFileAttributes dwFlagsAndAttributes,

           IntPtr hTemplateFile);

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

        //static extern bool CloseHandle(IntPtr hHandle);

        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;

        SafeFileHandle iPipeOutbound;

        public FileStream iStreamOutbound;

        //

        public string iPipeNameInbound;

        Thread iThreadInbound;

        SafeFileHandle iPipeInbound;

        public FileStream iStreamInbound;

        private bool iQuit = false;

        public Server(string aPipeNameOutbound, string aPipeNameInbound)

        {

            iPipeNameOutbound = aPipeNameOutbound;

            iPipeNameInbound = aPipeNameInbound;

        }

        /**

         * Start our services.

         */

        public void Start()

        {

            //Start inbound thread to receive messages

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

            this.iThreadInbound.Start();

        }

        /**

         * Stop our services.

         */

        public void Stop()

        {

            iQuit = true;

        }

        /**

         * Inbound thread is receiving messages from our client

         */

        private void ThreadInbound()

        {

            //Keep on trying to connect on our read pipe

            while ((iPipeInbound == null || iPipeInbound.IsInvalid) && !iQuit)

            {

                Trace.WriteLine("Trying to connect to inbound pipe...");

                iPipeInbound = CreateFile(iPipeNameInbound, EFileAccess.GenericRead, EFileShare.None, IntPtr.Zero, ECreationDisposition.OpenExisting, EFileAttributes.None, IntPtr.Zero);

                System.Threading.Thread.Sleep(1000);

            }

            //Client now connected create our inbound stream

            if (iPipeInbound!=null && !iPipeInbound.IsInvalid)

            {

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

                if (iStreamInbound.CanRead)

                {

                    Trace.WriteLine("Inbound stream ready!");

                }

            }

            //Keep on trying to connect to our write pipe

            while ((iPipeOutbound == null || iPipeOutbound.IsInvalid) && !iQuit)

            {

                Trace.WriteLine("Trying to connect to outbound pipe...");

                iPipeOutbound = CreateFile(iPipeNameOutbound, EFileAccess.GenericWrite, EFileShare.None, IntPtr.Zero, ECreationDisposition.OpenExisting, EFileAttributes.None, IntPtr.Zero);

                System.Threading.Thread.Sleep(1000);

            }

            //Client now connected create our stream

            if (iPipeOutbound!=null && !iPipeOutbound.IsInvalid)

            {

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

                if (iStreamOutbound.CanWrite)

                {

                    Trace.WriteLine("Outbound stream ready!");

                }

            }

            //Listening loop

            byte[] buffer = null;

            ASCIIEncoding encoder = new ASCIIEncoding();

            while (!iQuit)

            {                

                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);

                    string msg = encoder.GetString(Rc, 0, ReadLength);

                    Trace.WriteLine(msg);

                    Trace.WriteLine("Received " + ReadLength + " Bytes: " + msg);

                    buffer.Initialize();

                }

            }

            //clean up resources

            if (iStreamInbound!=null) iStreamInbound.Close();

            if (iPipeInbound != null) iPipeInbound.Close();

            //

            if (iStreamOutbound != null) iStreamOutbound.Close();

            if (iPipeOutbound != null) iPipeOutbound.Close();

        }

        /**

         * Send a message to our client.

         */

        public void SendMessage(string message)

        {

            byte[] m8 = new byte[message.Length];

            int i = 0;

            foreach (char c in message)

            {

                m8[i]=System.Convert.ToByte(c);

                i++;

            }

            //ASCIIEncoding encoder = new ASCIIEncoding();

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

            if (iStreamOutbound != null && iStreamOutbound.CanWrite)

            {

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

                iStreamOutbound.Write(m8, 0, message.Length);

                iStreamOutbound.Flush();

            }

        }

    }

}