#ifndef Key_H
#define Key_H

#include "Betriebssystem.h"
#include "ReferenceCounter.h"

namespace Framework
{
    namespace Encryption
    {
        //! Speichert einen Array von bytes
        class Bytes : public virtual ReferenceCounter
        {
        private:
            char* bytes;
            bool del;
            int length;

        public:
            //! Erzeugt einen lehren Byte Array
            DLLEXPORT Bytes();
            //! Erzeugt einen neuen Byte Array mit bestimmter Länge
            //! \param length Die Länge des Arrays
            DLLEXPORT Bytes(int length);
            //! Erzeugt ein neuen Byte Array durch kopieren der bytes
            //! \param daten Die Bytes, die kopiert werden sollen
            //! \param length Die Anzahl der Bytes die kopiert werden sollen
            DLLEXPORT Bytes(const char* daten, int length);
            //! Löscht den Array
            DLLEXPORT ~Bytes();
            //! Befüllt den Bytearray durch kopieren der Bytes
            //! \param daten Die Bytes, die kopiert werden sollen
            DLLEXPORT void setBytes(const char* daten);
            //! Löscht den Array und erzeugt einen neuen
            //! \param daten Die Bytes, die kopiert werden sollen
            //! \param length Die nänge des Arrays
            DLLEXPORT void setBytes(const char* daten, int length);
            //! Löscht den Array und übernimmt den übergebenen ohne zu kopieren
            //! \param daten Der neue Byte Array
            //! \param length Die nänge des Arrays
            DLLEXPORT void setBytesZ(char* daten, int length);
            //! Setzt alle Bytes des Arrays auf einen bestimmten Wert
            //! \param c Der Wert, auf den die Bytes gesetzt werden sollen
            DLLEXPORT void fill(const char c);
            //! Setzt eine bestimmte Anzahl von Bytes des Arrays auf einen
            //! bestimmten Wert \param c Der Wert, auf den die Bytes gesetzt
            //! werden sollen \param len Die Anzahl der Bytes die gesetzt werden
            //! sollen
            DLLEXPORT void fill(const char c, int len);
            //! Setzt einen bestimmte Abschnitt von Bytes des Arrays auf einen
            //! bestimmten Wert \param c Der Wert, auf den die Bytes gesetzt
            //! werden sollen \param beg Die Startposition des zu setzenden
            //! Abschnittes \param end Die Endposition des zu setzenden
            //! Abschnittes (nicht enthalten)
            DLLEXPORT void fill(const char c, int beg, int end);
            //! Kopiert bestimmte bytes in den Array
            //! \param c Die Bytes, die kopiert werden sollen
            //! \param cLength Die Anzahl an Bytes, die gesetzt werden sollen
            DLLEXPORT void fill(const char* c, int cLength);
            //! Setzt ein bestimmtes Byte auf einen Wert
            //! \param c Der Wert, auf den das Byte gesetzt werden soll
            //! \param pos Die Position des Bytes im Array
            DLLEXPORT void set(const char c, int pos);
            //! Gibt die Länge des Arrays zurück
            DLLEXPORT int getLength() const;
            //! Gibt den Array von Bytes zurück
            DLLEXPORT char* getBytes() const;
        };

        //! Kann Bytesequenzen mit bestimmten Schlüsseln verschlüsseln und
        //! entschlüsseln
        class Key : public virtual ReferenceCounter
        {
        private:
            unsigned char* key;
            int length;
            int pos;

        public:
            //! Erzeugt ein leeres Zeichnung
            DLLEXPORT Key();
            //! Erzeugt ein neues Zeichnung mi einem Schlüssel
            //! \param s Der Schlüssel, der zum verschlüsseln und entchlüsseln
            //! verwendet werden soll \param length Die Länge des Schlüssels
            DLLEXPORT Key(const char* s, int length);
            //! Löscht das Zeichnung
            DLLEXPORT ~Key();
            //! Setzt die Position im Schlüssel, wo mit dem verschlüsseln und
            //! entschlüsseln begonnen werden soll \param p Die Position im
            //! Schlüssel
            DLLEXPORT void setPos(__int64 p);
            //! Setzt den Schlüssel, der zum ver- und entschlüsseln verwendet
            //! werden soll \param s Der Schlüssel \param length Die Länge des
            //! Schlüssels
            DLLEXPORT void setKey(const char* s, int length);
            //! Verschlüsselt einen Byte Array mit dem gesetzten Schlüssel
            //! \param daten Der Byte Array, der verschlüsselt werden soll. Wird
            //! von der Funktion verändert
            DLLEXPORT void codieren(Bytes* daten);
            //! Entschlüsselt einen Byte Array mit dem gesetzten Schlüssel
            //! \param daten Der Byte Array, der entschlüsselt werden soll. Wird
            //! von der Funktion verändert
            DLLEXPORT void decodieren(Bytes* daten);
        };
    } // namespace Encryption
} // namespace Framework

#endif