using ServiceShared;
using ServiceShared.Crypto;
using ServiceShared.Database;
using ServiceShared.Models.HL7;
using ServiceShared.Models.Response;

namespace ServiceInside.Service
{
    public class BackgroundWorker
    {
        private enum AckTypes { SUBSCRIBE, UNSUBSCRIBE, DELETE_DEVICE, PICKEDUP, ERROR }

        /// <summary>
        /// Directory path of private files(hl7). This directory must not be accessible by outside service
        /// </summary>
        private static string _PrivateDirectory;

        /// <summary>
        /// Ack directory inside of PrivateDirectory(it will be created automatically)
        /// </summary>
        private static string _PrivateDirectoryAck;

        /// <summary>
        /// Ack done directory inside of PrivateDirectoryAck(it will be created automatically)
        /// </summary>
        private static string _PrivateDirectoryAckDone;

        /// <summary>
        /// Directory path of public files(encrypted pdf). This directory must contain only encrypted files and can be accessed by outside with a valid/authorized request
        /// No access over filesystem for outside service
        /// </summary>
        private static string _PublicDirectory;

        /// <summary>
        /// Queue of Workers
        /// </summary>
        private static List<string> WorkerThreadIds = null;

        /// <summary>
        /// Locks operations on the worker threads
        /// </summary>
        private static bool _WorkerThreadsLock = false;

        /// <summary>
        /// Number of max worker threads at same time
        /// </summary>
        private static int MaxWorkerThreads = 10;

        /// <summary>
        /// Number of tries to check not found results
        /// </summary>
        private static int MaxTryNotFoundResults = 2;

        /// <summary>
        /// Checking interval for not found results
        /// </summary>
        private static int CheckNotFoundResultsIntervalMinutes = 24;

        /// <summary>
        /// BackgroundWorker Thread
        /// </summary>
        private static Thread _workerThread;

        /// <summary>
        /// BackgroundWroker for missing actions (next try of not found results, not notified completed results)
        /// </summary>
        private static Thread _workerThreadMissingActions;

        /// <summary>
        /// Flag if BackgroundWorker is running
        /// </summary>
        private static bool _Running = false;

        /// <summary>
        /// Results database controller
        /// </summary>
        private static ServiceShared.Database.Controllers.Results dbResults;

        /// <summary>
        /// Sets parameter for BackgroundWorker
        /// </summary>
        /// <param name="privateDirectory">Directory path of private files(hl7). This directory must be private and outside service must not have access on this path</param>
        /// <param name="publicDirectory">Directory path of public files(encrypted pdf). This directory contains encrypted files and can be accessed by outside with a valid/authorized request</param>
        /// <param name="maxWorkerThreads">Number of allowed worker threads at the same time</param>
        /// <param name="maxTryNotFoundResults">Number of posible tries to check not found results, else sends not found notification to patient</param>
        /// <param name="checkNotFoundResultsIntervalMinutes">Timeinterval for checking not found results in minutes</param>
        public static void SetParameters(string privateDirectory, string publicDirectory, DbContext dbContext, int maxWorkerThreads = 10, int maxTryNotFoundResults = 2, int checkNotFoundResultsIntervalMinutes = 24)
        {
            _PrivateDirectory = privateDirectory;
            _PublicDirectory = publicDirectory;
            MaxWorkerThreads = maxWorkerThreads;
            MaxTryNotFoundResults = maxTryNotFoundResults;
            CheckNotFoundResultsIntervalMinutes = checkNotFoundResultsIntervalMinutes;

            if(CheckNotFoundResultsIntervalMinutes < 5)
            {
                CheckNotFoundResultsIntervalMinutes = 5;
            }

            WorkerThreadIds = new List<string>();
            dbResults = new ServiceShared.Database.Controllers.Results(dbContext);

            try
            {
                if(!Directory.Exists(_PrivateDirectory))
                {
                    Directory.CreateDirectory(_PrivateDirectory);
                }

                if (!Directory.Exists(_PublicDirectory))
                {
                    Directory.CreateDirectory(_PublicDirectory);
                }

                _PrivateDirectoryAck = Path.Combine(_PrivateDirectory, "ack");

                if (!Directory.Exists(_PrivateDirectoryAck))
                {
                    Directory.CreateDirectory(_PrivateDirectoryAck);
                }

                _PrivateDirectoryAckDone = Path.Combine(_PrivateDirectoryAck, "done");

                if (!Directory.Exists(_PrivateDirectoryAckDone))
                {
                    Directory.CreateDirectory(_PrivateDirectoryAckDone);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "ServiceInside.Service.BackgroundWorker", "SetParameters");
            }
        }

        /// <summary>
        /// Starts the background working
        /// </summary>
        public static void Start()
        {
            try
            {
                if(_Running)
                {
                    Stop();
                }

                _workerThread = new Thread(WorkAsync);
                _workerThread.Start();

                _workerThreadMissingActions = new Thread(CheckMissingActionsAsync);
                _workerThreadMissingActions.Start();
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "Start");
            }
        }

        /// <summary>
        /// Stops the background working
        /// </summary>
        public static void Stop()
        {
            try
            {
                _Running = false;
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "Stop");
            }
        }

        /// <summary>
        /// Creates subscribe ack log file for the primary system
        /// </summary>
        /// <param name="pgs">pgs that was currently created</param>
        /// <param name="udid">device id where the pgs was currently created</param>
        public static void Subscribe(string pgs, string udid)
        {
            try
            {
                if (!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid))
                {
                    ServiceShared.Models.Database.Results results = dbResults.GetResults(pgs, udid);

                    if (results != null && CreateAck(results.UDID, results.PGS, results.PGS_HASH, AckTypes.SUBSCRIBE))
                    {
                        Log.Trace(AckTypes.SUBSCRIBE.ToString(), results.PGS, results.UDID);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "Subscribe(string, string)");
            }
        }

        /// <summary>
        /// Creates unsubscribe ack log file for the primary system and removes results if already exists from the storages
        /// </summary>
        /// <param name="pgs">pgs that should be unsubscripted</param>
        /// <param name="pgs_hash">pgs aes encrypted value</param>
        /// <param name="udid">device id where the pgs was created</param>
        public static void Unsubscribe(string pgs, string pgs_hash, string udid)
        {
            try
            {
                if (!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid))
                {
                    DeleteFilesFor(pgs, udid);

                    if (CreateAck(udid, pgs, pgs_hash, AckTypes.UNSUBSCRIBE))
                    {
                        Log.Trace(AckTypes.UNSUBSCRIBE.ToString(), pgs, udid);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "Unsubscribe(string, string, string)");
            }
        }

        /// <summary>
        /// Creates delete device ack log file for the primary system
        /// </summary>
        /// <param name="udid">udid hash(partial pk)</param>
        /// <param name="verificator_hash">verificator_hash, that validate the client permission</param>
        /// <returns>returns true if all data of udid have been deleted from the app services</returns>
        public static bool DeleteDevice(string udid, string verificator_hash)
        {
            bool result = false;

            try
            {
                if (!string.IsNullOrEmpty(udid) && !string.IsNullOrEmpty(verificator_hash))
                {
                    ServiceShared.Models.Database.Device device = dbResults.GetDevice(udid);

                    if(device != null)
                    {
                        List<ServiceShared.Models.Database.Results> results = dbResults.GetDeviceResults(udid, verificator_hash);

                        if (results != null && results.Count > 0)
                        {
                            foreach (ServiceShared.Models.Database.Results res in results)
                            {
                                DeleteFilesFor(res.PGS, res.UDID);
                                Log.Trace("device deleted", res.PGS, res.UDID);
                            }

                            if (dbResults.DeleteDevice(udid, verificator_hash))
                            {
                                results = dbResults.GetDeviceResults(udid, verificator_hash);
                                result = (results == null || results.Count <= 0);
                            }
                        }
                        else
                        {
                            result = true;
                        }
                    }
                    else
                    {
                        result = true;
                    }

                    if (result && dbResults.DeleteDevice(udid, verificator_hash))
                    {
                        CreateAck(udid, null, null, AckTypes.DELETE_DEVICE, (device != null ? device.PatHash : null));
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "DeleteDevice(string, string)");
            }

            return result;
        }

        /// <summary>
        /// Returns encrypted results as download object if it´s already available and has COMPLETED status
        /// </summary>
        /// <param name="pgs">pgs of results(PK part)</param>
        /// <param name="udid">udid of results(PK part)</param>
        /// <returns>Returns download object, that contains encrypted results</returns>
        public static Download GetDownload(string pgs, string udid)
        {
            Download result = null;

            try
            {
                if (!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid))
                {
                    ServiceShared.Models.Database.Results results = dbResults.GetResults(pgs, udid);

                    if (results.Available &&
                        results.Status == ServiceShared.Models.Database.Results.ResultsStatus.COMPLETED && 
                        !string.IsNullOrEmpty(results.ServerPublicKey))
                    {
                        string file = Path.Combine(_PublicDirectory, GetFileName(results.PGS, results.UDID));

                        if (File.Exists(file))
                        {
                            result = new Download();
                            result.server_public_key = results.ServerPublicKey;
                            result.encrypted_content = File.ReadAllText(file);
                            result.pgs = results.PGS;
                            result.udid = results.UDID;
                            Log.Trace("get_download", results.PGS, results.UDID);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "GetDownload(string, string)");
            }

            return result;
        }

        /// <summary>
        /// Moves results file to the done or error directory in the public area, depended on successfully pickedup checksum
        /// If pickedup was successfully it removes the original results from the private storage
        /// </summary>
        /// <param name="pgs">pgs of results(PK part)</param>
        /// <param name="udid">udid of results(PK part)</param>
        /// <param name="file_checksum">checksum of content(base64) after decryption, that was pickedup by patient</param>
        public static void SetPickedUpResultsAsync(string pgs, string udid, string file_checksum)
        {
            try
            {
                if (!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid))
                {
                    Thread thread = new Thread(() =>
                    {
                        ServiceShared.Models.Database.Results results = dbResults.GetResults(pgs, udid);

                        if (results != null &&
                            results.PickedUp &&
                            !string.IsNullOrEmpty(results.FileChecksum) &&
                            results.FileChecksum == file_checksum)
                        {
                            string file = Path.Combine(_PublicDirectory, GetFileName(results.PGS, results.UDID));

                            if (File.Exists(file))
                            {
                                File.Delete(file);
                            }

                            CreateAck(results.UDID, results.PGS, results.PGS_HASH, AckTypes.PICKEDUP);

                            DeleteFilesFor(results.PGS, results.UDID);
                        }
                    });

                    thread.Start();
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "SetPickedUpResultsAsync(string, string, string)");
            }
        }

        /// <summary>
        /// Checks missing or failed actions like notification on completed results or not found results
        /// </summary>
        private static void CheckMissingActionsAsync()
        {
            try
            {
                _Running = true;

                while (_Running)
                {
                    Log.Debug("[BW] check missing actions");

                    Log.Debug("[BW] check not found results (Interval: " + CheckNotFoundResultsIntervalMinutes + ", MaxTry: " + MaxTryNotFoundResults + ")");

                    /** check not found results after x Minutes (it should be minimum 5 minutes) **/
                    List<ServiceShared.Models.Database.Results> notFoundResults = dbResults.GetNotFoundResults(CheckNotFoundResultsIntervalMinutes, MaxTryNotFoundResults);

                    if(notFoundResults != null && notFoundResults.Count > 0)
                    {
                        Log.Debug("[BW] found not found results (" + notFoundResults.Count + ")");

                        foreach(ServiceShared.Models.Database.Results results in notFoundResults)
                        {
                            CreateAck(results.UDID, results.PGS, results.PGS_HASH, AckTypes.SUBSCRIBE);
                        }
                    }

                    /** check not notified completed results **/
                    List<ServiceShared.Models.Database.Results> complitedNotNotfiedResults = dbResults.GetNotNotifiedResults();

                    if(complitedNotNotfiedResults != null && complitedNotNotfiedResults.Count > 0)
                    {
                        Log.Debug("[BW] found not notified completed results (" + complitedNotNotfiedResults.Count + ")");

                        foreach (ServiceShared.Models.Database.Results results in complitedNotNotfiedResults)
                        {
                            Notification notification = new Notification();
                            notification.pgs = results.PGS;
                            notification.udid = results.UDID;
                            notification.created = DateTime.Now;
                            notification.status = results.Status;
                            notification.available = results.Available;
                            notification.available_ts = results.AvailableTS;

                            Log.Debug("[BW] try next notification PGS(" + results.PGS + ")");

                            ServiceOutside.Notify(notification);
                        }
                    }

                    /** check not found & not notificated results **/
                    List<ServiceShared.Models.Database.Results> notFoundNotNotfiedResults = dbResults.GetNotFoundNotNotifiedResults(MaxTryNotFoundResults);

                    if (notFoundNotNotfiedResults != null && notFoundNotNotfiedResults.Count > 0)
                    {
                        Log.Debug("[BW] found not notified not found results (" + notFoundNotNotfiedResults.Count + ")");

                        foreach (ServiceShared.Models.Database.Results results in notFoundNotNotfiedResults)
                        {
                            Notification notification = new Notification();
                            notification.pgs = results.PGS;
                            notification.udid = results.UDID;
                            notification.created = DateTime.Now;
                            notification.status = results.Status;
                            notification.available = false;
                            notification.available_ts = null;

                            Log.Debug("[BW] try next notification PGS(" + results.PGS + ") for not found");

                            ServiceOutside.Notify(notification);
                        }
                    }

                    // Sleep 5 minutes
                    Thread.Sleep(((1000 * 60) * 5));
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "CheckMissingActionsAsync");
            }
        }

        /// <summary>
        /// Works in background
        /// </summary>
        private static void WorkAsync()
        {
            try
            {
                _Running = true;

                while(_Running)
                {
                    string[] files = Directory.GetFiles(_PrivateDirectory, "*.hl7");

                    if (files != null && files.Length > 0)
                    {
                        int i = 0;

                        foreach(string file in files)
                        {
                            try
                            {
                                if(FileCanBeRead(file))
                                {
                                    if (i > MaxWorkerThreads)
                                    {
                                        break;
                                    }

                                    string newThreadId = SHA512.Encrypt(file);

                                    if (WorkerThreadIds.Count < MaxWorkerThreads && !WorkerThreadIds.Contains(newThreadId) && !_WorkerThreadsLock)
                                    {
                                        WorkerThreadIds.Add(newThreadId);
                                        ParameterizedThreadStart workerStart = new ParameterizedThreadStart(DoWorkAsync);
                                        Thread workerThread = new Thread(workerStart);
                                        workerThread.Start(new object[] { workerThread, file, newThreadId });
                                    }

                                    i++;
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "WorkAsync(Step)");
                            }
                            finally
                            {
                                Thread.Sleep(200);
                            }
                        }
                    }

                    Thread.Sleep(200);
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "WorkAsync");
            }
        }

        /// <summary>
        /// Single work with hl7 file from working directory
        /// </summary>
        /// <param name="args">array of arguments [0] = workerThread, [1] = hl7 file</param>
        private static void DoWorkAsync(object args)
        {
            string file = null;
            Thread workerThread = null;
            string workerThreadId = null;

            try
            {
                if(args != null)
                {
                    object[] param = (object[])args;

                    if(param != null && param.Length == 3)
                    {
                        workerThread = (Thread)param[0];
                        file = (string)param[1];
                        workerThreadId = (string)param[2];

                        Log.Debug("[BW] File: " + file);
                        Log.Debug("[BW] ThreadId: " + workerThreadId);

                        if (!string.IsNullOrEmpty(file) && File.Exists(file) && FileCanBeRead(file))
                        {
                            MDM mdm = ServiceShared.HL7.Parser.GetMDM(file);

                            if (mdm != null)
                            {
                                ServiceShared.Models.Database.Results results = null;
                                Notification notification = null;
                                string pgs = "";

                                if (!string.IsNullOrEmpty(mdm.PGSInitial) && !string.IsNullOrEmpty(mdm.UDID))
                                {
                                    pgs = mdm.PGSInitial;
                                    results = dbResults.GetResults(mdm.PGSInitial, mdm.UDID);
                                }
                                else 
                                {
                                    pgs = mdm.PGS();
                                    results = dbResults.GetResults(mdm.PGS(), mdm.UDID);
                                }

                                Log.Debug("[BW] PGS: " + pgs);
                                Log.Debug("[BW] UDID: " + mdm.UDID);
                                Log.Debug("[BW] ZIP: " + mdm.Zip);
                                Log.Debug("[BW] Birthday: " + mdm.Birthday);
                                Log.Debug("[BW] SampleId: " + mdm.SampleId);
                                Log.Debug("[BW] Status: " + mdm.ResultsStatus);

                                if (results != null)
                                {
                                    Log.Debug("[BW] in db exists: ");
                                   
                                    notification = new Notification();
                                    notification.pgs = results.PGS;
                                    notification.udid = results.UDID;
                                    notification.created = DateTime.Now;
                                    notification.status = mdm.ResultsStatus;

                                    if (mdm.ResultsStatus == ServiceShared.Models.Database.Results.ResultsStatus.COMPLETED)
                                    {
                                        notification.available = true;
                                        notification.available_ts = mdm.TimeStamp;

                                        KeyPair keyPair = Curve25519.GenerateKeyPair();
                                        byte[] deriveKey = keyPair.GetSharedKey(results.ClientPublicKey!);

                                        if (deriveKey == null || deriveKey.Length <= 0 ||
                                           !WriteEncryptedToPublic(mdm.PGS(), mdm.UDID, mdm.Base64Content, deriveKey) ||

                                           !dbResults.UpdateStatus(results.PGS, 
                                                                    results.UDID, 
                                                                    true, 
                                                                    keyPair.PublicKey, 
                                                                    SHA512.Encrypt(mdm.Base64Content), 
                                                                    mdm.TimeStamp, 
                                                                    mdm.ResultsStatus,
                                                                    mdm.PAT_HASH()))
                                        {
                                            results = null;
                                            notification = null;

                                            Log.Critical(new Exception("Could not move to the encrypted public storage" + file + ")"), "ServiceInside.Service.BackgroundWorker", "DoWorkAsync(object)");
                                        }
                                    }
                                    else if(mdm.ResultsStatus == ServiceShared.Models.Database.Results.ResultsStatus.REJECTED)
                                    {
                                        Log.Debug("[BW] Status - Rejexted: " + file);
                                        notification.available = false;
                                        notification.available_ts = null;
                                        dbResults.SetReject(results.PGS, results.UDID);
                                        DeleteFilesFor(results.PGS, results.UDID);
                                    }
                                    else if (mdm.ResultsStatus == ServiceShared.Models.Database.Results.ResultsStatus.NOT_FOUND)
                                    {
                                        Log.Debug("[BW] Status - NOT_FOUND: " + file);
                                        
                                        if((results.NotFoundCounter + 1) >= MaxTryNotFoundResults)
                                        {
                                            notification.available = false;
                                            notification.available_ts = null;
                                        } 
                                        else
                                        {
                                            notification = null;
                                        }

                                        dbResults.SetNotFound(results.PGS, results.UDID);
                                        DeleteFilesFor(results.PGS, results.UDID);
                                    }
                                    else
                                    {
                                        CreateAck(results.PGS, results.PGS_HASH, AckTypes.ERROR, results.UDID, file, "MDM has no valid ResultsStatus file");
                                        Log.Critical(new Exception("MDM has no valid ResultsStatus file: " + file), "ServiceInside.Service.BackgroundWorker", "DoWorkAsync");
                                    }
                                }
                                else
                                {
                                    // Get device by udid to get public key for encryption
                                    ServiceShared.Models.Database.Device device = dbResults.GetDevice(mdm.UDID);

                                    if (device != null && !string.IsNullOrEmpty(device.ClientPublicKey))
                                    {
                                        Log.Debug("[BW] device(" + mdm.UDID + ") in db found:");

                                        KeyPair keyPair = Curve25519.GenerateKeyPair();
                                        byte[] deriveKey = keyPair.GetSharedKey(device.ClientPublicKey!);

                                        if (deriveKey != null && deriveKey.Length > 0 && 
                                            WriteEncryptedToPublic(mdm.PGS(), mdm.UDID, mdm.Base64Content, deriveKey))
                                        {
                                            ServiceShared.Models.Database.Results newResults = new ServiceShared.Models.Database.Results();

                                            newResults.PGS = mdm.PGS();
                                            newResults.PGS_HASH = mdm.PGS_HASH(mdm.UDID);
                                            newResults.Available = true;
                                            newResults.AvailableTS = mdm.TimeStamp;
                                            newResults.Status = mdm.ResultsStatus;
                                            newResults.DeviceToken = device.DeviceToken;
                                            newResults.DeviceType = device.DeviceType;
                                            newResults.ClientPublicKey = device.ClientPublicKey;
                                            newResults.UDID = device.UDID;
                                            newResults.VerificationHash = device.VerificationHash;
                                            newResults.ServerPublicKey = keyPair.PublicKey;
                                            newResults.FileChecksum = SHA512.Encrypt(mdm.Base64Content);

                                            if (dbResults.Create(newResults))
                                            {
                                                notification = new Notification();
                                                notification.pgs = mdm.PGS();
                                                notification.udid = mdm.UDID;
                                                notification.available = true;
                                                notification.available_ts = mdm.TimeStamp;
                                                notification.status = mdm.ResultsStatus;
                                                notification.created = DateTime.Now;
                                            }
                                            else
                                            {
                                                Log.Critical(new Exception("Could not create results in database MDM(" + file + ")"), "ServiceInside.Service.BackgroundWorker", "DoWorkAsync(object)");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        Log.Debug("[BW] device " + mdm.UDID + " not found in db");
                                    }
                                }

                                if (notification != null)
                                {
                                    Log.Debug("[BW] notify");
                                    ServiceOutside.Notify(notification);
                                }

                                Log.Trace("mdm(" + mdm.ResultsStatus + ")", pgs, mdm.UDID);
                            }
                            else
                            {
                                Log.Critical(new Exception("Not valid MDM(" + file + ")"), "ServiceInside.Service.BackgroundWorker", "DoWorkAsync(object)");
                            }

                            Log.Debug("[BW] delete file " + file);

                            // Delte original hl7 file
                            File.Delete(file);
                        }
                        else
                        {
                            Log.Debug("[BW] File: " + file + " not exists");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                if(ex != null && 
                   !string.IsNullOrEmpty(ex.Message) && 
                   !ex.Message.Contains("process cannot access the file"))
                {
                    Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "DoWorkAsync(object)");
                }
                
                if(!string.IsNullOrEmpty(file) && File.Exists(file))
                {
                    File.Delete(file);
                }
            }
            finally
            {
                if(!string.IsNullOrEmpty(file))
                {
                    FreeWorker(workerThreadId);
                }
            }
        }

        /// <summary>
        /// Deletes files for pgs and udid
        /// </summary>
        /// <param name="pgs">pgs that should be used in the new filename</param>
        /// <param name="udid">udid that should be used in the new filename</param>
        private static void DeleteFilesFor(string pgs, string udid)
        {
            try
            {
               if(!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid))
               {
                    // Delete from public storage
                    string file = Path.Combine(_PublicDirectory, GetFileName(pgs, udid));
                    if(!string.IsNullOrEmpty(file) && File.Exists(file))
                    {
                        File.Delete(file);
                    }

                    // Delte from private storage
                    file = Path.Combine(_PrivateDirectory, GetFileName(pgs, udid, "hl7"));
                    if (!string.IsNullOrEmpty(file) && File.Exists(file))
                    {
                        File.Delete(file);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "DeleteFilesFor(string, string)");
            }
        }

        /// <summary>
        /// Encrypts and writes a content to the public directory
        /// </summary>
        /// <param name="pgs">pgs of results that will used as filename</param>
        /// <param name="udid">udid of results that will used as filename</param>
        /// <param name="content">content that should be encrypted</param>
        /// <param name="deriveKey">shared derive key that should be used for the encrypton</param>
        /// <returns></returns>
        private static bool WriteEncryptedToPublic(string pgs, string udid, string content, byte[] deriveKey)
        {
            bool result = false;

            try
            {
                if(!string.IsNullOrEmpty(pgs) && !string.IsNullOrEmpty(udid) && !string.IsNullOrEmpty(content) && deriveKey != null && deriveKey.Length > 0)
                {
                    string encryptedFile = Path.Combine(_PublicDirectory, GetFileName(pgs, udid));
                    string encrypted = AES.Encrypt(content, deriveKey);
                    File.WriteAllText(encryptedFile, encrypted);
                    result = File.Exists(encryptedFile);

                    Log.Trace("encrypted move to (" + encryptedFile + ")", pgs, udid);
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "WriteToPublic(string, string, string, byte[])");
            }

            return result;
        }

        /// <summary>
        /// Removes worher Thread from the queue list
        /// </summary>
        /// <param name="threadId">Worker thread id</param>
        private static void FreeWorker(string threadId)
        {
            try
            {
                if(threadId != null)
                {
                    if (WorkerThreadIds.Contains(threadId))
                    {
                        WorkerThreadIds.Remove(threadId);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "ServiceInside.Service.BackgroundWorker", "FreeWorker");
            }
        }

        /// <summary>
        /// Returns filename by pgs and udid SHA512 hash
        /// </summary>
        /// <param name="pgs">pgs hash that should be used in filename</param>
        /// <param name="udid">udid that should be used in filename</param>
        /// <param name="extension">file extension if should be set</param>
        /// <param name="addTimestamp">flag if filename should be sufixed by timestamp</param>
        /// <returns>returns SHA512 hash by (pgs + udid).extension</returns>
        private static string GetFileName(string pgs, string udid, string extension = null, bool addTimestamp = false)
        {
            string result = null;

            if(!string.IsNullOrEmpty(udid))
            {
                result = SHA512.Encrypt(udid + (!string.IsNullOrEmpty(pgs) ? pgs : "")) + (addTimestamp ? "_" + DateTime.Now.ToString("yyyyMMddHHmmss") : "") + (!string.IsNullOrEmpty(extension) ? "." + extension.ToLower() : "");
            }
            
            return result;
        }

        /// <summary>
        /// Creates a ack log file for primary system 
        /// </summary>
        /// <param name="udid">udid of mobile client</param>
        /// <param name="pgs">pgs SHA512</param>
        /// <param name="pgs_hash">pgs_hash AES Encrypted</param>
        /// <param name="type">type of ack log file</param>
        /// <param name="pat_hash">pat_hash AES Encrypted</param>
        /// <returns></returns>
        private static bool CreateAck(string udid, string pgs, string pgs_hash, AckTypes type, string pat_hash = null)
        {
            bool result = false;

            try
            {
                string ack = "TYPE:" + type.ToString() + "\r\n";
                ack += "UDID:" + udid + "\r\n";

                if (!string.IsNullOrEmpty(pgs))
                {
                    ack += "PGS:" + pgs + "\r\n";

                    if (!string.IsNullOrEmpty(pgs_hash))
                    {
                        string decrypted_values = AES.Decrypt(pgs_hash, AES.GetKey(udid + AES.PGS_ENCRYPT_PARTIAL_KEY));

                        if (!string.IsNullOrEmpty(decrypted_values))
                        {
                            string[] values = decrypted_values.Split('|');

                            if (values.Length == 3)
                            {
                                ack += "ZIP:" + values[0] + "\r\n";
                                ack += "BIRTHDATE:" + values[1] + "\r\n";
                                ack += "ORDER_ID:" + values[2] + "\r\n";
                            }
                        }
                    }
                }

                if(!string.IsNullOrEmpty(pat_hash))
                {
                    string decrypted_pat_id = AES.Decrypt(pat_hash);

                    if(!string.IsNullOrEmpty(decrypted_pat_id))
                    {
                        ack += "PAT_ID:" + decrypted_pat_id + "\r\n";
                    }
                }

                ack += "CREATED:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                string ack_file = Path.Combine(_PrivateDirectoryAck, GetFileName(pgs, udid, "log", true));

                if (File.Exists(ack_file))
                {
                    File.Delete(ack_file);
                }

                File.WriteAllText(ack_file, ack);

                result = File.Exists(ack_file);
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "CreateAck(string, string, AckTypes");
            }

            return result;
        }

        /// <summary>
        /// Creates a ack log file for primary system 
        /// </summary>
        /// <param name="pgs">pgs for the error log file</param>
        /// <param name="pgs_hash">pgs_hash that can be decrypted for plz, geb.datum, sampleid</param>
        /// <param name="type">type of ack log file</param>
        /// <param name="udid">udid for the error log file</param>
        /// <param name="filename">filename, that contains error</param>
        /// <param name="reason">reason of error</param>
        private static bool CreateAck(string pgs, string pgs_hash, AckTypes type, string udid = null, string filename = null, string reason = null)
        {
            bool result = false;

            try
            {
                string ack = "TYPE:" + type.ToString() + "\r\n";
                ack += "UDID:" + udid + "\r\n";

                if (!string.IsNullOrEmpty(pgs))
                {
                    ack += "PGS:" + pgs + "\r\n";

                    if(!string.IsNullOrEmpty(pgs_hash))
                    {
                        string decrypted_values = AES.Decrypt(pgs_hash, AES.GetKey(udid + AES.PGS_ENCRYPT_PARTIAL_KEY));

                        if (!string.IsNullOrEmpty(decrypted_values))
                        {
                            string[] values = decrypted_values.Split('|');

                            if (values.Length == 3)
                            {
                                ack += "ZIP:" + values[0] + "\r\n";
                                ack += "BIRTHDATE:" + values[1] + "\r\n";
                                ack += "ORDER_ID:" + values[2] + "\r\n";
                            }
                        }
                    }
                }

                if (!string.IsNullOrEmpty(filename))
                {
                    ack += "FILENAME:" + filename + "\r\n";
                }

                if (!string.IsNullOrEmpty(reason))
                {
                    ack += "REASON:" + reason + "\r\n";
                }

                ack += "CREATED:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                string ack_file = Path.Combine(_PrivateDirectoryAck, GetFileName(pgs, udid, "log", true));

                if (File.Exists(ack_file))
                {
                    File.Delete(ack_file);
                }

                File.WriteAllText(ack_file, ack);

                result = File.Exists(ack_file);
            }
            catch (Exception ex)
            {
                Log.Critical(ex, "ServiceInside.Service.BackgroundWorker", "CreateErrorLog(string, AckTypes, string, string, string)");
            }

            return result;
        }

        /// <summary>
        /// Checks if file exists and it can be read
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        private static bool FileCanBeRead(string file)
        {
            bool result = false;

            try
            {
                if (!string.IsNullOrEmpty(file) && File.Exists(file))
                {
                    using (var fs = new FileStream(file, FileMode.Open))
                    {
                        result = fs.CanRead;
                    }
                }
            }
            catch
            {

            }

            return result;
        }

        /// <summary>
        /// Returns private directory path
        /// </summary>
        /// <returns></returns>
        public static string GetPrivateDirectory()
        {
            return _PrivateDirectory;
        }

        /// <summary>
        /// Returns private directory ack path
        /// </summary>
        /// <returns></returns>
        public static string GetPrivateDirectoryAck()
        {
            return _PrivateDirectoryAck;
        }

        /// <summary>
        /// Returns private directory ack done path
        /// </summary>
        /// <returns></returns>
        public static string GetPrivateDirectoryAckDone()
        {
            return _PrivateDirectoryAckDone;
        }

        /// <summary>
        /// Returns public directory path
        /// </summary>
        /// <returns></returns>
        public static string GetPublicDirectory()
        {
            return _PublicDirectory;
        }
    }
}