#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 Laenge
            //! \param length Die Laenge 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);
            //! Loescht den Array
            DLLEXPORT ~Bytes();
            //! Befuellt den Bytearray durch kopieren der Bytes
            //! \param daten Die Bytes, die kopiert werden sollen
            DLLEXPORT void setBytes(const char* daten);
            //! Loescht den Array und erzeugt einen neuen
            //! \param daten Die Bytes, die kopiert werden sollen
            //! \param length Die naenge des Arrays
            DLLEXPORT void setBytes(const char* daten, int length);
            //! Loescht den Array und uebernimmt den uebergebenen ohne zu kopieren
            //! \param daten Der neue Byte Array
            //! \param length Die naenge 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 Laenge des Arrays zurueck
            DLLEXPORT int getLength() const;
            //! Gibt den Array von Bytes zurueck
            DLLEXPORT char* getBytes() const;
        };

        //! Kann Bytesequenzen mit bestimmten Schluesseln verschluesseln und
        //! entschluesseln
        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 Schluessel
            //! \param s Der Schluessel, der zum verschluesseln und entchluesseln
            //! verwendet werden soll \param length Die Laenge des Schluessels
            DLLEXPORT Key(const char* s, int length);
            //! Loescht das Zeichnung
            DLLEXPORT ~Key();
            //! Setzt die Position im Schluessel, wo mit dem verschluesseln und
            //! entschluesseln begonnen werden soll \param p Die Position im
            //! Schluessel
            DLLEXPORT void setPos(__int64 p);
            //! Setzt den Schluessel, der zum ver- und entschluesseln verwendet
            //! werden soll \param s Der Schluessel \param length Die Laenge des
            //! Schluessels
            DLLEXPORT void setKey(const char* s, int length);
            //! Verschluesselt einen Byte Array mit dem gesetzten Schluessel
            //! \param daten Der Byte Array, der verschluesselt werden soll. Wird
            //! von der Funktion veraendert
            DLLEXPORT void codieren(Bytes* daten);
            //! Entschluesselt einen Byte Array mit dem gesetzten Schluessel
            //! \param daten Der Byte Array, der entschluesselt werden soll. Wird
            //! von der Funktion veraendert
            DLLEXPORT void decodieren(Bytes* daten);
        };
    } // namespace Encryption
} // namespace Framework

#endif