#include "cryptengine.h"

CryptEngine::CryptEngine(QObject *parent)
    : QObject(parent)
{
    m_algorithm  = 0; //Initialize NullCipher
    m_cryptClass = new CryptClassNullCipher;
}


CryptEngine::~CryptEngine()
{
    delete m_cryptClass;
}

void CryptEngine::generateRandomKey()
{
    m_cryptClass->generateRandomKey();
}

void CryptEngine::setKey(QString value)
{
    m_cryptClass->setKey( value.toLatin1() );
}

void CryptEngine::setKey(QByteArray value)
{
    m_cryptClass->setKey( value );
}

void CryptEngine::setKey(const uchar *value, int keyLength )
{
    m_cryptClass->setKey( value, keyLength );
}

QByteArray &CryptEngine::getKey()
{
    return m_cryptClass->getKey();
}

void CryptEngine::setCryptText(QByteArray value)
{
    m_cryptClass->setCryptText(value);
}

void CryptEngine::setCryptText(const uchar *value, int dataLength )
{
    m_cryptClass->setCryptText(value, dataLength);
}

void CryptEngine::setClearText(QByteArray value)
{
    m_cryptClass->setClearText(value);
}

void CryptEngine::setClearText(const uchar *value, int dataLength )
{
    m_cryptClass->setClearText(value, dataLength);
}

void CryptEngine::encrypt()
{
    //If cleartext present, set in CryptClass, encrypt, and fetch encrypted data
    if( m_cryptClass->getClearText().length() > 0 )
    {
        m_cryptClass->encrypt();
    }
}

void CryptEngine::decrypt()
{
    //If crypttext present, set in CryptClass, decrypt, and fetch decrypted data
    if( m_cryptClass->getCryptText().length() > 0 )
    {
        m_cryptClass->decrypt();
    }
}

void CryptEngine::oncipherSelected_triggered(int cipher)
{
    m_algorithm = cipher;

    //Get Instance of Singleton mapping Integers to String for Cipher description
    CiphersSingleton ciphers   = CiphersSingleton::getInstance();

    //Algorithm contains cipher as text.
    QString algorithm           = ciphers.textFromValue(m_algorithm);


    //delete old CryptClass and create new one according to selected algorithm
    if( algorithm == "NullCipher" )
    {
        delete m_cryptClass;
        m_cryptClass = new CryptClassNullCipher;
        qDebug("CryptEngine::oncipherSelected_triggered - NullCipher");
    }
    else if( algorithm == "Caesar" )
    {
        delete m_cryptClass;
        m_cryptClass = new CryptClassCaesar;
        qDebug("CryptEngine::oncipherSelected_triggered - Caesar");
    }
    else if( algorithm == "RC4" )
    {
        delete m_cryptClass;
        m_cryptClass = new CryptClassRc4;
        qDebug("CryptEngine::oncipherSelected_triggered - RC4");
    }
    else if( algorithm == "Cube" )
    {
//        delete m_cryptClass;
//        m_cryptClass = new CryptClassCube;
        qDebug("CryptEngine::oncipherSelected_triggered - Cube");
    }
    else if( algorithm == "AES" )
    {
//        delete m_cryptClass;
//        m_cryptClass = new CryptClassAES;
        qDebug("CryptEngine::oncipherSelected_triggered - AES");
    }
    else if( algorithm == "RSA" )
    {
//        delete m_cryptClass;
//        m_cryptClass = new CryptClassRSA;
        qDebug("CryptEngine::oncipherSelected_triggered - RSA");
    }
    else if( algorithm == "ECC" )
    {
//        delete m_cryptClass;
//        m_cryptClass = new CryptClassECC;
        qDebug("CryptEngine::oncipherSelected_triggered - ECC");
    }

    //Send Signal confirming if data is binary or not
    emit binaryData( m_cryptClass->getBinaryData() );
}

void CryptEngine::onkeylengthChanged(int value, bool symmetric)
{
    qDebug("CrptEngine::onkeylengthChanged - new Keylength: %d", value);

    m_cryptClass->setKeyLength(value);
}