#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 );
        };
    }
}

#endif