using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Configuration
{
    /// <summary>
    /// Représente un fichier de configuration de type INI
    /// </summary>
    public class IniFile
    {
        #region Membres privés statiques

        private static readonly Regex _regexSection = new Regex(@"\s*\[\s*([\.\w\s]+)\]", RegexOptions.Compiled);
        private static readonly Regex _regexKeyValuePair = new Regex(@"^\s*(\w[\s\w]+)=(.*?)(\s*;.*)?$", RegexOptions.Compiled);

        #endregion

        #region Membres privés

        private readonly bool _caseSensitive;
        private readonly IDictionary<string, IDictionary<string, string>> _sections;
        private Encoding _encoding;

        #endregion

        #region Constructeurs

        /// <summary>
        /// Crée une instance vide de IniFile, pour créer dynamiquement
        /// le contenu du fichier avant de l'enregistrer.
        /// </summary>
        public IniFile()
            : this(null, false)
        {
        }

        /// <summary>
        /// Crée une instance vide de IniFile, pour créer dynamiquement
        /// le contenu du fichier avant de l'enregistrer.
        /// </summary>
        /// <param name="caseSensitive">Indique si le IniFile doit tenir compte de la casse</param>
        public IniFile(bool caseSensitive)
            : this(null, caseSensitive)
        {
        }

        /// <summary>
        /// Crée une instance de IniFile en chargeant le fichier spécifié
        /// </summary>
        /// <param name="fileName">Nom du fichier INI à ouvrir</param>
        public IniFile(string fileName)
            : this(fileName, false)
        {
        }

        /// <summary>
        /// Crée une instance de IniFile en chargeant le fichier spécifié
        /// </summary>
        /// <param name="fileName">Nom du fichier INI à ouvrir</param>
        /// <param name="caseSensitive">Indique si le IniFile doit tenir compte de la casse</param>
        public IniFile(string fileName, bool caseSensitive) : this(fileName, caseSensitive, null)
        {
        }

        /// <summary>
        /// Crée une instance de IniFile en chargeant le fichier spécifié
        /// </summary>
        /// <param name="fileName">Nom du fichier INI à ouvrir</param>
        /// <param name="encoding">Encodage à utiliser pour lire le fichier</param>
        public IniFile(string fileName, Encoding encoding) : this(fileName, false, encoding)
        {
        }

        /// <summary>
        /// Crée une instance de IniFile en chargeant le fichier spécifié
        /// </summary>
        /// <param name="fileName">Nom du fichier INI à ouvrir</param>
        /// <param name="caseSensitive">Indique si le IniFile doit tenir compte de la casse</param>
        /// <param name="encoding">Encodage à utiliser pour lire le fichier</param>
        public IniFile(string fileName, bool caseSensitive, Encoding encoding)
        {
            _caseSensitive = caseSensitive;
            _encoding = encoding;

            var comparer = _caseSensitive ? StringComparer.CurrentCulture : StringComparer.CurrentCultureIgnoreCase;
            _sections = new Dictionary<string, IDictionary<string, string>>(comparer);

            if (fileName != null)
            {
                FileName = fileName;
                Reload();
            }
        }

        #endregion

        #region Propriétés publiques

        /// <summary>
        /// Le nom du fichier
        /// </summary>
        public string FileName { get; set; }

        /// <summary>
        /// Sections du fichier INI, accessibles sous forme d'un dictionnaire de sections
        /// Chaque section est elle-même un dictionnaire de propriétés
        /// </summary>
        public IDictionary<string, IDictionary<string, string>> Sections
        {
            get { return _sections; }
        }

        #endregion

        #region Indexeur

        /// <summary>
        /// Renvoie la valeur de la propriété spécifiée dans la section spécifiée
        /// </summary>
        /// <param name="section">Nom de la section, ou une chaine vide</param>
        /// <param name="key">Nom de la propriété</param>
        /// <returns>La valeur de la propriété demandée, ou null si la
        /// propriété n'existe pas dans le fichier</returns>
        public string this[string section, string key]
        {
            get { return GetValue(section, key); }
            set { SetValue(section, key, value); }
        }

        #endregion

        #region Méthodes publiques

        /// <summary>
        /// Charge ou recharge le fichier indiqué par la propriété FileName
        /// </summary>
        public void Reload()
        {
            if (FileName.IsNullOrEmpty())
                throw new InvalidOperationException(ExceptionMessages.IniFileNameNotSet);

            _sections.Clear();

            using (StreamReader rd = new StreamReader(FileName, _encoding ?? Encoding.UTF8, true))
            {
                string curSection = "";
                string line;
                Match m;
                while ((line = rd.ReadLine()) != null)
                {
                    // Skip comments
                    if (line.Trim().StartsWith(";"))
                        continue;

                    if ((m = _regexSection.Match(line)).Success)
                    {
                        curSection = m.Groups[1].Value;
                    }
                    else if ((m = _regexKeyValuePair.Match(line)).Success)
                    {
                        string key = m.Groups[1].Value;
                        string value = m.Groups[2].Value;
                        IDictionary<string, string> dSection;
                        if (!Sections.TryGetValue(curSection, out dSection))
                            dSection = AddSection(curSection);
                        dSection.Add(key, value);
                    }
                }
                _encoding = rd.CurrentEncoding;
            }
        }

        /// <summary>
        /// Ajoute une section au fichier INI
        /// </summary>
        /// <param name="name">Nom de la section à ajouter</param>
        /// <returns>La section créée, sous form d'un dictionnaire</returns>
        public IDictionary<string, string> AddSection(string name)
        {
            Dictionary<string, string> section;
            if (_caseSensitive)
                section = new Dictionary<string, string>();
            else
                section = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            Sections.Add(name, section);
            return section;
        }

        /// <summary>
        /// Obtient la valeur de la propriété spécifiée dans la section spécifiée
        /// Si la propriété n'est pas dans une section, passer une chaine vide
        /// </summary>
        /// <param name="section">Nom de la section, ou une chaine vide</param>
        /// <param name="key">Nom de la propriété</param>
        /// <param name="defaultValue">Valeur par défaut si la propriété n'existe pas</param>
        /// <returns>a valeur de la propriété demandée, ou defaultValue si la
        /// propriété n'existe pas dans le fichier</returns>
        public string GetValue(string section, string key, string defaultValue)
        {
            if (section == null) section = "";
            IDictionary<string, string> dSection;
            if (Sections.TryGetValue(section, out dSection))
            {
                string value;
                if (dSection.TryGetValue(key, out value))
                    return value;
                return defaultValue;
            }
            return defaultValue;
        }

        /// <summary>
        /// Obtient la valeur de la propriété spécifiée dans la section spécifiée
        /// Si la propriété n'est pas dans une section, passer une chaine vide
        /// </summary>
        /// <param name="section">Nom de la section, ou une chaine vide</param>
        /// <param name="key">Nom de la propriété</param>
        /// <returns>a valeur de la propriété demandée, ou null si la
        /// propriété n'existe pas dans le fichier</returns>
        public string GetValue(string section, string key)
        {
            return GetValue(section, key, null);
        }

        /// <summary>
        /// Définit la valeur d'une propriété dans une section donnée.
        /// Pour n'indiquer aucune section, passer une chaine vide.
        /// Si la section n'existe pas, elle est créée
        /// </summary>
        /// <param name="section">Nom de la section, ou une chaine vide</param>
        /// <param name="key">Nom de la propriété</param>
        /// <param name="value">Valeur de la propriété</param>
        public void SetValue(string section, string key, string value)
        {
            if (section == null)
                section = "";
            IDictionary<string, string> dSection;
            if (!Sections.TryGetValue(section, out dSection))
                dSection = AddSection(section);
            dSection[key] = value;
        }

        /// <summary>
        /// Enregistre le fichier INI sous le chemin indiqué par la propriété FileName.
        /// Attention, les commentaires éventuellement présents dans le fichier avant
        /// le chargement ne sont pas conservés.
        /// </summary>
        public void Save()
        {
            Save(FileName);
        }

        /// <summary>
        /// Enregistre le fichier INI sous le chemin indiqué.
        /// Attention, les commentaires éventuellement présents dans le fichier avant
        /// le chargement ne sont pas conservés.
        /// </summary>
        /// <param name="fileName">Chemin du fichier</param>
        public void Save(string fileName)
        {
            Save(fileName, _encoding);
        }

        /// <summary>
        /// Enregistre le fichier INI sous le chemin indiqué.
        /// Attention, les commentaires éventuellement présents dans le fichier avant
        /// le chargement ne sont pas conservés.
        /// </summary>
        /// <param name="fileName">Chemin du fichier</param>
        /// <param name="encoding">Encodage à utiliser pour lire le fichier</param>
        public void Save(string fileName, Encoding encoding)
        {
            if (fileName.IsNullOrEmpty())
                throw new InvalidOperationException(ExceptionMessages.IniFileNameNotSet);

            _encoding = encoding ?? Encoding.UTF8;

            using (StreamWriter wr = new StreamWriter(fileName, false, _encoding))
            {
                IDictionary<string, string> noSection;
                if (Sections.TryGetValue("", out noSection))
                {
                    foreach (string key in noSection.Keys)
                    {
                        wr.WriteLine("{0}={1}", key, Sections[""][key]);
                    }
                    wr.WriteLine();
                }

                foreach (string secName in Sections.Keys)
                {
                    if (secName.Length == 0)
                        continue;
                    wr.WriteLine("[{0}]", secName);
                    foreach (string key in Sections[secName].Keys)
                    {
                        wr.WriteLine("{0}={1}", key, Sections[secName][key]);
                    }
                    wr.WriteLine();
                }
            }
        }

        #endregion

    }
}