private void HandleConnection(IAsyncResult result)
        {
            AcceptConnection();
            TcpClient client = server.EndAcceptTcpClient(result);

            try
            {
                NetworkStream ns = client.GetStream();

                while (true)
                {
                    while (!ns.DataAvailable)
                    {
                        ;
                    }
                    while (client.Available < 3)
                    {
                        ;
                    }

                    byte[] incomingData = new byte[client.Available];
                    int    bytesCount   = ns.Read(incomingData, 0, client.Available);
                    string decodedData  = Encoding.UTF8.GetString(incomingData);

                    if (Regex.IsMatch(decodedData, "^GET", RegexOptions.IgnoreCase))
                    {
                        byte[] response = MakeHandshake(decodedData);
                        ns.Write(response, 0, response.Length);
                    }
                    else
                    {
                        bool fin  = (incomingData[0] & 0b10000000) != 0,
                             mask = (incomingData[1] & 0b10000000) != 0;

                        int opcode = incomingData[0] & 0b00001111,
                            msglen = incomingData[1] - 128,
                            offset = 2;

                        if (msglen == 126)
                        {
                            msglen = BitConverter.ToUInt16(new byte[] { incomingData[3], incomingData[2] }, 0);
                            offset = 4;
                        }

                        else if (mask)
                        {
                            byte[] decoded = new byte[msglen];
                            byte[] masks   = new byte[4] {
                                incomingData[offset], incomingData[offset + 1], incomingData[offset + 2], incomingData[offset + 3]
                            };
                            offset += 4;

                            for (int i = 0; i < msglen; ++i)
                            {
                                decoded[i] = (byte)(incomingData[offset + i] ^ masks[i % 4]);
                            }

                            string text = Encoding.UTF8.GetString(decoded);

                            string writeJson;

                            ClientInput input = JsonConvert.DeserializeObject <ClientInput>(text);

                            if (!input.Authenticate())
                            {
                                writeJson = Status.Create(403, "Forbidden: Authentication failed.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            if (input.command != "print")
                            {
                                writeJson = Status.Create(400, "Bad Request: Incorrect command. Please try again.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            ZplString zpl = new ZplString(input.zpl);

                            if (!zpl.Validate())
                            {
                                writeJson = Status.Create(400, "Bad Request: The ZPL string is formatted incorrectly. Please send a properly formatted ZPL string.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            Printer printer = new Printer();

                            if (printer.GetName() == "")
                            {
                                writeJson = Status.Create(500, "Internal Server Error: A valid printer could not be found.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            printer.Print(zpl.text);

                            Dictionary <String, String> logEntry = new Dictionary <String, String>
                            {
                                { "IPAddress", SystemHelper.GetLocalIP() },
                                { "ComputerName", SystemHelper.GetComputerName() },
                                { "ClientUsername", "username" },
                                { "PrintContent", zpl.text }
                            };

                            PrintLogRepository.Log(logEntry);

                            writeJson = Status.Create(200, "OK: Action completed");
                            ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                            client.Close();
                        }
                        else
                        {
                            Console.WriteLine("mask bit not set");
                        }

                        Console.WriteLine();
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionLogRepository.Log(ex.Message);
            }
        }
        // The delegate that processes incoming print requests and, if possible, prints them.
        private void HandleConnection(IAsyncResult result)
        {
            // This call doesn't make sense. Isn't this the method we called to pass this method as a delegate?
            // So if we're in this method, we know we had to have successfully called AcceptConnection() already,
            // and that method doesn't do anything besides specify this method. Why are we calling this?
            AcceptConnection();
            TcpClient client = server.EndAcceptTcpClient(result);

            try
            {
                NetworkStream ns = client.GetStream();

                // QUESTION/COMMENT- I'm not sure why we have this while loop. It would make sense if we were reading incoming data in a synchronous way, but
                // the rest of the code acts like result has all the data we're ever going to get.
                while (true)
                {
                    // QUESTION/COMMENT- Silly questions, but ones any coder will ask - if we never start getting data
                    // in stream for some reason, or the client only sends two bytes of data for some weird
                    // reason, these loops are infinite. Is that a problem?
                    // The space between the parentheses and the semicolon looks deliberate, given the rest of
                    // the formatting, so I'm taking that for a convention to indicate an empty while loop.
                    while (!ns.DataAvailable)
                    {
                        ;
                    }

                    // QUESTION/COMMENT- Below, is 3 a magic value for us in some way? If so, I'd like to replace with a named const.
                    // From reading the next lines of code, it seems like once we get the data, we get it all - when we
                    // assign bytesCount, we never check again to see if it has changed - so what's up for us that we're not
                    // saying "while (client.Available == 0)"?
                    // COMMENT - Available is the number of bytes of data received from the network and available to be read.
                    // Wait until we have some until starting work.
                    while (client.Available < 3)
                    {
                        ;
                    }

                    // incomingData holds all the data we got in the print request, which includes metadata as well as the
                    // data that we want to print.
                    byte[] incomingData = new byte[client.Available];
                    int    bytesCount   = ns.Read(incomingData, 0, client.Available);

                    // We only use decodedData to check for a handshake request from the client. For an actual print request,
                    // we just use the incomingData byte array.
                    string decodedData = Encoding.UTF8.GetString(incomingData);

                    // If the data we received starts with GET (case-insensitive), then just
                    // send a handshake response to the client. Don't do any other processing.
                    if (Regex.IsMatch(decodedData, "^GET", RegexOptions.IgnoreCase))
                    {
                        byte[] response = MakeHandshake(decodedData);
                        ns.Write(response, 0, response.Length);
                    }
                    // It wasn't a handshake request - it's a real print request.
                    else
                    {
                        // We do a lot of low-level bit operations in this block to get and interpret the control bytes
                        // from the client request.

                        // First, we do a bitwise comparison on the first two bytes of data to figure out if the fin and mask flags
                        // have been set.
                        // 0b at the beginning of a number tells C# that the rest of the number are literal bits.
                        // fin is true if the first bit of the first incoming byte is 1,
                        // mask is true if the first bit of the second incoming byte is 1.
                        // If the mask bit isn't set, we're not going to print anything.

                        // QUESTION/COMMENT- We never use fin. Why do we bother getting it?
                        bool fin  = (incomingData[0] & 0b10000000) != 0,
                             mask = (incomingData[1] & 0b10000000) != 0;

                        // The last 4 bits of the first incoming byte give us the numeric value for opcode.
                        // We strip the first 4 bits by AND-ing them with 0s.
                        int opcode = incomingData[0] & 0b00001111,
                        // The last seven bits of the second incoming byte give us our message length.
                        // We can find out what the last seven bits are by subtracting the 8th bit, which is worth 128
                        // if it's 1. That leaves us with a message length of 0-127 bytes.
                            msglen = incomingData[1] - 128,
                        // by default we assume that the first two bytes are metadata and the data starts at byte 3
                        // (0-indexed)
                            offset = 2;

                        // If the rightmost bit of the message length byte is 0 and the six bits to the right of that are 1's,
                        // (126), that's a flag that the msglen is actually
                        // a number that is two bytes long, that it is stored in bytes 3 and 4, and that our print data starts at byte, not byte 3.
                        // QUESTION/COMMENT- 126 might make a good named constant.
                        if (msglen == 126)
                        {
                            // The 0 argument just means start reading at the first (0-index) byte of the byte array we pass in the first argument.
                            msglen = BitConverter.ToUInt16(new byte[] { incomingData[3], incomingData[2] }, 0);
                            offset = 4;
                        }
                        // QUESTION/COMMENT- Is this an error? We went to some trouble in the lines above to get a two-byte message length,
                        // and an offset value that works with it, but with the "else" below, we're never going to use it.
                        else if (mask)
                        {
                            // Get an array of msglen bytes to hold our print data.
                            byte[] decoded = new byte[msglen];
                            // The four bytes after the bytes with the opcode, msglen, fin and mask values are data masks that we'll use to
                            // transform the data we read. The print data actually starts after the mask bytes.
                            byte[] masks = new byte[4] {
                                incomingData[offset], incomingData[offset + 1], incomingData[offset + 2], incomingData[offset + 3]
                            };
                            offset += 4;

                            // QUESTION/COMMENT- is there a reason we use ++i in the for loop below? As far as I can tell it has the same effect as i++, but people are
                            // really used to seeing i++ and when they see ++i, it makes them stop and wonder why and look for something they're missing.
                            // If we just like using ++i, that's fine, I'm just offering my two cents from a training and onboarding perspectie.

                            // COMMENT - read all of the actual incoming data, starting at the offset.
                            // We use the mask bytes to transform the byte data we received and which we will ultimately deserialize below into
                            // an input object.
                            // To transform the data, as we read each data byte, we apply a bitwise exclusive OR operation (true if the bits compared are different,
                            // false otherwise) to the data byte and one of the mask bytes. We apply the mask bytes to the data bytes in groups of four.
                            // The first data byte we read gets the first mask byte, the second data byte the second mask byte, etc., then we start again
                            // with the fifth data byte getting the first mask byte.
                            for (int i = 0; i < msglen; ++i)
                            {
                                decoded[i] = (byte)(incomingData[offset + i] ^ masks[i % 4]);
                            }

                            // Turn our transformed data byte array into a JSON string.
                            string text = Encoding.UTF8.GetString(decoded);

                            // The output HTTP response we'll send back to the client.
                            string writeJson;

                            // Finally, we have can turn our input JSON string into an input object.
                            ClientInput input = JsonConvert.DeserializeObject <ClientInput>(text);

                            if (!input.Authenticate())
                            {
                                writeJson = Status.Create(403, "Forbidden: Authentication failed.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            // QUESTION/COMMENT- "print" might be a good named constant.
                            if (input.command != "print")
                            {
                                writeJson = Status.Create(400, "Bad Request: Incorrect command. Please try again.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            // Get a Zebra Print Language (ZPL) string from the input and validate it.
                            ZplString zpl = new ZplString(input.zpl);

                            if (!zpl.Validate())
                            {
                                writeJson = Status.Create(400, "Bad Request: The ZPL string is formatted incorrectly. Please send a properly formatted ZPL string.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            Printer printer = new Printer();

                            if (printer.GetName() == "")
                            {
                                writeJson = Status.Create(500, "Internal Server Error: A valid printer could not be found.");
                                ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                                client.Close();
                                break;
                            }

                            // Finally, we print to the printer we found in the new Printer() call above and log the whole interaction.
                            printer.Print(zpl.text);

                            // QUESTION/COMMENT- do we want to log errors? The way the code is written, we break on any error that we know how to
                            // handle, like invalid ZPL data or printer not found, so we'll never see errors in our log. Exceptions go to the
                            // ExceptionLogRepository, but errors we know how to handle are just lost.
                            Dictionary <String, String> logEntry = new Dictionary <String, String>
                            {
                                { "IPAddress", SystemHelper.GetLocalIP() },
                                { "ComputerName", SystemHelper.GetComputerName() },
                                { "ClientUsername", "username" },
                                { "PrintContent", zpl.text }
                            };

                            PrintLogRepository.Log(logEntry);

                            writeJson = Status.Create(200, "OK: Action completed");
                            ns.Write(Encoding.Default.GetBytes(writeJson), 0, Encoding.Default.GetBytes(writeJson).Length);
                            client.Close();

                            // QUESTION/COMMENT- We don't have a break here, so we stay in while(true). Is that what we want to do?
                            // We just closed the client, which we instantiated just to handle the result passed to this method,
                            // so it doesn't seem like there's anything more for the while loop to do.
                        }
                        else
                        {
                            // QUESTION/COMMENT- the code reads a little easier if you put a quick exit condition like this before all
                            // the lengthy data processing logic.
                            Console.WriteLine("mask bit not set");
                        }

                        Console.WriteLine();
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionLogRepository.Log(ex.Message);
            }
        }