/*
 * SliceRaw.File.cs
 * 
 * Copyright © 2009
 * Diversified Technical Systems, Inc.
 * All Rights Reserved
 */

using System;
using System.IO;
using DTS.Common.Utilities.DotNetProgrammingConstructs;
using DTS.Common.Utilities.Logging;
using System.Linq;

namespace DTS.Serialization.SliceRaw
{   ///
    /// <summary>
    ///  Representation of a SliceRaw-type serialization. 
    /// </summary>
    /// 
    public partial class File
        : Serialization.File, IReadable<Test>, IWritable<Test>
    {   ///
        /// <summary>
        /// Initialize an instance of the SliceRaw.File class.
        /// </summary>
        /// 
        public File()
            : base("Slice Raw")
        {
        }

        /// <summary>
        /// Get the file writer for this file type.
        /// </summary>
        public IWriter<Test> Exporter
        {
            get
            {
                try
                {
                    if (_Exporter == null)
                        _Exporter = new Writer(this, DefaultEncoding);
                    return _Exporter;
                }

                catch (System.Exception ex)
                {
                    throw new Exception("encountered problem getting exporter", ex);
                }
            }
        }
        private IWriter<Test> _Exporter = null;

        /// <summary>
        /// Get the file reader for this file type.
        /// </summary>
        public IReader<Test> Importer
        {
            get
            {
                try
                {
                    if (_Importer == null)
                        _Importer = new Reader(this);
                    return _Importer;
                }

                catch (System.Exception ex)
                {
                    throw new Exception("encountered problem getting importer", ex);
                }
            }
        }
        private IReader<Test> _Importer = null;

        /// <summary>
        /// File extension for the disk entity that contains the serialized test information.
        /// </summary>
        public static string TestFileExtension
        {
            get => _TestFileExtension.Value;
            private set => _TestFileExtension.Value = value;
        }
        private static readonly Property<string> _TestFileExtension = new Property<string>("TestFileExtension", ".dts", true);

        /// <summary>
        /// File extension for the disk entity that contains serialized channel information.
        /// </summary>
        public static string ChannelFileExtension
        {
            get => _ChannelFileExtension.Value;
            private set => _ChannelFileExtension.Value = value;
        }
        private static readonly Property<string> _ChannelFileExtension = new Property<string>("ChannelFileExtension", ".chn", true);

        /// <summary>
        /// File extension for the disk entity that contains serialized channel information.
        /// </summary>
        public static string CalculatedChannelFileExtension
        {
            get => _CalculatedChannelFileExtension.Value;
            private set => _CalculatedChannelFileExtension.Value = value;
        }
        private static readonly Property<string> _CalculatedChannelFileExtension = new Property<string>("CalculatedChannelFileExtension", ".cchn", true);

        /// <summary>
        /// File extension for the disk entity that contains binary information.
        /// </summary>
        public static string BinaryFileExtension
        {
            get => _BinaryFileExtension.Value;
            private set => _BinaryFileExtension.Value = value;
        }
        private static readonly Property<string> _BinaryFileExtension = new Property<string>("BinaryFileExtension", ".bin", true);

        /// <summary>
        /// File extension for the disk entity that contains NMEA information.
        /// </summary>
        public static string NMEAFileExtension
        {
            get => _NMEAFileExtension.Value;
            private set => _NMEAFileExtension.Value = value;
        }
        private static readonly Property<string> _NMEAFileExtension = new Property<string>("NMEAFileExtension", ".nmea", true);

        /// <summary>
        /// File extension for the disk entity that contains plaintext information.
        /// </summary>
        public static string PlainTextFileExtension
        {
            get => _PlainTextFileExtension.Value;
            private set => _PlainTextFileExtension.Value = value;
        }
        private static readonly Property<string> _PlainTextFileExtension = new Property<string>("PlainTextFileExtension", ".txt", true);

        /// <summary>
        /// File extension for the disk entity that contains module timestamp information.
        /// </summary>
        public static string DasTimestampFileExtension
        {
            get => _DasTimestampFileExtension.Value;
            private set => _DasTimestampFileExtension.Value = value;
        }
        private static readonly Property<string> _DasTimestampFileExtension = new Property<string>("DasTimestampFileExtension", ".bin", true);

        /// <summary>
        /// The string that separates the channel numbers from the riffraff.
        /// </summary>
        public const string ChannelNumberDelimiter = ".";

        public const string AbsoluteDisplayOrderDelimiter = "Ch";
        /// <summary>
        /// Extract the channel file number from the specified channel name string.
        /// </summary>
        /// 
        /// <param name="testName">
        /// The test name <see cref="string"/> to be incorporated into the channel filename.
        /// </param>
        /// 
        /// <param name="channelNumber">
        /// The <see cref="int"/> channel number to be incorporated into the channel filename.
        /// </param>
        /// 
        /// <returns>
        /// A channel filename <see cref="string"/> that uniquely identifies test and channel
        /// that this channel informtion belongs to.
        /// </returns>
        /// 
        public string GetChannelFileNameFromTestNameAndChannelNumber(string testName, int channelNumber, int absoluteDisplayOrder)
        {
            try
            {
                if (string.IsNullOrEmpty(testName))
                    throw new ArgumentException("cannot construct channel file name from null/empty test name string");
                else
                    return string.Format("{0}{5}{1:000}{2}{3:000}{4}",
                        testName, 1 + absoluteDisplayOrder, ChannelNumberDelimiter, channelNumber, ChannelFileExtension, AbsoluteDisplayOrderDelimiter);
            }
            catch (System.Exception ex)
            {
                throw new Exception("encountered problem getting channel file name from channel number \"" + channelNumber.ToString() + "\"", ex);
            }
        }

        /// 
        public string GetCalculatedChannelFileNameFromTestNameAndChannelNumber(string testName, int channelNumber)
        {
            try
            {
                if (string.IsNullOrEmpty(testName))
                    throw new ArgumentException("cannot construct channel file name from null/empty test name string");
                return testName + ChannelNumberDelimiter + channelNumber.ToString() + CalculatedChannelFileExtension;
            }
            catch (System.Exception ex)
            {
                throw new Exception("encountered problem getting channel file name from channel number \"" + channelNumber.ToString() + "\"", ex);
            }
        }

        /// <summary>
        /// Extract the channel number from the specified channel filename.
        /// </summary>
        /// 
        /// <param name="channelFileName">
        /// The channel filename <see cref="string"/> to be converted into a channel number.
        /// </param>
        /// 
        /// <returns>
        /// The <see cref="int"/> channel number represented by the specified file.
        /// </returns>
        /// 
        public override int GetChannelNumberFromChannelFileName(string channelFileName)
        {
            try
            {
                var indexOfExtension = channelFileName.LastIndexOf(ChannelFileExtension);
                if (!char.IsDigit(channelFileName[indexOfExtension - 1]))
                {
                    //extension prefix detected, back up some more
                    indexOfExtension = channelFileName.LastIndexOf(ChannelNumberDelimiter, indexOfExtension - 1);
                }
                var indexOfFirstChannelNumberCharacter = channelFileName.LastIndexOf(ChannelNumberDelimiter, indexOfExtension - 1) + 1;
                return int.Parse(channelFileName.Substring(indexOfFirstChannelNumberCharacter, indexOfExtension - indexOfFirstChannelNumberCharacter));
            }
            catch (System.Exception ex)
            {
                throw new Exception("encountered problem getting channel number from channel file name", ex);
            }
        }

        /// 
        public string GetTimestampFileNameFromTestNameAndDASSerialNumber(string testName, string dasSerialNumber)
        {
            try
            {
                if (string.IsNullOrEmpty(testName))
                    throw new ArgumentException("cannot construct das file name from null/empty test name string");
                else
                    return string.Format("TS-{0}{2}{1}{3}",
                        testName, dasSerialNumber, ChannelNumberDelimiter, DasTimestampFileExtension);
            }
            catch (System.Exception ex)
            {
                throw new Exception("encountered problem getting das file name from das serial number \"" + dasSerialNumber.ToString() + "\"", ex);
            }
        }

        public static void ReadTestSetup(string testFileName, ref Test _test, ref TestSetup _testSetup)
        {
            ReadTestSetup(testFileName, out _test, out _testSetup, false);
        }
        public static void ReadTestSetup(string testFileName, out Test test, out TestSetup testSetup,
            bool justDTSFile)
        {
            var fi = new FileInfo(testFileName);
            var directory = fi.Directory.FullName;
            test = null;
            testSetup = null;

            var f = new Serialization.SliceRaw.File();
            try
            {
                using (var reader = new StreamReader(testFileName))
                {
                    var allText = reader.ReadToEnd();
                    const string delimiter = "<?xml version=";
                    var delimiterArray = new[] { delimiter };
                    var allTextArray = allText.Split(delimiterArray, StringSplitOptions.RemoveEmptyEntries);
                    var xmlCounter = 0;
                    foreach (var fullstring in allTextArray)
                    {
                        var fullString = allTextArray[xmlCounter];
                        xmlCounter++;
                        if (!fullString.Contains("Test")) continue;
                        fullString = delimiter + fullString;
                        var sr = new StringReader(fullString);
                        var tr = new System.Xml.XmlTextReader(sr);
                        var xmlType = fullString.Substring(fullString.IndexOf('>') + 4, 5).TrimEnd();
                        switch (xmlType)
                        {
                            case "Test":
                                try
                                {
                                    if (justDTSFile)
                                    {
                                        System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
                                        doc.LoadXml(fullString);

                                        var id = (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("Id");
                                        var desc =
                                            (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("Description");
                                        //FB 18312 Get the event number from xml if it's not in xaml calculate it from file name 
                                        var eventNum = (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("EventNumber");
                                        if (!string.IsNullOrWhiteSpace(eventNum))
                                        {
                                            var eventNumber = Convert.ToInt32(eventNum);
                                            test = new Test(id, desc, eventNumber);
                                        }
                                        else
                                        {
                                            var fileName = fi.Name;
                                            var segments = fileName.Split('_');
                                            if (Array.Exists(segments, p => p.Contains(DTS.Common.Constants.EventNumber)))
                                            {
                                                var foundEvent = Array.Find(segments, p => p.Contains(DTS.Common.Constants.EventNumber));
                                                var eventNumber = Convert.ToInt32(foundEvent.Replace(DTS.Common.Constants.EventNumber, ""));
                                                test = new Test(id, desc, eventNumber);
                                            }
                                            else
                                            {
                                                test = new Test(id, desc, 0);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        f.Importer.Read(directory, out test);
                                    }
                                }
                                catch (System.Exception ex)
                                {
                                    APILogger.Log(ex);
                                }
                                break;
                            case "TestS":
                                testSetup = new TestSetup();
                                var xs = new System.Xml.Serialization.XmlSerializer(testSetup.GetType());
                                testSetup = (TestSetup)xs.Deserialize(tr);
                                tr.Close();
                                sr.Close();
                                break;
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                APILogger.Log("exception in read test setup", ex);
            }
        }
    }
}