using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Configuration;
using Newtonsoft.Json;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace AIAHTML5.API.Controllers
{
    public class ConfigurationController : ApiController
    {
        [Route("api/Configuration/GetConfigurationvalues")]
        [HttpGet]
         public HttpResponseMessage GetConfigurationvalues()
        {
            dynamic responseData;
            MyConfig mconfig = new MyConfig();
            mconfig.current_year= DateTime.Now.Year;
            mconfig.idleTime = Int32.Parse(ConfigurationManager.AppSettings["IDLE_TIME"]);
            mconfig.idelTimeOut = Int32.Parse(ConfigurationManager.AppSettings["IDLE_TIME_OUT"]);
            mconfig.pingInterval = Int32.Parse(ConfigurationManager.AppSettings["PING_INTERVAL"]);
            mconfig.serverPath = ConfigurationManager.AppSettings["ANIMATION_HOSTING_SERVER"];
            mconfig.fileSize = Int32.Parse(ConfigurationManager.AppSettings["UploadMaxFileSize"]);
            mconfig.aodSiteUrl = ConfigurationManager.AppSettings["Aod_site_Url"];

            var plainkey = ConfigurationManager.AppSettings["aiapasskey"];

            AdamOnDemand aod = new AdamOnDemand();

            mconfig.aodkeypass = aod.Encrypt(plainkey);

           // var simplekey= aod.Decrypt(mconfig.aodkeypass);

            responseData = JsonConvert.SerializeObject(mconfig);
            
            return new HttpResponseMessage { StatusCode = HttpStatusCode.OK, Content = new StringContent(responseData) };
        }
    }
}
public class MyConfig
{
    public int current_year { get; set; }
    public int idleTime { get; set; }
    public int idelTimeOut { get; set; }
    public int pingInterval { get; set; }
    public string serverPath { get; set; }
    public int fileSize { get; set; }

    public string aodSiteUrl { get; set; }
    public string aodkeypass { get; set; }
}


public class AdamOnDemand
{
    //Triple Des encription/decription
    public string Encrypt(string plainText)
    {
        string passPhrase = ConfigurationManager.AppSettings["EncryptionKey"].ToString();
        string saltValue = ConfigurationManager.AppSettings["SaltValue"].ToString();
        string hashAlgorithm = ConfigurationManager.AppSettings["HashAlgorithm"].ToString();
        int passwordIterations = Convert.ToInt32(ConfigurationManager.AppSettings["IterationCount"]);
        string initVector = ConfigurationManager.AppSettings["InitVector"].ToString();
        int keySize = Convert.ToInt32(ConfigurationManager.AppSettings["KeySize"]); ;


        return EncryptData(plainText, passPhrase, saltValue, hashAlgorithm,passwordIterations, initVector, keySize);
    }

    //Triple Des encription/decription
    public string Decrypt(string encryptedText)
    {
        string passPhrase = ConfigurationManager.AppSettings["EncryptionKey"].ToString();
        string saltValue = ConfigurationManager.AppSettings["SaltValue"].ToString();
        string hashAlgorithm = ConfigurationManager.AppSettings["HashAlgorithm"].ToString();
        int passwordIterations = Convert.ToInt32(ConfigurationManager.AppSettings["IterationCount"]);
        string initVector = ConfigurationManager.AppSettings["InitVector"].ToString();
        int keySize = Convert.ToInt32(ConfigurationManager.AppSettings["KeySize"]); ;


        return DecryptData(encryptedText, passPhrase, saltValue, hashAlgorithm,passwordIterations, initVector, keySize);
    }

    private string EncryptData(string plainText, string passPhrase, string saltValue, string hashAlgorithm,int passwordIterations, string initVector, int keySize)
    {
        // Convert strings into byte arrays.
        // Let us assume that strings only contain ASCII codes.
        // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
        // encoding.
        byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
        byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

        // Convert our plaintext into a byte array.
        // Let us assume that plaintext contains UTF8-encoded characters.
        byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

        // First, we must create a password, from which the key will be derived.
        // This password will be generated from the specified passphrase and 
        // salt value. The password will be created using the specified hash 
        // algorithm. Password creation can be done in several iterations.
        PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);

        // Use the password to generate pseudo-random bytes for the encryption
        // key. Specify the size of the key in bytes (instead of bits).
        byte[] keyBytes = password.GetBytes(keySize / 8);

        // Create uninitialized Rijndael encryption object.
        RijndaelManaged symmetricKey = new RijndaelManaged();

        // It is reasonable to set encryption mode to Cipher Block Chaining
        // (CBC). Use default options for other symmetric key parameters.
        symmetricKey.Mode = CipherMode.CBC;

        // Generate encryptor from the existing key bytes and initialization 
        // vector. Key size will be defined based on the number of the key 
        // bytes.
        ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);

        // Define memory stream which will be used to hold encrypted data.
        MemoryStream memoryStream = new MemoryStream();

        // Define cryptographic stream (always use Write mode for encryption).
        CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
        // Start encrypting.
        cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

        // Finish encrypting.
        cryptoStream.FlushFinalBlock();

        // Convert our encrypted data from a memory stream into a byte array.
        byte[] cipherTextBytes = memoryStream.ToArray();

        // Close both streams.
        memoryStream.Close();
        cryptoStream.Close();

        // Convert encrypted data into a base64-encoded string.
        string cipherText = Convert.ToBase64String(cipherTextBytes);

        // Return encrypted string.
        return cipherText;
    }

    private string DecryptData(string encryptedText, string passPhrase, string saltValue, string hashAlgorithm, int passwordIterations, string initVector, int keySize)
    {
        try
        {
            // arrays. Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

            // Convert our encryptedvalue into a byte array.
            byte[] cipherTextBytes = Convert.FromBase64String(encryptedText);

            // First, we must create a password, from which the key will be 
            // derived. This password will be generated from the specified 
            // passphrase and salt value. The password will be created using
            // the specified hash algorithm. Password creation can be done in
            // several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);

            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);

            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged();

            // It is reasonable to set encryption mode to Cipher Block Chaining
            // (CBC). Use default options for other symmetric key parameters.
            symmetricKey.Mode = CipherMode.CBC;

            // Generate decryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);

            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = new MemoryStream(cipherTextBytes);

            // Define cryptographic stream (always use Read mode for encryption).
            CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);

            // Since at this point we don't know what the size of decrypted data
            // will be, allocate the buffer long enough to hold ciphertext;
            // plaintext is never longer than ciphertext.
            byte[] plainTextBytes = new byte[cipherTextBytes.Length];

            // Start decrypting.
            int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);

            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();

            // Convert decrypted data into a string. 
            // Let us assume that the original plaintext string was UTF8-encoded.
            string plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);

            // Return decrypted string.   
            return plainText;

        }
        catch( Exception ex)
        {
            return null;
        }
        // Convert strings defining encryption key characteristics into byte
       
    }

}