//-----------------------------------------------------------------------
// <copyright file="ObdCodeFileAccess.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 DataSource.FileAccess
{
    using System.Collections.Generic;
    using System.Globalization;
    using System.IO;
    using global::SharedObjects;

    /// <summary>
    /// Access class for OBD codes.
    /// </summary>
    public class ObdCodeFileAccess : XmlParserHelper
    {
        /// <summary>
        /// Gets Name of file.
        /// </summary>
        public string fileName { get; private set; }

        /// <summary>
        /// Gets Dictionary of supported OBD codes.
        /// </summary>
        public SortedDictionary<string, string> obdcodes { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObdCodeFileAccess" /> class.
        /// <para>
        /// Initiate access to OBD codes.
        /// </para>
        /// </summary>
        /// <param name="iLogging">Logging interface.</param>
        /// <param name="newList">'true' if a new empty OBD list is to be created.</param>
        /// <param name="dataFileDir">Data file directory path.</param>
        public ObdCodeFileAccess(ILogging iLogging, bool newList, string dataFileDir)
            : base(iLogging, dataFileDir)
        {
            if (newList)
            {
                this.obdcodes = new SortedDictionary<string, string>();
            }
            else
            {
                this.obdcodes = null;
            }

            this.fileName = null;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObdCodeFileAccess" /> class.
        /// <para>
        /// Create a new instance based on an existing dictionary of codes.
        /// </para>
        /// </summary>
        /// <param name="iLogging">Logging interface.</param>
        /// <param name="addCodes">Existing dictionary</param>
        /// <param name="dataFileDir">Data file directory path.</param>
        public ObdCodeFileAccess(ILogging iLogging, SortedDictionary<string, string> addCodes, string dataFileDir)
            : base(iLogging, dataFileDir)
        {
            this.obdcodes = new SortedDictionary<string, string>(addCodes);
            this.fileName = null;
        }

        /// <summary>
        /// Adds codes from the given dictionary to the current if
        /// the code does not already exist.
        /// </summary>
        /// <param name="additionalCodes">Existing dictionary, may be 'null' in which case nothing happens.</param>
        public void addCodes(SortedDictionary<string, string> additionalCodes)
        {
            if (this.obdcodes == null)
            {
                this.obdcodes = new SortedDictionary<string, string>();
            }

            if (additionalCodes != null)
            {
                foreach (string key in additionalCodes.Keys)
                {
                    if (!this.obdcodes.ContainsKey(key))
                    {
                        this.obdcodes.Add(key, additionalCodes[key]);
                    }
                }
            }
        }

        /// <summary>
        /// Add one single code, create code list if empty.
        /// </summary>
        /// <param name="code">OBD code name, e.g. P0420</param>
        /// <param name="description">Description of OBD code.</param>
        public void add(string code, string description)
        {
            if (this.obdcodes == null)
            {
                this.obdcodes = new SortedDictionary<string, string>();
            }

            this.obdcodes.Add(code, description);
        }

        /// <summary>
        /// Save codes to the same file as they were loaded from.
        /// (Overwrites file)
        /// </summary>
        public void save()
        {
            this.save(this.fileName);
        }

        /// <summary>
        /// Save codes to the given file.
        /// </summary>
        /// <param name="saveFileName">File name</param>
        public void save(string saveFileName)
        {
            this.iLogging.appendText("Saving OBD codes to file : " + saveFileName + "\r\n");

            if (saveFileName == Path.GetFileName(saveFileName))
            {
                saveFileName = this.dataFileDir + saveFileName;
            }

            StreamWriter sw = null;
            try
            {
                sw = new StreamWriter(saveFileName);
                foreach (string key in this.obdcodes.Keys)
                {
                    sw.WriteLine(key + " " + this.obdcodes[key]);
                }
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
            }
        }

        /// <summary>
        /// Load OBD codes from a file with the given name.
        /// </summary>
        /// <param name="codefile">Name and optionally path to file.</param>
        /// <param name="specificFile">The file given is a specific file to open, not the standard file(s) for the application.</param>
        public void loadObdCodes(string codefile, bool specificFile)
        {
            using (StreamReader sr = this.openInFile(codefile, specificFile))
            {
                if (sr != null)
                {
                    try
                    {
                        this.loadCodes(sr);
                    }
                    finally
                    {
                        closeInFile(sr);
                    }
                }
            }
        }

        /// <summary>
        /// Close in file.
        /// </summary>
        /// <param name="sr">Stream to close</param>
        private static void closeInFile(StreamReader sr)
        {
            try
            {
                if (sr != null)
                {
                    sr.Close();
                    sr = null;
                }
            }
            catch
            {
            }
        }

        /// <summary>
        /// Tries to open the file from one of three different locations:
        /// <list type="number">
        ///     <listheader>
        ///         <term>#</term>
        ///         <description>Directory</description>
        ///     </listheader>
        ///     <item>
        ///         <term>1.</term>
        ///         <description>Current Directory.</description>
        ///     </item>
        ///     <item>
        ///         <term>2.</term>
        ///         <description>Common Application Data Directory.</description>
        ///     </item>
        ///     <item>
        ///         <term>3.</term>
        ///         <description>Application Binary directory (last resort).</description>
        ///     </item>
        /// </list>
        /// </summary>
        /// <param name="codefile">File containing OBD codes.</param>
        /// <param name="specificFile">The file given is a specific file to open, not the standard file(s) for the application.</param>
        /// <returns>Stream reader instance for the file.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed.")]
        private StreamReader openInFile(string codefile, bool specificFile)
        {
            StreamReader sr = null;
            string basename = Path.GetFileName(codefile);
            string codeBase = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase;
            string dir = System.IO.Path.GetDirectoryName(codeBase);
            string progdirFilename = dir + "\\" + basename;

            this.iLogging.appendText("Loading OBD data from file.\r\n");

            try
            {
                if (specificFile)
                {
                    sr = new StreamReader(codefile);
                    this.fileName = codefile;
                }
                else
                {
                    try
                    {
                        sr = new StreamReader(this.dataFileDir + basename);
                        this.fileName = this.dataFileDir + basename;
                    }
                    catch
                    {
                        sr = new StreamReader(progdirFilename);
                        this.fileName = progdirFilename;
                    }
                }

                this.iLogging.appendText("Found OBD codes in file : " + this.fileName + "\r\n");
            }
            catch
            {
            }

            return sr;
        }

        /// <summary>
        /// Load the OBD codes from file.
        /// </summary>
        /// <param name="sr">Stream to read from.</param>
        private void loadCodes(StreamReader sr)
        {
            string line = string.Empty;
            this.obdcodes = new SortedDictionary<string, string>();
            while ((line = sr.ReadLine()) != null)
            {
                if (line.Length > 0 && !line.StartsWith(";"))
                {
                    int n = line.IndexOf(' ');
                    if (n > 0)
                    {
                        string code = line.Substring(0, n);
                        code = code.ToUpper(CultureInfo.InvariantCulture);
                        if (!this.obdcodes.ContainsKey(code))
                        {
                            try
                            {
                                this.obdcodes.Add(code, line.Substring(n + 1));
                            }
                            catch
                            {
                                // Ignore, discard duplicates.
                            }
                        }
                    }
                }
            }
        }
    }
}