//-----------------------------------------------------------------------
// <copyright file="SerialPortHandler.cs" company="bedug.com">
//     Copyright © 2012 Nils Hammar. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
/*
 * Software to access vehicle information via the OBD-II connector.
 * 
 * Copyright © 2012 Nils Hammar
 * 
 * This program 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.
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Alternative licensing is possible, see the licensing document.
 * 
 * The above text may not be removed or modified.
 */

namespace Protocol
{
    using System;
    using System.IO.Ports;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Class for handling interaction with serial port.
    /// </summary>
    public class SerialPortHandler : IDisposable
    {
        /// <summary>
        /// Parameters for port.
        /// </summary>
        private ISerialPortParameters serialPortParameters;

        /// <summary>
        /// Serial port instance.
        /// </summary>
        private SerialPort serialPort = null;

        /// <summary>
        /// Initializes a new instance of the <see cref="SerialPortHandler" /> class.
        /// </summary>
        /// <param name="serialPortParameters">Parameters for port.</param>
        public SerialPortHandler(ISerialPortParameters serialPortParameters)
        {
            this.serialPortParameters = serialPortParameters;
        }

        /// <summary>
        /// Open the serial port.
        /// <para>
        /// Notice that it is closed and re-opened if it's already open.
        /// </para>
        /// </summary>
        public void open()
        {
            this.close();
            this.serialPort = new SerialPort(
                this.serialPortParameters.serialPortName,
                this.serialPortParameters.serialPortSpeed,
                this.serialPortParameters.serialPortParity,
                this.serialPortParameters.serialPortDatabits,
                this.serialPortParameters.serialPortStopbits);
            this.serialPort.Open();
        }

        /// <summary>
        /// Implementation of IDisposable.
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Close the serial port.
        /// </summary>
        public void close()
        {
            if (this.serialPort != null)
            {
                this.serialPort.Close();
                this.serialPort = null;
            }
        }

        /// <summary>
        /// Write the string to the serial port.
        /// </summary>
        /// <param name="str">String to be written.</param>
        public void write(string str)
        {
            this.serialPort.Write(str);
        }

        /// <summary>
        /// Write bytes in hex to the serial port.
        /// <para>
        /// This method converts bytes to hex form before writing to the port.
        /// </para>
        /// </summary>
        /// <param name="ba">Data to write.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void write(byte[] ba)
        {
            bool first = true;
            foreach (byte b1 in ba)
            {
                if (!first)
                {
                    this.serialPort.Write(" ");
                }
                else
                {
                    first = false;
                }

                this.serialPort.Write(b1.ToString("x2"));
            }

            this.serialPort.Write(ba, 0, ba.Length);
        }

        /// <summary>
        /// Write Raw to the serial port.
        /// <para>
        /// This method writes bytes 'as is' to the serial port, which allows for writing of binary data.
        /// </para>
        /// </summary>
        /// <param name="ba">Data to write.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void writeRaw(byte[] ba)
        {
            this.serialPort.Write(ba, 0, ba.Length);
        }

        /// <summary>
        /// Read from the serial port.
        /// </summary>
        /// <param name="noWait">If 'true' read what's in the buffers and return right away.</param>
        /// <returns>String read from serial port.</returns>
        public string read(bool noWait)
        {
            noWait = false;
            string data = string.Empty;
            try
            {
                if (noWait)
                {
                    data = this.serialPort.ReadExisting();
                }
                else
                {
                    // data = this.serialPort.ReadTo("\r>");
                    // data = this.serialPort.ReadTo("\n>");
                    data = this.serialPort.ReadTo(">");
                }
            }
            catch
            {
                // Ignore any exception thrown.
            }

            return data;
        }

        /// <summary>
        /// Dispose the object.
        /// </summary>
        /// <param name="disposing">Unused parameter.</param>
        protected virtual void Dispose(bool disposing)
        {
            this.close();
        }
    }
}