using log4net.Repository.Hierarchy;
using NFC.Crypto;
using NFC.ISO7816_4;
using NFC.Mifare_DESFire.Enums;
using NFC.NXP_MIFARE_DESFire.Exceptions;
using PCSC.Iso7816;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace NFC.Mifare_DESFire
{
    public class MIFARE_DESFire
    {
        // Docs https://hackmd.io/qATu8uYdRnOC40aFrB9afg

        #region Log
        private static readonly log4net.ILog _Log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        #endregion

        #region Contructors
        /// <summary>
        /// Construct MIFRARE_DESFire Object with ICard Interface
        /// </summary>
        /// <param name="card">Implementation of ICard, only transmit is used</param>
        public MIFARE_DESFire(ICard card)
        {
            _Card = card;
        }
        #endregion

        #region Properties
        /// <summary>
        /// ICard Implementation used to transmit APDUCommands and recive APDUResponses
        /// </summary>
        private ICard _Card;

        /// <summary>
        /// SessionKey, is set after Successfull Authentication
        /// </summary>
        public byte[] _SessionKey;

        /// <summary>
        /// Initialation Vector for CBC Encryption
        /// Is 0 bytes after Successfull Authentication
        /// </summary>
        public byte[] _IV;
        #endregion

        #region Methods
        #region Helper Methods
        /// <summary>
        /// Generate Byte Array filled with 0
        /// </summary>
        /// <param name="size">Size of Array</param>
        public byte[] GenerateEmptyKey(uint size)
        {
            byte[] key = new byte[size];
            for (int i = 0; i < size; i++)
            {
                key[i] = 0;
            }

            return key;
        }

        /// <summary>
        /// Converts byte[] to string with HEX Code
        /// No 0x is created
        /// </summary>
        /// <param name="data">Data</param>
        public string ConvertToHexString(byte[] data)
        {
            return BitConverter.ToString(data).Replace("-", "").ToLower();
        }

        /// <summary>
        /// Converts string with HEX Code to byte[]
        /// No 0x is requiered
        /// </summary>
        /// <param name="data">Data</param>
        public byte[] ConvertFromHexString(string data)
        {
            if (data.Length % 2 == 1)
                throw new Exception("Data Length is uneven.");

            byte[] arr = new byte[data.Length >> 1];

            for (int i = 0; i < data.Length >> 1; ++i)
            {
                arr[i] = (byte)((GetHexVal(data[i << 1]) << 4) + (GetHexVal(data[(i << 1) + 1])));
            }

            return arr;
        }

        /// <summary>
        /// Get Range of Array
        /// </summary>
        /// <param name="array"></param>
        /// <param name="offset"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public byte[] GetSubArray(byte[] array, long offset, long length)
        {
            byte[] subarray = new byte[length];
            for (long i = offset; i < offset + length; i++)
            {
                subarray[i - offset] = array[i];
            }
            return subarray;
        }

        private int GetHexVal(char hex)
        {
            int val = (int)hex;
            //For uppercase A-F letters:
            //return val - (val < 58 ? 48 : 55);
            //For lowercase a-f letters:
            //return val - (val < 58 ? 48 : 87);
            //Or the two combined, but a bit slower:
            return val - (val < 58 ? 48 : (val < 97 ? 55 : 87));
        }

        /// <summary>
        /// Check APDU Response for DESFire Error Codes
        /// https://www.nxp.com/docs/en/data-sheet/MF2DLHX0.pdf
        /// Section: 11.3
        /// </summary>
        public void CheckAPDUResponse(APDUResponse response)
        {
            if (response == null)
            {
                throw new ArgumentNullException("Response cannot be null.");
            }

            if (response.SW1 == 0x91)
            {
                switch (response.SW2)
                {
                    case 0x00: // OPERATION_OK
                        return;
                    case 0x0C: // NO_CHANGES
                        return;
                    case 0x1C: // ILLEGAL_COMMAND_CODE
                        throw new IllegalCommandCodeException();
                    case 0x1E: // INTEGRITY_ERROR
                        throw new IntegrityErrorException();
                    case 0x40: // NO_SUCH_KEY
                        throw new NoSuchKeyException();
                    case 0x7E: // LENGTH_ERROR
                        throw new LengthErrorException();
                    case 0x9D: // PERMISSION_DENIED
                        throw new PermissionDeniedException();
                    case 0x9E: // PARAMETER_ERROR
                        throw new ParameterErrorException();
                    case 0xAD: // AUTHENTICATION_DELAY
                        throw new AuthenticationDelayException();
                    case 0xAE: // AUTHENTICATION_ERROR
                        throw new AuthenticationErrorException();
                    case 0xAF: // ADDITIONAL_FRAME
                        return;
                    case 0xBE: // BOUNDARY_ERROR
                        throw new BoundaryErrorException();
                    case 0xCA: // COMMAND_ABORTED
                        throw new CommandAbortedException();
                    case 0xDE: // DUPLICATE_ERROR
                        throw new DuplicateErrorException();
                    case 0xF0: // FILE_NOT_FOUND
                        throw new FileNotFoundException();
                    default:
                        break;
                }
            }

            throw new Exception(string.Format("Unknown Response Code: 0x{0}.", BitConverter.ToString(new byte[] { response.SW1, response.SW2 }).Replace("-", string.Empty)));
        }
        #endregion

        #region Crypto Operation
        /// <summary>
        /// Return a copy of the last Block of data
        /// </summary>
        /// <param name="data">Data compatible to blocksize</param>
        /// <param name="blocksize">in byte</param>
        public byte[] ExtractLastBlock(byte[] data, uint blocksize)
        {
            if (data == null)
            {
                throw new ArgumentNullException("Data cannot be null.");
            }

            if (data.Length % blocksize != 0)
            {
                throw new ArgumentException(string.Format("Data is not compatible with blocksize(data(length):{0}, blocksize:{1}.", data.Length, blocksize));
            }

            byte[] lastblock = new byte[blocksize];

            for (int i = 0; i < blocksize; i++)
            {
                lastblock[i] = data[data.Length - blocksize + i];
            }

            return lastblock;
        }

        /// <summary>
        /// Rotates Array to the left
        /// </summary>
        /// <param name="data">Data</param>
        /// <returns>Copy of data</returns>
        public byte[] RotateLeft(byte[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("Data cannot be null.");
            }

            byte[] rotate = new byte[data.Length];
            data.CopyTo(rotate, 0);

            byte tmp = rotate[0];
            for (var i = 0; i < rotate.Length - 1; i++)
            {
                rotate[i] = rotate[i + 1];
            }
            rotate[rotate.Length - 1] = tmp;

            return rotate;
        }

        /// <summary>
        /// Rotates Array to the right
        /// </summary>
        /// <param name="data">Data</param>
        /// <returns>Copy of data</returns>
        public byte[] RotateRight(byte[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("Data cannot be null.");
            }

            byte[] rotate = new byte[data.Length];
            data.CopyTo(rotate, 0);

            byte tmp = rotate[rotate.Length - 1];
            for (var i = rotate.Length - 1; i > 0; i--)
            {
                rotate[i] = rotate[i - 1];
            }
            rotate[0] = tmp;

            return rotate;
        }

        /// <summary>
        /// Concatenates Arrays
        /// </summary>
        /// <param name="data">List of Byte Array</param>
        public byte[] Concatenate(params byte[][] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("Data cannot be null.");
            }

            List<byte> cat = new List<byte>();

            foreach(byte[] d in data)
            {
                cat.AddRange(d);
            }

            return cat.ToArray();
        }

        /// <summary>
        /// Boolean Operation XOR on all Bytes
        /// </summary>
        /// <param name="a">Array A</param>
        /// <param name="b">Array B</param>
        /// <returns>Copy of Data</returns>
        public byte[] XOR(byte[] a, byte[] b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("Array A cannot be null.");
            }

            if (b == null)
            {
                throw new ArgumentNullException("Array B cannot be null.");
            }

            if (a.Length != b.Length)
            {
                throw new ArgumentException(string.Format("Arrays are not same Length(Length A:{0}, Lenght B:{1})", a.Length, b.Length));
            }

            byte[] c = new byte[a.Length];

            for(int i = 0; i < a.Length; i++)
            {
                c[i] = (byte)(a[i] ^ b[i]);
            }

            return c;
        }

        /// <summary>
        /// Generates SessionKey for DES Authentification
        /// </summary>
        /// <returns>16Byte SessionKey</returns>
        public byte[] GenerateSesionKey_DES(byte[] rndA, byte[] rndB)
        {
            byte[] sesssionkey = new byte[8];

            for (int i = 0; i < sesssionkey.Length; i++)
            {
                if (i < 4)
                {
                    sesssionkey[i] = rndA[i];
                }
                else
                {
                    sesssionkey[i] = rndB[i - 4];
                }
            }

            // DES SessionKey is a double DES Key
            return Concatenate(sesssionkey, sesssionkey);
        }

        /// <summary>
        /// Generates SessionKey for AES Authentification
        /// </summary>
        /// <returns>16Byte SessionKey</returns>
        public byte[] GenerateSesionKey_AES(byte[] rndA, byte[] rndB)
        {
            byte[] sesssionkey = new byte[16];

            for (int i = 0; i < sesssionkey.Length; i++)
            {
                if (i < 4)
                {
                    sesssionkey[i] = rndA[i];
                }
                else if(i >= 4 && i < 8)
                {
                    sesssionkey[i] = rndB[i - 4];
                }
                else if (i >= 8 && i < 12)
                {
                    sesssionkey[i] = rndA[i + 4];
                }
                else
                {
                    sesssionkey[i] = rndB[i];
                }
            }

            return sesssionkey;
        }

        /// <summary>
        /// Set KeyVersion in DES Key
        /// KeyVersion is stored in LSB of the first 8 Bytes of the DES Key
        /// </summary>
        public byte[] SetKeyVersion(byte[] key, byte keyversion)
        {
            byte[] pow2 = new byte[]
            {
                0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
            };

            byte[] new_key = new byte[key.Length];
            key.CopyTo(new_key, 0);

            for (int i = 0; i < 8; i++)
            {
                if ((keyversion & pow2[i]) > 0)
                {
                    new_key[i] = (byte)(new_key[5] | 0x01);
                }
                else
                {
                    new_key[i] = (byte)(new_key[5] & 0x7F);
                }
            }

            return new_key;
        }

        /// <summary>
        /// Expand Array to Block Size, fill with 0x00
        /// </summary>
        /// <param name="data"></param>
        public byte[] ExpandToBlockSize(byte[] data, uint bocksize)
        {
            int diff = data.Length % (int)bocksize;
            if (diff == 0)
            {
                return data;
            }

            byte[] expand = new byte[data.Length + bocksize - diff];

            data.CopyTo(expand, 0);

            for (int i = expand.Length - 1; i > data.Length - 1; i--)
            {
                expand[i] = 0x00;
            }

            return expand;
        }
        #endregion

        #region DESFire Commands
        /// <summary>
        /// Authenticate to PICC, with ISO Authenticate
        /// </summary>
        /// <param name="key_id">0x01 - 0x0D</param>
        /// <param name="key"></param>
        /// <param name="rndA">!!! WARNING For Testing only !!!</param>
        /// <exception cref="AuthenticationDelayException">Retry after short Time</exception>
        public void AuthenticateISO_DES(byte key_id, byte[] key, byte[] rndA = null)
        {
            _Log.Debug("Start AuthenticateISO_DES");

            // Sepearte InitialisationVector for Authentication
            byte[] iv = new byte[8];

            APDUCommand cmd_challange_request = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0x1A,
                Data = new byte[]
                {
                    key_id
                }
            };
            _Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", ConvertToHexString(cmd_challange_request.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_challange_request);
            _Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            byte[] rndB_enc = response.Body;
            _Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_enc));

            TDES des = new TDES();
            byte[] rndB = des.Decrypt(rndB_enc, key, GenerateEmptyKey(8));
            _Log.DebugFormat("rndB: {0}", ConvertToHexString(rndB));

            rndB.CopyTo(iv, 0);

            byte[] rndB_rl = RotateLeft(rndB);
            _Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_rl));

            if(rndA == null)
            {
                Random rnd = new Random();
                rndA = new byte[8];
                rnd.NextBytes(rndA);
            }
            _Log.DebugFormat("rndA: {0}", ConvertToHexString(rndA));

            byte[] rndAB = Concatenate(rndA, rndB_rl);
            _Log.DebugFormat("rndAB: {0}", ConvertToHexString(rndAB));

            byte[] rndAB_enc = des.Encrypt(rndAB, key, rndB_enc);
            _Log.DebugFormat("rndA_rndB_enc: {0}", ConvertToHexString(rndAB_enc));
            iv = ExtractLastBlock(rndAB_enc, 8);

            APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xAF,
                Data = rndAB_enc
            };
            _Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray()));

            response = _Card.Transmit(cmd_challange_response);
            _Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray()));

            CheckAPDUResponse(response);

            byte[] encryptedRndAFromCard = response.Body;
            _Log.DebugFormat("encryptedRndAFromCard: {0}", ConvertToHexString(encryptedRndAFromCard));

            byte[] rotatedRndAFromCard = des.Decrypt(encryptedRndAFromCard, key, iv);
            _Log.DebugFormat("rotatedRndAFromCard: {0}", ConvertToHexString(rotatedRndAFromCard));

            byte[] rndAFromCard = RotateRight(rotatedRndAFromCard);
            _Log.DebugFormat("rndAFromCard: {0}", ConvertToHexString(rndAFromCard));

            if (!rndA.SequenceEqual(rndAFromCard))
            {
                throw new Exception("Authentication failed, PICC Challenge is not corret");
            }

            _SessionKey = GenerateSesionKey_DES(rndA, rndB);
            _Log.DebugFormat("_SessionKey: {0}", ConvertToHexString(_SessionKey));

            _IV = GenerateEmptyKey(8);
            _Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV));

            _Log.Debug("End AuthenticateISO_DES");
        }

        /// <summary>
        /// Format PICC
        /// </summary>
        public void Format()
        {
            _Log.Debug("Start Format");

            APDUCommand cmd_format = new APDUCommand(IsoCase.Case2Short)
            {
                CLA = 0x90,
                INS = 0xFC,
            };
            _Log.DebugFormat("APDU_CMD(cmd_format): {0}", ConvertToHexString(cmd_format.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_format);
            _Log.DebugFormat("APDU_RES(cmd_format): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End Format");
        }

        /// <summary>
        /// Create Application for ID
        /// </summary>
        /// <param name="aid">3 Byte ID</param>
        public void CreateApplication(UInt32 aid, byte keysetting1, byte keysetting2)
        {
            _Log.Debug("Start CreateApplication");

            byte[] id_byte = BitConverter.GetBytes(aid);
            _Log.DebugFormat("AID: {0}", ConvertToHexString(id_byte.ToArray()));

            APDUCommand cmd_CreateApplication = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xCA,
                Data = new byte[]
                {
                    id_byte[0],
                    id_byte[1],
                    id_byte[2],
                    keysetting1,
                    keysetting2
                }
            };
            _Log.DebugFormat("APDU_CMD(cmd_CreateApplication): {0}", ConvertToHexString(cmd_CreateApplication.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_CreateApplication);
            _Log.DebugFormat("APDU_RES(cmd_CreateApplication): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End CreateApplication");
        }

        /// <summary>
        /// Select Application by AID
        /// </summary>
        /// <param name="aid">3 Byte AID</param>
        public void SelectApplication(UInt32 aid)
        {
            _Log.Debug("Start SelectApplication");

            byte[] id_byte = BitConverter.GetBytes(aid);
            _Log.DebugFormat("AID: {0}", ConvertToHexString(id_byte.ToArray()));

            APDUCommand cmd_SelectApplication = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = (byte)APDUInstructions.SELECT_APPLICATION,
                Data = new byte[]
                {
                    id_byte[0],
                    id_byte[1],
                    id_byte[2]
                }
            };
            _Log.DebugFormat("APDU_CMD(cmd_SelectApplication): {0}", ConvertToHexString(cmd_SelectApplication.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_SelectApplication);
            _Log.DebugFormat("APDU_RES(cmd_SelectApplication): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End SelectApplication");
        }

        /// <summary>
        /// Authenticate to PICC, with ISO Authenticate
        /// </summary>
        /// <param name="key_id">0x01 - 0x0D</param>
        /// <param name="key"></param>
        /// <param name="rndA">!!! WARNING For Testing only !!!</param>
        /// <exception cref="AuthenticationDelayException">Retry after short Time</exception>
        public void AuthenticateISO_AES(byte key_id, byte[] key, byte[] rndA = null)
        {
            _Log.Debug("Start AuthenticateISO_AES");

            // Sepearte InitialisationVector for Authentication
            byte[] iv = new byte[16];

            APDUCommand cmd_challange_request = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xAA,
                Data = new byte[]
                {
                    key_id
                }
            };
            _Log.DebugFormat("APDU_CMD(cmd_challange_request): {0}", ConvertToHexString(cmd_challange_request.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_challange_request);
            _Log.DebugFormat("APDU_RES(cmd_challange_request): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            byte[] rndB_enc = response.Body;
            _Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_enc));

            AES aes = new AES();
            byte[] rndB = aes.Decrypt(rndB_enc, key, GenerateEmptyKey(16));
            _Log.DebugFormat("rndB: {0}", ConvertToHexString(rndB));

            rndB.CopyTo(iv, 0);

            byte[] rndB_rl = RotateLeft(rndB);
            _Log.DebugFormat("rndB_enc: {0}", ConvertToHexString(rndB_rl));

            if (rndA == null)
            {
                Random rnd = new Random();
                rndA = new byte[16];
                rnd.NextBytes(rndA);
            }
            _Log.DebugFormat("rndA: {0}", ConvertToHexString(rndA));

            byte[] rndAB = Concatenate(rndA, rndB_rl);
            _Log.DebugFormat("rndAB: {0}", ConvertToHexString(rndAB));

            byte[] rndAB_enc = aes.Encrypt(rndAB, key, rndB_enc);
            _Log.DebugFormat("rndA_rndB_enc: {0}", ConvertToHexString(rndAB_enc));
            iv = ExtractLastBlock(rndAB_enc, 16);

            APDUCommand cmd_challange_response = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xAF,
                Data = rndAB_enc
            };
            _Log.DebugFormat("APDU_CMD(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray()));

            response = _Card.Transmit(cmd_challange_response);
            _Log.DebugFormat("APDU_RES(cmd_challange_response): {0}", ConvertToHexString(cmd_challange_response.ToArray()));

            CheckAPDUResponse(response);

            byte[] encryptedRndAFromCard = response.Body;
            _Log.DebugFormat("encryptedRndAFromCard: {0}", ConvertToHexString(encryptedRndAFromCard));

            byte[] rotatedRndAFromCard = aes.Decrypt(encryptedRndAFromCard, key, iv);
            _Log.DebugFormat("rotatedRndAFromCard: {0}", ConvertToHexString(rotatedRndAFromCard));

            byte[] rndAFromCard = RotateRight(rotatedRndAFromCard);
            _Log.DebugFormat("rndAFromCard: {0}", ConvertToHexString(rndAFromCard));

            if (!rndA.SequenceEqual(rndAFromCard))
            {
                throw new Exception("Authentication failed, PICC Challenge is not corret");
            }

            _SessionKey = GenerateSesionKey_AES(rndA, rndB);
            _Log.DebugFormat("_SessionKey: {0}", ConvertToHexString(_SessionKey));

            _IV = GenerateEmptyKey(16);
            _Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV));

            _Log.Debug("End AuthenticateISO_DES");
        }

        /// <summary>
        /// Change Same DES key as Authenticated 
        /// </summary>
        /// <param name="key_id"></param>
        /// <param name="new_key"></param>
        /// <param name="key_version"></param>
        public void ChangeKey_DES(byte key_id, byte[] new_key, byte key_version)
        {
            _Log.Debug("Start ChangeKey_DES");

            byte[] header = new byte[]
            {
                0xC4, key_id
            };
            _Log.DebugFormat("header: {0}", ConvertToHexString(header));

            byte[] key_and_version = new_key;
            byte[] command = Concatenate(header, key_and_version);
            _Log.DebugFormat("command: {0}", ConvertToHexString(command));

            CRC32 crc32 = new CRC32();
            byte[] crc = crc32.Calculate(command);
            _Log.DebugFormat("crc: {0}", ConvertToHexString(crc));

            byte[] cryptogram = Concatenate(key_and_version, crc);
            _Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram));

            byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
            _Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block));

            TDES des = new TDES();
            byte[] cryptogram_enc = des.Encrypt(cryptogram_block, _SessionKey, _IV);
            _Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc));

            _IV = ExtractLastBlock(cryptogram_enc, 8);
            _Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV));

            byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
            _Log.DebugFormat("data: {0}", ConvertToHexString(data));

            APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xC4,
                Data = data
            };
            _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_ChangeKey);
            _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End ChangeKey_AES");
        }

        /// <summary>
        /// Change Same AES key as Authenticated 
        /// </summary>
        /// <param name="key_id"></param>
        /// <param name="new_key"></param>
        /// <param name="key_version"></param>
        public void ChangeKey_AES(byte key_id, byte[] new_key, byte key_version)
        {
            _Log.Debug("Start ChangeKey_AES");

            byte[] header = new byte[]
            {
                0xC4, key_id
            };
            _Log.DebugFormat("header: {0}", ConvertToHexString(header));

            // AES Key Version is Append to Key
            byte[] key_and_version = Concatenate(new_key, new byte[] { key_version });
            byte[] command = Concatenate(header, key_and_version);
            _Log.DebugFormat("command: {0}", ConvertToHexString(command));

            CRC32 crc32 = new CRC32();
            byte[] crc = crc32.Calculate(command);
            _Log.DebugFormat("crc: {0}", ConvertToHexString(crc));

            byte[] cryptogram = Concatenate(key_and_version, crc);
            _Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram));

            byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
            _Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block));

            AES aes = new AES();
            byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
            _Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc));

            _IV = ExtractLastBlock(cryptogram_enc, 16);
            _Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV));

            byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
            _Log.DebugFormat("data: {0}", ConvertToHexString(data));

            APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xC4,
                Data = data
            };
            _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_ChangeKey);
            _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End ChangeKey_AES");
        }

        /// <summary>
        /// Change other AES key as Authenticated 
        /// </summary>
        /// <param name="key_id"></param>
        /// <param name="new_key"></param>
        /// <param name="key_version"></param>
        public void ChangeOtherKey_AES(byte key_id, byte[] new_key, byte[] old_key, byte key_version)
        {
            _Log.Debug("Start ChangeOtherKey_AES");

            byte[] header = new byte[]
            {
                0xC4, key_id
            };
            _Log.DebugFormat("header: {0}", ConvertToHexString(header));

            byte[] key_xor = XOR(new_key, old_key);

            // AES Key Version is Append to Key
            byte[] key_and_version = Concatenate(key_xor, new byte[] { key_version });
            byte[] command = Concatenate(header, key_and_version);
            _Log.DebugFormat("command: {0}", ConvertToHexString(command));

            CRC32 crc32 = new CRC32();
            byte[] crc_cmd = crc32.Calculate(command);
            _Log.DebugFormat("crc_cmd: {0}", ConvertToHexString(crc_cmd));
            byte[] crc_key = crc32.Calculate(new_key);
            _Log.DebugFormat("crc_key: {0}", ConvertToHexString(crc_key));

            byte[] cryptogram = Concatenate(key_and_version, crc_cmd);
            cryptogram = Concatenate(cryptogram, crc_key);
            _Log.DebugFormat("cryptogram: {0}", ConvertToHexString(cryptogram));

            byte[] cryptogram_block = ExpandToBlockSize(cryptogram, 16);
            _Log.DebugFormat("cryptogram_block: {0}", ConvertToHexString(cryptogram_block));

            AES aes = new AES();
            byte[] cryptogram_enc = aes.Encrypt(cryptogram_block, _SessionKey, _IV);
            _Log.DebugFormat("cryptogram_enc: {0}", ConvertToHexString(cryptogram_enc));

            _IV = ExtractLastBlock(cryptogram_enc, 16);
            _Log.DebugFormat("_IV: {0}", ConvertToHexString(_IV));

            byte[] data = Concatenate(new byte[] { key_id }, cryptogram_enc);
            _Log.DebugFormat("data: {0}", ConvertToHexString(data));

            APDUCommand cmd_ChangeKey = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = 0xC4,
                Data = data
            };
            _Log.DebugFormat("APDU_CMD(cmd_ChangeKey): {0}", ConvertToHexString(cmd_ChangeKey.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_ChangeKey);
            _Log.DebugFormat("APDU_RES(cmd_ChangeKey): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End ChangeOtherKey_AES");
        }

        /// <summary>
        /// Create Standard Data File
        /// </summary>
        /// <param name="file_id">ID of File (0x01 - 0x10)</param>
        /// <param name="communication">Type of File Communicaton</param>
        /// <param name="accessRights">Access Rights for File</param>
        /// <param name="size">Size of File in Bytes</param>
        public void CreateFile_Standard(byte file_id, FileCommunication communication, UInt16 accessRights, UInt32 size)
        {
            _Log.Debug("Start CreateFile_Standard");

            _Log.DebugFormat("FID: {0}", file_id);

            byte[] accessRights_byte = BitConverter.GetBytes(accessRights);
            byte[] size_byte_tolong = BitConverter.GetBytes(size);
            // Use only 3 Bytes
            byte[] size_byte = new byte[]
            {
                size_byte_tolong[0],
                size_byte_tolong[1],
                size_byte_tolong[2],
            };

            byte[] data = new byte[]
            {
                file_id,
                (byte)communication
            };

            APDUCommand cmd_CreateFile_Standard = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = (byte)APDUInstructions.CREATE_STDDATAFILE,
                Data = Concatenate(data, accessRights_byte, size_byte)
            };
            _Log.DebugFormat("APDU_CMD(cmd_CreateFile_Standard): {0}", ConvertToHexString(cmd_CreateFile_Standard.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_CreateFile_Standard);
            _Log.DebugFormat("APDU_RES(cmd_CreateFile_Standard): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End CreateFile_Standard");
        }

        /// <summary>
        /// Read Data from File
        /// </summary>
        /// <param name="file_id">ID of File (0x01 - 0x10)</param>
        /// <param name="offset">Offset for File</param>
        /// <param name="length">Lenght of Data</param>
        public byte[] ReadData(byte file_id, UInt32 offset, UInt32 length)
        {
            _Log.Debug("Start ReadData");

            int max_read_bytes_pre_transaction = 58;
            long bytes_readed = 0;

            List<byte> read_data = new List<byte>();

            while (bytes_readed != length)
            {
                byte[] data = new byte[]
                {
                    file_id
                };

                byte[] offset_byte_tolong = BitConverter.GetBytes(offset + bytes_readed);
                // Use only 3 Bytes
                byte[] offset_byte = new byte[]
                {
                offset_byte_tolong[0],
                offset_byte_tolong[1],
                offset_byte_tolong[2],
                };

                long bytes_toread = 0;

                if (length - bytes_readed < max_read_bytes_pre_transaction)
                {
                    bytes_toread = length - bytes_readed;
                }
                else
                {
                    bytes_toread = max_read_bytes_pre_transaction;
                }

                byte[] length_byte_tolong = BitConverter.GetBytes(bytes_toread);
                bytes_readed += bytes_toread;
                
                // Use only 3 Bytes
                byte[] length_byte = new byte[]
                {
                    length_byte_tolong[0],
                    length_byte_tolong[1],
                    length_byte_tolong[2],
                };

                APDUCommand cmd_ReadData = new APDUCommand(IsoCase.Case4Short)
                {
                    CLA = 0x90,
                    INS = (byte)APDUInstructions.READ_DATA,
                    Data = Concatenate(data, offset_byte, length_byte)
                };
                _Log.DebugFormat("APDU_CMD(cmd_ReadData): {0}", ConvertToHexString(cmd_ReadData.ToArray()));

                APDUResponse response = _Card.Transmit(cmd_ReadData);
                _Log.DebugFormat("APDU_RES(cmd_ReadData): {0}", ConvertToHexString(response.ToArray()));
                
                CheckAPDUResponse(response);
                read_data.AddRange(response.Body);
            }
            _Log.Debug("End ReadData");

            return read_data.ToArray();
        }

        /// <summary>
        /// Write Data to File
        /// </summary>
        /// <param name="file_id">ID of File (0x01 - 0x10)</param>
        /// <param name="offset">Offset for File</param>
        /// <param name="data">Data to write</param>
        public void WriteData(byte file_id, UInt32 offset, byte[] data)
        {
            _Log.Debug("Start WriteData");

            byte[] file_id_array = new byte[]
            {
                file_id
            };

            byte[] offset_byte_tolong = BitConverter.GetBytes(offset);
            // Use only 3 Bytes
            byte[] offset_byte = new byte[]
            {
                offset_byte_tolong[0],
                offset_byte_tolong[1],
                offset_byte_tolong[2],
            };

            byte[] lenght_byte_tolong = BitConverter.GetBytes(data.Length);
            // Use only 3 Bytes
            byte[] lenght_byte = new byte[]
            {
                lenght_byte_tolong[0],
                lenght_byte_tolong[1],
                lenght_byte_tolong[2],
            };

            APDUCommand cmd_WriteData = new APDUCommand(IsoCase.Case4Short)
            {
                CLA = 0x90,
                INS = (byte)APDUInstructions.WRITE_DATA,
                Data = Concatenate(file_id_array, offset_byte, lenght_byte, data)
            };
            _Log.DebugFormat("APDU_CMD(cmd_WriteData): {0}", ConvertToHexString(cmd_WriteData.ToArray()));

            APDUResponse response = _Card.Transmit(cmd_WriteData);
            _Log.DebugFormat("APDU_RES(cmd_WriteData): {0}", ConvertToHexString(response.ToArray()));

            CheckAPDUResponse(response);

            _Log.Debug("End WriteData");
        }


        ///// <summary>
        ///// Write Data to File
        ///// </summary>
        ///// <param name="file_id">ID of File (0x01 - 0x10)</param>
        ///// <param name="offset">Offset for File</param>
        ///// <param name="data">Data to write</param>
        //public void WriteData(byte file_id, UInt32 offset, byte[] data)
        //{
        //    _Log.Debug("Start WriteData");

        //    int max_write_bytes_pre_transaction = 8;
        //    byte[] write_buffer;

        //    long bytes_writed = 0;
        //    long length = data.Length;

        //    while (bytes_writed != data.Length)
        //    {
        //        byte[] file_id_array = new byte[]
        //        {
        //            file_id
        //        };

        //        byte[] offset_byte_tolong = BitConverter.GetBytes(offset + bytes_writed);
        //        // Use only 3 Bytes
        //        byte[] offset_byte = new byte[]
        //        {
        //        offset_byte_tolong[0],
        //        offset_byte_tolong[1],
        //        offset_byte_tolong[2],
        //        };

        //        long bytes_towrite = 0;

        //        if (length - bytes_writed < max_write_bytes_pre_transaction)
        //        {
        //            bytes_towrite = length - bytes_writed;
        //        }
        //        else
        //        {
        //            bytes_towrite = max_write_bytes_pre_transaction;
        //        }

        //        byte[] length_byte_tolong = BitConverter.GetBytes(bytes_towrite);

        //        write_buffer = GetSubArray(data, bytes_writed, bytes_towrite);
        //        bytes_writed += bytes_towrite;

        //        // Use only 3 Bytes
        //        byte[] length_byte = new byte[]
        //        {
        //            length_byte_tolong[0],
        //            length_byte_tolong[1],
        //            length_byte_tolong[2],
        //        };

        //        APDUCommand cmd_WriteData = new APDUCommand(IsoCase.Case4Short)
        //        {
        //            CLA = 0x90,
        //            INS = (byte)APDUInstructions.WRITE_DATA,
        //            Data = Concatenate(file_id_array, offset_byte, length_byte, write_buffer)
        //        };
        //        _Log.DebugFormat("APDU_CMD(cmd_WriteData): {0}", ConvertToHexString(cmd_WriteData.ToArray()));

        //        APDUResponse response = _Card.Transmit(cmd_WriteData);
        //        _Log.DebugFormat("APDU_RES(cmd_WriteData): {0}", ConvertToHexString(response.ToArray()));

        //        CheckAPDUResponse(response);
        //    }

        //    _Log.Debug("End WriteData");
        //}

        /// <summary>
        /// Get all ApplicationIDS from PICC
        /// </summary>
        /// <returns>AIDs (3 Byte) as Array</returns>
        //public UInt32[] GetApplicationIDs()
        //{
        //    _Log.Debug("Start GetApplicationIDs");

        //    APDUCommand cmd = new APDUCommand(IsoCase.Case2Short)
        //    {
        //        CLA = 0x90,
        //        INS = (byte)APDUInstructions.GET_APPLICATION_IDS
        //    };

        //    APDUResponse response = _Card.Transmit(cmd);

        //    CheckAPDUResponse(response);

        //    if (response.Body.Length % 3 != 0)
        //    {
        //        throw new Exception(string.Format("Invalid body length (was: {0}).", response.Body.Length));
        //    }

        //    if (response.Body.Length == 0)
        //    {
        //        throw new Exception("Missing PICC Entry 0x000000.");
        //    }

        //    List<UInt32> applicationIDs = new List<UInt32>();

        //    for (int i = 0; i < response.Body.Length; i += 3)
        //    {
        //        UInt32 new_applicationID = 0;
        //        new_applicationID = (UInt32)((response.Body[i] << 16) + (response.Body[i + 1] << 8) + response.Body[i + 2]);
        //        applicationIDs.Add(new_applicationID);
        //    }

        //    _Log.Debug("End GetApplicationIDs");

        //    return applicationIDs.ToArray();
        //}

        /// <summary>
        /// Delete Application by ID
        /// </summary>
        /// <param name="id">3 Byte ID</param>
        //public void DeleteApplication(UInt32 id)
        //{
        //    byte[] id_byte = BitConverter.GetBytes(id);

        //    APDUCommand cmd = new APDUCommand(IsoCase.Case4Short)
        //    {
        //        CLA = 0x90,
        //        INS = (byte)APDUInstructions.DELETE_APPLICATION,
        //        Data = new byte[]
        //        {
        //            id_byte[0],
        //            id_byte[1],
        //            id_byte[2]
        //        },
        //        Le = 0x00
        //    };

        //    APDUResponse response = _Card.Transmit(cmd);
        //    CheckAPDUResponse(response);
        //}
        #endregion

        #region Configuration Generator
        /// <summary>
        /// Genearte KeySetting1 for Application Settings or PICC Setting
        /// </summary>
        public byte GenerateKeySetting1(ChangeApplicationKey changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
        {
            return (byte)(((byte)changeKey << 4) | (byte)changeMasterKeySettings | (byte)createDeleteFile | (byte)fileDirectoryAccess | (byte)changeMasterKey);
        }

        /// <summary>
        /// Genearte KeySetting1 for Application Settings or PICC Setting
        /// </summary>
        /// <param name="changeKey">ID of Key for changing Application Keys</param>
        /// <returns></returns>
        public byte GenerateKeySetting1(byte changeKey, ChangeMasterKeySettings changeMasterKeySettings, CreateDeleteFile createDeleteFile, FileDirectoryAccess fileDirectoryAccess, ChangeMasterKey changeMasterKey)
        {
            if (changeKey < 0x01 || changeKey >= 0x0E)
            {
                throw new ArgumentOutOfRangeException();
            }
            return GenerateKeySetting1(changeKey, changeMasterKeySettings, createDeleteFile, fileDirectoryAccess, changeMasterKey);
        }

        /// <summary>
        /// Genearte KeySetting2 for Application Creation
        /// </summary>
        /// <param name="numberOfKeys">Number of keys that can be stored within the application (0x01-0x0D)</param>
        /// <returns></returns>
        public byte GenerateKeySetting2(CryptoOperationsType cryptoOperations, FileIdentifies fileIdentifies, byte numberOfKeys)
        {
            if (numberOfKeys < 0x01 || numberOfKeys >= 0x0D)
            {
                throw new ArgumentOutOfRangeException();
            }

            return (byte)((byte)cryptoOperations | (byte)fileIdentifies | numberOfKeys);
        }

        /// <summary>
        /// Generate FileAccess Rights for File Settings
        /// Use enum AccesRights for Free or Never Option
        /// </summary>
        /// <param name="read">KeyID for Read Access</param>
        /// <param name="write">KeyID for Write Access</param>
        /// <param name="read_write">KeyID for Read and Write Access</param>
        /// <param name="configure">KeyID for Configuration Access</param>
        public UInt16 GenerateFileAccessRights(byte read, byte write, byte read_write, byte configure)
        {
            if(read > 0x0F || write > 0x0F || read_write > 0x0F || configure > 0x0F)
            {
                throw new ArgumentOutOfRangeException("One KeyID is not valid");
            }

            return (UInt16)((read << 12) | (write << 8) | (read_write << 4) | configure);
        }
        #endregion
        #endregion
    }
}