using NUnit.Framework;
using ServiceShared.Models.Response;
using ServiceShared.Models.Response.Exception;
using ServiceShared.Crypto;
using System;
using System.Text.Json;
using ServiceShared.Models.Request;
using ServiceShared.Https;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using static ServiceShared.Models.Database.Device;

namespace ServiceOutsideTests.Controllers
{
    public class ResultsController : BaseTestController
    {
        public ResultsController() : base()
        {
        }

        /**
         * Publick Key has not been exchanged with server
         */
        [Test]
        public void WrongClient()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            // Public Key has not been exchanged
            byte[] base64Encoded = Convert.FromBase64String(keyPair.PublicKey);
            Assert.IsNotNull(base64Encoded); 
            byte[] sharedKey = keyPair.GetSharedKey(keyPair.PublicKey); //Wrong Server Public Key
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);

            encryptedRequest.encrypted_content = encryptedRequest.encrypted_content;

            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidClientException exception = encryptedResponse.Decrypt<InvalidClientException>(keyPair.GetSharedKey(keyPair.PublicKey));
            Assert.IsNull(encryptedResponse.descriptor);
        }

        /**
         * Encrypted Content has been modifed on the way
         */
        [Test]
        public void InvalidHMAC()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            encryptedRequest.encrypted_content = encryptedRequest.encrypted_content + "A"; // Encrypted Content has been modified on the way

            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidClientException exception = encryptedResponse.Decrypt<InvalidClientException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidClient);
        }

        /**
         * Called API Method was not found(Invalid Request)
         */
        [Test]
        public void InvalidRequest()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", "dasdasdasdasd", sharedKey); // dasdasdasdasd is not valid method
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidRequestException exception = encryptedResponse.Decrypt<InvalidRequestException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidRequest);
        }

        [Test]
        public void MissingPGS()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "pgs");
        }

        [Test]
        public void MissingUDID()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "udid");
        }

        [Test]
        public void MissingDeviceToken()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "device_token");
        }

        [Test]
        public void MissingClientPublicKey()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.device_token = this.DeviceToken;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "client_public_key");
        }

        [Test]
        public void MissingDeviceType()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "device_type");
        }

        [Test]
        public void WrongLengthPGS()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = "test";
            
            for(int i = 0; i < 300; i++)
            {
                subscribe.pgs += i.ToString();
            }

            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "pgs" && exception.reason == "wrong length");
        }

        [Test]
        public void WrongLengthUDID()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = "12345";
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "udid" && exception.reason == "wrong length");
        }

        [Test]
        public void WrongLengthDeviceToken()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = "ass";
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "device_token" && exception.reason == "wrong length");
        }

        [Test]
        public void WrongLengthClientPublicKey()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = "sassas";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "client_public_key" && exception.reason == "wrong length");
        }

        [Test]
        public void MissingVerificatorHash()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "verificator_hash");
        }

        [Test]
        public void WrongLengthVerificatorHash()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = "12345";
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "verificator_hash" && exception.reason == "wrong length");
        }

        [Test]
        public void MissingPIN()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            MissingArgumentException exception = encryptedResponse.Decrypt<MissingArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.MissingArgument && exception.argument == "pin");
        }

        [Test]
        public void WrongLengthPIN()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "1345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            InvalidArgumentException exception = encryptedResponse.Decrypt<InvalidArgumentException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.InvalidArgument && exception.argument == "pin");
        }

        [Test]
        public void AlreadySubscriptedSameDevice()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            AlreadySubscribtedException exception = encryptedResponse.Decrypt<AlreadySubscribtedException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.AlreadySubscribted);
        }

        [Test]
        public void AlreadySubscriptedDifferenceDevices()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.pin = "12345";
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            subscribe.udid = subscribe.udid + "A";

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            AlreadySubscribtedException exception = encryptedResponse.Decrypt<AlreadySubscribtedException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.AlreadySubscribted);
        }

        [Test]
        public void MaxOpenedRequestLimit()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
           
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = SHA512.HMAC("Test", AES.GetKey("TEST"));

            for (int i = 0; i < 11; i++)
            {
                subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());

                EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
                string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
                EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                MaxOpenedRequestLimitException exception = encryptedResponse.Decrypt<MaxOpenedRequestLimitException>(keyPair.GetSharedKey(publicKey.key));

                if (exception != null)
                {
                    Assert.IsTrue(exception.error_type == ResponseException.Types.MaxOpenedRequestLimit);
                    break;
                }
            }
        }

        [Test]
        public void Subscribe()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(sharedKey);
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            Thread.Sleep(5000);
            
            string[] files = Directory.GetFiles(@"C:\befund_app\private\ack", GetFileName(subscribe.pgs, subscribe.udid) + "*.log");
            Assert.IsTrue(files.Length > 0);
        }

        [Test]
        public void DifferencePGSOnSameDevice()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            for (int i = 0; i < 3; i++)
            {
                subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
                subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));

                EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
                string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
                EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
                Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");
            }
        }

        [Test]
        public void Unscribe()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "unsubscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");
        }

        [Test]
        public void UnscribeUnauthorizedOtherDevice()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            subscribe.udid = subscribe.udid + "1";

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "unsubscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            NotAuthorizedException exception = encryptedResponse.Decrypt<NotAuthorizedException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.NotAuthorized);
        }

        [Test]
        public void UnscribeUnauthorizedInvalidVerificatorHash()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.pin = "12345";
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST1"));

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "unsubscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            NotAuthorizedException exception = encryptedResponse.Decrypt<NotAuthorizedException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.NotAuthorized);
        }

        [Test]
        public void DeleteDevice()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);

            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            for (int i = 0; i < 3; i++)
            {
                subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
                subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));

                EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
                string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
                EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                MaxOpenedRequestLimitException exception = encryptedResponse.Decrypt<MaxOpenedRequestLimitException>(keyPair.GetSharedKey(publicKey.key));

                if (exception != null)
                {
                    Assert.IsTrue(exception.error_type == ResponseException.Types.MaxOpenedRequestLimit);
                    break;
                }
            }

            DeleteDevice deleteDevice = new DeleteDevice();
            deleteDevice.udid = subscribe.udid;
            deleteDevice.verificator_hash = subscribe.verificator_hash;

            EncryptedRequest encryptedRequest1 = new EncryptedRequest("DeleteDevice", subscribe, sharedKey);
            string response1 = Request.Post(this.ServiceOutsideHost, "results", "delete_device", encryptedRequest1, keyPair);
            EncryptedResponse encryptedResponse1 = JsonSerializer.Deserialize<EncryptedResponse>(response1, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse1.Decrypt(sharedKey);
            Assert.IsTrue(encryptedResponse1.descriptor.ToLower() == "success");

            encryptedRequest1 = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response1 = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest1, keyPair);
            encryptedResponse1 = JsonSerializer.Deserialize<EncryptedResponse>(response1, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            NotAvailableException exception1 = encryptedResponse1.Decrypt<NotAvailableException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception1);
            Assert.IsTrue(exception1.error_type == ResponseException.Types.NotAvailable);
        }

        [Test]
        public void SubscribeWithPatHash()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            ServiceShared.Models.Database.Status status = encryptedResponse.Decrypt<ServiceShared.Models.Database.Status>(keyPair.GetSharedKey(publicKey.key));
        }

        [Test]
        public void Status()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            ServiceShared.Models.Database.Status status = encryptedResponse.Decrypt<ServiceShared.Models.Database.Status>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(status);
            Assert.IsTrue(status.pgs == subscribe.pgs);
        }

        [Test]
        public void GetOpened()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string device_udid = Guid.NewGuid().ToString().Substring(0, 14);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            Subscribe subscribe = null;
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            EncryptedRequest encryptedRequest = null;
            EncryptedResponse encryptedResponse = null;
            string response = null;

            for (int i = 0; i < 5; i++)
            {
                byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
                Assert.IsNotNull(base64Encoded);
                subscribe = new Subscribe();
                subscribe.device_token = this.DeviceToken;
                subscribe.udid = device_udid;
                subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
                subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
                subscribe.client_public_key = keyPair.PublicKey;
                subscribe.device_type = DeviceTypes.IOS;
                subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
                subscribe.pin = "12345";
                encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
                response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
                encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
                Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            }

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "opened", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            List<ServiceShared.Models.Database.Status> status = encryptedResponse.Decrypt<List<ServiceShared.Models.Database.Status>>(keyPair.GetSharedKey(publicKey.key));

            Assert.IsNotNull(status);
            Assert.IsTrue(status.Count == 5);
        }

        [Test]
        public void GetPIN()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string device_udid = Guid.NewGuid().ToString().Substring(0, 14);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            Subscribe subscribe = null;
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            EncryptedRequest encryptedRequest = null;
            EncryptedResponse encryptedResponse = null;
            string response = null;

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = device_udid;
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "85476";
            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            GetPIN getPIN = new GetPIN();
            getPIN.udid = subscribe.udid;
            getPIN.verificator_hash = subscribe.verificator_hash;
            
            encryptedRequest = new EncryptedRequest("Subscribe", getPIN, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "pin", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            PIN pin = encryptedResponse.Decrypt<PIN>(keyPair.GetSharedKey(publicKey.key));

            Assert.IsNotNull(pin);
            Assert.IsTrue(pin.code == subscribe.pin);
        }

        [Test]
        public void UpdateVerificatorHash()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            EncryptedRequest encryptedRequest = null;
            string response = null;
            EncryptedResponse encryptedResponse = null;

            for (int i = 0; i < 3; i++)
            {
                subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
                encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
                response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
                encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                encryptedResponse.Decrypt(sharedKey);
                Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");
            }

            ChangeVerificatorHash changeVerificatorHash = new ChangeVerificatorHash();
            changeVerificatorHash.udid = subscribe.udid;
            changeVerificatorHash.pin = "77551";
            changeVerificatorHash.old_verificator_hash = subscribe.verificator_hash;
            changeVerificatorHash.new_verificator_hash = SHA512.HMAC("Test", AES.GetKey("TEST_NEW"));

            EncryptedRequest encryptedRequest1 = new EncryptedRequest("UpdateVerificatorHash", changeVerificatorHash, sharedKey);
            string response1 = Request.Post(this.ServiceOutsideHost, "results", "update_verificator_hash", encryptedRequest1, keyPair);
            EncryptedResponse encryptedResponse1 = JsonSerializer.Deserialize<EncryptedResponse>(response1, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse1.Decrypt(sharedKey);
            Assert.IsTrue(encryptedResponse1.descriptor.ToLower() == "success");

            subscribe.verificator_hash = changeVerificatorHash.new_verificator_hash;

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            ServiceShared.Models.Database.Status status = encryptedResponse.Decrypt<ServiceShared.Models.Database.Status>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(status);
            Assert.IsTrue(status.pgs == subscribe.pgs);

            subscribe.verificator_hash = changeVerificatorHash.old_verificator_hash;

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            NotAvailableException exception = encryptedResponse.Decrypt<NotAvailableException>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(exception);
            Assert.IsTrue(exception.error_type == ResponseException.Types.NotAvailable);
        }

        [Test]
        public void UpdateVerificatorHashNotAuthorized()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            subscribe.pgs_hash = AES.Encrypt(Guid.NewGuid().ToString(), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.pin = "12345";
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));

            EncryptedRequest encryptedRequest = null;
            string response = null;
            EncryptedResponse encryptedResponse = null;

            subscribe.pgs = SHA512.Encrypt(Guid.NewGuid().ToString());
            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(sharedKey);
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            ChangeVerificatorHash changeVerificatorHash = new ChangeVerificatorHash();
            changeVerificatorHash.udid = subscribe.udid;
            changeVerificatorHash.old_verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST1"));
            changeVerificatorHash.new_verificator_hash = SHA512.HMAC("Test", AES.GetKey("TEST_NEW"));

            EncryptedRequest encryptedRequest1 = new EncryptedRequest("UpdateVerificatorHash", changeVerificatorHash, sharedKey);
            string response1 = Request.Post(this.ServiceOutsideHost, "results", "update_verificator_hash", encryptedRequest1, keyPair);
            EncryptedResponse encryptedResponse1 = JsonSerializer.Deserialize<EncryptedResponse>(response1, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            NotAuthorizedException exception = encryptedResponse1.Decrypt<NotAuthorizedException>(sharedKey);
            Assert.IsTrue(exception.error_type == ResponseException.Types.NotAuthorized);
        }

        [Test]
        public void Download()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string birthday = "1987-01-04";
            string zip = "41238";
            string sampleid = Guid.NewGuid().ToString().Substring(0, 10);

            string new_pgs = SHA512.Encrypt(zip + birthday + sampleid);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = new_pgs;
            subscribe.pgs_hash = AES.Encrypt((zip + "|" + birthday + "|" + sampleid), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            string current_dir = AppDomain.CurrentDomain.BaseDirectory;
            string hl7_test_file = Path.Combine(current_dir, "TestFiles", "test.hl7");
            string inside_private_storage_path = @"c:\befund_app\private";
            string old_content = File.ReadAllText(hl7_test_file);

            string patid = Guid.NewGuid().ToString().Substring(0, 10);
            string new_content = old_content.Replace("[ZIP]", zip).Replace("[BIRTHDAY]", birthday).Replace("[SAMPLEID]", sampleid).Replace("[PATID]", patid).Replace("[UDID]", subscribe.udid).Replace("[STATUS]", "COMPLETED").Replace("[PGS]", subscribe.pgs);
            string file = Path.Combine(inside_private_storage_path, GetFileName(subscribe.pgs, subscribe.udid, "hl7"));

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

            File.WriteAllText(file, new_content);

            Thread.Sleep(10000);

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "download", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });

            Download download = encryptedResponse.Decrypt<Download>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "download");
            Assert.IsNotNull(download);
            string decrypt = AES.Decrypt(download.encrypted_content, keyPair.GetSharedKey(download.server_public_key));
            Assert.IsNotNull(decrypt);
            Assert.IsNotEmpty(decrypt);
        }

        [Test]
        public void SendResults()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string birthday = "1987-01-04";
            string zip = "41238";
            string sampleid = "0000000002";

            string new_pgs = SHA512.Encrypt(zip + birthday + sampleid);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = this.DeviceUDID;
            subscribe.pgs = new_pgs;
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));

            string current_dir = AppDomain.CurrentDomain.BaseDirectory;
            string hl7_test_file = Path.Combine(current_dir, "TestFiles", "test.hl7");
            string inside_private_storage_path = @"c:\befund_app\private";
            string old_content = File.ReadAllText(hl7_test_file);

            string patid = Guid.NewGuid().ToString().Substring(0, 10);
            string new_content = old_content.Replace("[ZIP]", zip).Replace("[BIRTHDAY]", birthday).Replace("[SAMPLEID]", sampleid).Replace("[PATID]", patid).Replace("[UDID]", subscribe.udid).Replace("[STATUS]", "COMPLETED").Replace("[PGS]", subscribe.pgs);
            string file = Path.Combine(inside_private_storage_path, GetFileName(subscribe.pgs, subscribe.udid, "hl7"));

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

            File.WriteAllText(file, new_content);
        }

        [Test]
        public void DownloadAndSetUpdatePickedUp()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string birthday = "19990101";
            string zip = "47774";
            string sampleid = Guid.NewGuid().ToString().Substring(0, 10);

            string new_pgs = SHA512.Encrypt(zip + birthday + sampleid);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = new_pgs;
            subscribe.pgs_hash = AES.Encrypt((zip + "|" + birthday + "|" + sampleid), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));
            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";

            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");

            string current_dir = AppDomain.CurrentDomain.BaseDirectory;
            string hl7_test_file = Path.Combine(current_dir, "TestFiles", "test.hl7");
            string inside_private_storage_path = @"c:\befund_app\private";
            string old_content = File.ReadAllText(hl7_test_file);

            string patid = Guid.NewGuid().ToString().Substring(0, 10);
            string new_content = old_content.Replace("[ZIP]", zip).Replace("[BIRTHDAY]", birthday).Replace("[SAMPLEID]", sampleid).Replace("[PATID]", patid).Replace("[UDID]", subscribe.udid).Replace("[STATUS]", "COMPLETED").Replace("[PGS]", subscribe.pgs);
            string file = Path.Combine(inside_private_storage_path, GetFileName(subscribe.pgs, subscribe.udid, "hl7"));

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

            File.WriteAllText(file, new_content);

            Thread.Sleep(10000);

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "download", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });

            Download download = encryptedResponse.Decrypt<Download>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "download");
            Assert.IsNotNull(download);
            string decryptBase64 = AES.Decrypt(download.encrypted_content, keyPair.GetSharedKey(download.server_public_key));
            Assert.IsNotNull(decryptBase64);
            Assert.IsNotEmpty(decryptBase64);

            CheckFileChecksum checkFileChecksum = new CheckFileChecksum();
            checkFileChecksum.udid = subscribe.udid;
            checkFileChecksum.pgs = subscribe.pgs;
            checkFileChecksum.device_token = subscribe.device_token;
            checkFileChecksum.verificator_hash = subscribe.verificator_hash;
            checkFileChecksum.device_type = subscribe.device_type;
            checkFileChecksum.client_public_key = subscribe.client_public_key;
            checkFileChecksum.file_checksum = SHA512.Encrypt(decryptBase64);

            encryptedRequest = new EncryptedRequest("CheckFileChecksum", checkFileChecksum, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "pickedup", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success" || encryptedResponse.descriptor.ToLower() == "status");

            Thread.Sleep(10000);

            string inside_private_storage_done_path = @"c:\befund_app\private" + GetFileName(subscribe.pgs, subscribe.udid, "hl7");
            string inside_public_storage_done_path = @"c:\befund_app\public" + GetFileName(subscribe.pgs, subscribe.udid); 
            string[] inside_private_storage_ack_path = Directory.GetFiles(@"C:\befund_app\private\ack", GetFileName(subscribe.pgs, subscribe.udid) + "*.log");
            Assert.IsFalse(File.Exists(inside_private_storage_done_path));
            Assert.IsFalse(File.Exists(inside_public_storage_done_path));
            Assert.IsTrue(inside_private_storage_ack_path.Length > 0);
        }

        [Test]
        public void RejectNotUniquePGS()
        {
            KeyPair keyPair = Curve25519.GenerateKeyPair();

            string birthday = "19990101";
            string zip = "47774";
            string sampleid = Guid.NewGuid().ToString().Substring(0, 10);

            string new_pgs = SHA512.Encrypt(zip + birthday + sampleid);

            PublicKey publicKey = Request.GetPublicKey(this.ServiceOutsideHost);
            Assert.IsNotNull(publicKey);
            Assert.IsNotNull(publicKey.key);
            Assert.IsNotEmpty(publicKey.key);

            byte[] base64Encoded = Convert.FromBase64String(publicKey.key);
            Assert.IsNotNull(base64Encoded);
            byte[] sharedKey = keyPair.GetSharedKey(publicKey.key);
            Subscribe subscribe = new Subscribe();
            subscribe.device_token = this.DeviceToken;
            subscribe.udid = Guid.NewGuid().ToString().Substring(0, 25);
            subscribe.pgs = new_pgs;
            subscribe.pgs_hash = AES.Encrypt((zip + "|" + birthday + "|" + sampleid), AES.GetKey(subscribe.udid + AES.PGS_ENCRYPT_PARTIAL_KEY));

            subscribe.client_public_key = keyPair.PublicKey;
            subscribe.device_type = DeviceTypes.IOS;
            subscribe.verificator_hash = ServiceShared.Crypto.SHA512.HMAC("Test", AES.GetKey("TEST"));
            subscribe.pin = "12345";
            EncryptedRequest encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            string response = Request.Post(this.ServiceOutsideHost, "results", "subscribe", encryptedRequest, keyPair);
            EncryptedResponse encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            encryptedResponse.Decrypt(keyPair.GetSharedKey(publicKey.key));
            Assert.IsTrue(encryptedResponse.descriptor.ToLower() == "success");
            
            string current_dir = AppDomain.CurrentDomain.BaseDirectory;
            string hl7_test_file = Path.Combine(current_dir, "TestFiles", "test.hl7");
            string inside_private_storage_path = @"c:\befund_app\private";

            string old_content = File.ReadAllText(hl7_test_file);
            string new_content = old_content.Replace("[ZIP]", zip).Replace("[BIRTHDAY]", birthday).Replace("[SAMPLEID]", sampleid).Replace("[PATID]", "1").Replace("[PGS]", new_pgs).Replace("[STATUS]", "REJECTED").Replace("[UDID]", subscribe.udid);

            string file = Path.Combine(inside_private_storage_path, GetFileName(new_pgs, subscribe.udid, "hl7"));
            File.WriteAllText(file, new_content);

            Thread.Sleep(3000);

            encryptedRequest = new EncryptedRequest("Subscribe", subscribe, sharedKey);
            response = Request.Post(this.ServiceOutsideHost, "results", "status", encryptedRequest, keyPair);
            encryptedResponse = JsonSerializer.Deserialize<EncryptedResponse>(response, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            ServiceShared.Models.Database.Status status = encryptedResponse.Decrypt<ServiceShared.Models.Database.Status>(keyPair.GetSharedKey(publicKey.key));
            Assert.IsNotNull(status);
            Assert.IsTrue(status.results_status == "REJECTED");
        }

        [Test]
        public void StressTest()
        {
            for(int i = 0; i < 100; i++)
            {
                string birthday = "19990101";
                string zip = "47774";
                string sampleid = Guid.NewGuid().ToString().Substring(0, 6) + i;

                string new_pgs = SHA512.Encrypt(zip + birthday + sampleid);

                string current_dir = AppDomain.CurrentDomain.BaseDirectory;
                string hl7_test_file = Path.Combine(current_dir, "TestFiles", "test.hl7");
                string inside_private_storage_path = @"c:\befund_app\private";

                string old_content = File.ReadAllText(hl7_test_file);
                string patid = (i % 2).ToString();
                string new_content = old_content.Replace("[ZIP]", zip).Replace("[BIRTHDAY]", birthday).Replace("[SAMPLEID]", sampleid).Replace("[PATID]", patid);
                string file = Path.Combine(inside_private_storage_path, new_pgs + "_" + MD5.Encrypt(SHA512.Encrypt(patid)) + ".hl7");

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

                File.WriteAllText(file, new_content);

            }
        }
    }
}