//
//  Class:			transmitter
//	Current CLR:	4.0.30319.34209
//	System:			Microsoft Visual Studio 10.0
//	Author:			dani
// 	Created:		7/14/2015 7:39:29 AM
//
//	Copyright (c) 2015 Informatikbüro Daniel Schick. All rights reserved.

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using System.Xml.Serialization;
using bsmd.database;
using log4net;

namespace bsmd.hisnord
{
    public class transmitter
    {
        private static readonly ILog _log = LogManager.GetLogger(typeof(transmitter));
        private static int? processId;

        public static bool Transmit()
        {
            string rootDir = Properties.Settings.Default.TransmitterRoot;

            if(processId.HasValue)
            {
                _log.InfoFormat("Transmitter process {0} still running, aborting call", processId);
                return false;
            }

            ProcessStartInfo startInfo = new ProcessStartInfo(Path.Combine(rootDir, Properties.Settings.Default.Transmitter));
            startInfo.WorkingDirectory = rootDir;
            startInfo.RedirectStandardError = true;
            startInfo.RedirectStandardOutput = true;
            startInfo.RedirectStandardInput = false;
            startInfo.UseShellExecute = false;
            // der Transmitter schickt alles was im Ausgabe-Verzeichnis ist
            // damit das gut geht schicken wir die Nachrichten einzeln und arbeiten jeweils das 
            // Ergebnis ab

            using (Process transmitterProcess = new Process())
            {                
                transmitterProcess.Exited += TransmitterProcess_Exited;                

                transmitterProcess.ErrorDataReceived += TransmitterProcess_ErrorDataReceived;
                transmitterProcess.OutputDataReceived += TransmitterProcess_OutputDataReceived;
                
                transmitterProcess.StartInfo = startInfo;
                transmitterProcess.EnableRaisingEvents = true;
                transmitterProcess.Start();

                transmitterProcess.BeginErrorReadLine();
                transmitterProcess.BeginOutputReadLine();

                processId = transmitterProcess.Id;                

                // _log.DebugFormat("started {0}", transmitterProcess.ProcessName);
                int timeout = Properties.Settings.Default.BatchTimeoutMins * 1000 * 60; // convert to ms                

                _log.DebugFormat($"starting transmitter, process ID: {processId}, timeout {timeout} ms.");

                if (!transmitterProcess.WaitForExit((timeout == 0) ? int.MaxValue : timeout))
                {
                    _log.Warn($"Transmitter {processId} not exited within {timeout} ms");                    
                    try
                    {
                        transmitterProcess.Kill();
                        _log.Warn($"Transmitter {processId} killed");                        
                        processId = null;
                    }
                    catch (Exception e)
                    {
                        _log.Warn($"Killing Transmitter {processId} failed: {e.Message}");
                    }
                }
            }
            return true;
        }

        private static void TransmitterProcess_OutputDataReceived(object sender, DataReceivedEventArgs e)
        {
            if(!e.Data.IsNullOrEmpty())
                _log.Debug(e.Data);
        }

        private static void TransmitterProcess_ErrorDataReceived(object sender, DataReceivedEventArgs e)
        {
            if(!e.Data.IsNullOrEmpty())
                _log.Error(e.Data);
        }        

        private static void TransmitterProcess_Exited(object sender, EventArgs e)
        {
            _log.Debug("Transmitter process exited");
            processId = null;
        }

        public static result GetResult(string filenameFullPath)
        {            
            // now we should read the response message...
            string resultFilename = string.Format("{0}.result.xml", Path.GetFileName(filenameFullPath));
            string resultDir = Path.Combine(Properties.Settings.Default.TransmitterRoot, Properties.Settings.Default.ResultDir);
            string resultFullPath = Path.Combine(resultDir, resultFilename);
            return result.ReadResult(resultFullPath);
        }

        public static void PurgeOldFiles(int maxAgeDays)
        {
            try
            {
                // "ANSWERS_DONE"
                DirectoryInfo info = new DirectoryInfo(Path.Combine(Properties.Settings.Default.TransmitterRoot, Properties.Settings.Default.AnswerArchiveDir));
                FileInfo[] files = info.GetFiles();
                int cnt = 0;
                foreach (FileInfo file in files)
                {
                    if (file.CreationTime < DateTime.Now.AddDays(-maxAgeDays))
                    {
                        _log.Debug($"deleting {file.Name}");
                        file.Delete();
                        cnt++;
                    }
                }
                _log.Info($"deleted {cnt} files from {Properties.Settings.Default.AnswerArchiveDir}");

                // "RESULTS"
                cnt = 0;
                info = new DirectoryInfo(Path.Combine(Properties.Settings.Default.TransmitterRoot, Properties.Settings.Default.ResultDir)); 
                files = info.GetFiles();
                foreach (FileInfo file in files)
                {
                    if (file.CreationTime < DateTime.Now.AddDays(-maxAgeDays))
                    {
                        _log.Debug($"deleting {file.Name}");
                        file.Delete();
                        cnt++;
                    }
                }
                _log.Info($"deleted {cnt} files from {Properties.Settings.Default.ResultDir}");

                // "READY"
                cnt = 0;
                info = new DirectoryInfo(Path.Combine(Properties.Settings.Default.TransmitterRoot, "READY"));
                files = info.GetFiles();
                foreach (FileInfo file in files)
                {
                    if (file.CreationTime < DateTime.Now.AddDays(-maxAgeDays))
                    {
                        _log.Debug($"deleting {file.Name}");
                        file.Delete();
                        cnt++;
                    }
                }
                _log.Info($"deleted {cnt} files from READY");
            }
            catch(Exception ex)
            {
                _log.ErrorFormat("Error trying to delete old files: {0}", ex.Message);
            }
        }

        /// <summary>
        /// class to read transmitter result xml files
        /// </summary>
        [Serializable]
        public class result
        {
            public result() { }
            public int code { get; set; }
            public string message { get; set; }
            public string detail { get; set; }

            /// <summary>
            /// create result items from file
            /// </summary>
            public static result ReadResult(string filename)
            {
                result aResult = null;
                try
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(result));
                    if (!File.Exists(filename))
                    {
                        _log.WarnFormat("Expected file {0} does not exist!", filename);
                    }
                    else
                    {
                        using (FileStream fs = new FileStream(filename, FileMode.Open))
                        {
                            aResult = (result)serializer.Deserialize(fs);
                        }
                    }
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Exception deserializing transmitter result: {0}", ex.Message);
                }
                return aResult;
            }
        }
    }
}