// ******************************************************************************//
//  RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
//  PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
//  AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
//  UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
//  RAYTHEON COMPANY''S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
//  CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
//  OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
//  COMPANY.
//
//  THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S. GOVERNMENT
//
//  UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
//
//  WARNING: THIS DOCUMENT CONTAINS TECHNICAL DATA AND / OR TECHNOLOGY WHOSE
//  EXPORT OR DISCLOSURE TO NON-U.S. PERSONS, WHEREVER LOCATED, IS RESTRICTED
//  BY THE INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) (22 C.F.R. SECTION
//  120-130) OR THE EXPORT ADMINISTRATION REGULATIONS (EAR) (15 C.F.R. SECTION
//  730-774). THIS DOCUMENT CANNOT BE EXPORTED (E.G., PROVIDED TO A SUPPLIER
//  OUTSIDE OF THE UNITED STATES) OR DISCLOSED TO A NON-U.S. PERSON, WHEREVER
//  LOCATED, UNTIL A FINAL JURISDICTION AND CLASSIFICATION DETERMINATION HAS
//  BEEN COMPLETED AND APPROVED BY RAYTHEON, AND ANY REQUIRED U.S. GOVERNMENT
//  APPROVALS HAVE BEEN OBTAINED. VIOLATIONS ARE SUBJECT TO SEVERE CRIMINAL
//  PENALTIES.
//
//  DOD 5220.22-M, INDUSTRIAL SECURITY MANUAL, CHAPTER 5, SECTION 1 THROUGH 9 :
//  FOR CLASSIFIED DOCUMENTS FOLLOW THE PROCEDURES IN OR DOD 5200.1-R,
//  INFORMATION SECURITY PROGRAM, CHAPTER 6. FOR UNCLASSIFIED, LIMITED DOCUMENTS
//  DESTROY BY ANY  METHOD THAT WILL PREVENT DISCLOSURE OF CONTENTS OR
//  RECONSTRUCTION OF THE DOCUMENT.
// ****************************************************************************//
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Newtonsoft.Json;

namespace Raytheon.Common
{
   /// <summary>
   /// Implementation of the IConfigurationFile interface for Json file format
   /// </summary>
   public class JsonConfigurationFile : ConfigurationFileBase
   {

      private Dictionary<string, Dictionary<string, string>> _data;

      /// <summary>
      /// constructor
      /// </summary>
      /// <param name="fileName"></param>
      /// <exception cref="ArgumentException"></exception>
      public JsonConfigurationFile(string fileName)
          : base(fileName)
      {
         if (_configurationType != ConfigurationFileType.JSON)
         {
            throw new ArgumentException("Expecting JSON file configuration type");
         }

         if (!_fileInfo.Exists)
         {
            using (File.Create(_fileInfo.FullName)) { }
         }
      }

      /// <summary>
      /// reads all available keys from given section from current configuration file
      /// </summary>
      /// <param name="section"></param>
      /// <returns></returns>
      public override List<string> ReadAllKeys(string section)
      {
         string json = File.ReadAllText(_fileName);
         if (!string.IsNullOrEmpty(json))
         {
            _data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(json);
         }
         else
         {
            _data = new Dictionary<string, Dictionary<string, string>>();
         }
         return _data.ContainsKey(section) ? _data[section].Keys.ToList() : new List<string>();
      }

      /// <summary>
      /// reads all available sections from current configuration file
      /// </summary>
      /// <returns>list of sections</returns>
      public override List<string> ReadAllSections()
      {
         string json = File.ReadAllText(_fileName);
         if (!string.IsNullOrEmpty(json))
         {
            _data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(json);
         }
         else
         {
            _data = new Dictionary<string, Dictionary<string, string>>();
         }
         return _data.Keys.ToList();
      }

      public override List<T> ReadList<T>(string section, string key, IList<T> defList = null)
      {
         return ReadValue(section, key, defList).ToList();
      }

      /// <summary>
      /// reads a single value in json format
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="section"></param>
      /// <param name="key"></param>
      /// <param name="defValue"></param>
      /// <returns>configuration value</returns>
      /// <exception cref="NotImplementedException"></exception>
      public override T ReadValue<T>(string section, string key, T defValue = default)
      {
         string json = File.ReadAllText(_fileName);
         if (!string.IsNullOrEmpty(json))
         {
            _data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(json);
         }
         else
         {
            _data = new Dictionary<string, Dictionary<string, string>>();
         }

         if (_data.ContainsKey(section) && _data[section].ContainsKey(key))
         {
            return JsonConvert.DeserializeObject<T>(_data[section][key]);
         }
         else
         {
            WriteValue(section, key, defValue);
            return defValue;
         }
      }

      /// <summary>
      /// reads a single value in json format
      /// </summary>
      /// <param name="section"></param>
      /// <param name="key"></param>
      /// <returns>configuration value</returns>
      /// <exception cref="NotImplementedException"></exception>
      public override string ReadValue(string section, string key)
      {
         throw new NotImplementedException();
      }

      /// <summary>
      /// writes a list of values of any generic type
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="section"></param>
      /// <param name="key"></param>
      /// <param name="listToWrite"></param>
      public override void WriteList<T>(string section, string key, IList<T> listToWrite)
      {
         WriteValue(section, key, listToWrite);
      }

      /// <summary>
      /// writes a single value 
      /// </summary>
      /// <typeparam name="T"></typeparam>
      /// <param name="section"></param>
      /// <param name="key"></param>
      /// <param name="lineToWrite"></param>
      public override void WriteValue<T>(string section, string key, T lineToWrite)
      {
         string json = File.ReadAllText(_fileName);
         if (!string.IsNullOrEmpty(json))
         {
            _data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(json);
         }
         else
         {
            _data = new Dictionary<string, Dictionary<string, string>>();
         }

         if (!_data.ContainsKey(section))
         {
            _data[section] = new Dictionary<string, string>();
         }

         _data[section][key] = JsonConvert.SerializeObject(lineToWrite);

         using (StreamWriter writer = new StreamWriter(_fileName, false))
         {
            writer.WriteLine(JsonConvert.SerializeObject(_data));
         }
      }

   }
}
