/*
 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 */
#include <QTest>

#include "eapqtconfiginterface_context.h"
#include "eapqtvalidator_stub.h"
#include "eapqtexpandedeaptype.h"

EapQtConfigInterfaceContext::EapQtConfigInterfaceContext() : 
    mEapQtConfig(NULL)
{
}

EapQtConfigInterfaceContext::~EapQtConfigInterfaceContext()
{
    mEapQtConfig->mValidator.clear();
}

void EapQtConfigInterfaceContext::setObject(EapQtConfigInterface *eapQtConfig)
{
    mEapQtConfig = eapQtConfig;
}

void EapQtConfigInterfaceContext::createEapAkaSim(int type)
{
    QList<EapQtPluginHandle> types;
    types.append((EapQtPluginHandle::Plugin)type);
    setSupportedOuterTypes(types);

    setSelectectedOuterTypes(types, true);
    
    EapQtConfig config;
    config.setValue(EapQtConfig::UsernameAutomatic, true);
    config.setValue(EapQtConfig::RealmAutomatic, true);
    setOuterConfig((EapQtPluginHandle::Plugin)type, config, true);
}

void EapQtConfigInterfaceContext::createLeap(
    const QString& username, 
    const QString& passwd)
{
    QList<EapQtPluginHandle> types;
    types.append(EapQtPluginHandle::PluginLeap);
    setSupportedOuterTypes(types);

    setSelectectedOuterTypes(types, true);
    
    EapQtConfig config;
    config.setValue(EapQtConfig::UsernameAutomatic, false);
    config.setValue(EapQtConfig::Username, username);
    config.setValue(EapQtConfig::PasswordPrompt, false);
    config.setValue(EapQtConfig::Password, passwd);
    setOuterConfig(EapQtPluginHandle::PluginLeap, config, true);
    
    // validators
    createInnerTypeValidators(EapQtPluginHandle::PluginLeap);
}

void EapQtConfigInterfaceContext::createEapIdentifyValidators(EapQtPluginHandle::Plugin outerType)
{
    EapQtPluginHandle typeHandle(outerType);
    
    EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
    setValidator(typeHandle.type().type(), EapQtConfig::Username, valStub);
    
    valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
    setValidator(typeHandle.type().type(), EapQtConfig::Realm, valStub);
}

void EapQtConfigInterfaceContext::createEapTtlsPeap(
    EapQtPluginHandle::Plugin type,
    bool automaticCert,
    bool usernameAutomatic, 
    const QString &username,
    bool realmAutomatic, 
    const QString &realm,
    EapQtPluginHandle::Plugin innerType)
{
    EapQtPluginHandle typeHandle(type);
    
    QList<EapQtPluginHandle> types;
    types.append(typeHandle);
    setSupportedOuterTypes(types);
    setSelectectedOuterTypes(types, true);
    
    // Certs
    QList<EapQtCertificateInfo> certs;
    EapQtCertificateInfo caCert;
    caCert.setValue(EapQtCertificateInfo::CertificateLabel, "My Super Cert");
    certs.append(caCert);
    setCertsCa(certs);
    
    // CREATE VALIDATOR
    createEapIdentifyValidators(type);
    
    // CREATE CONFIGURATION FOR TTLS/PEAP
    
    EapQtConfig config;
    config.setValue(EapQtConfig::UseIdentityPrivacy, false);
    config.setValue(EapQtConfig::VerifyServerRealm, false);
    config.setValue(EapQtConfig::ClientAuthenticationRequired, false);
    
    config.setValue(EapQtConfig::UsernameAutomatic, usernameAutomatic);
    config.setValue(EapQtConfig::Username, username);
    config.setValue(EapQtConfig::RealmAutomatic, realmAutomatic);
    config.setValue(EapQtConfig::Realm, realm);
    if (automaticCert){
        config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true);
    }
    else {
        QList<QVariant> caCerts;
        caCerts.append(qVariantFromValue(caCert));
        config.setValue(EapQtConfig::AuthorityCertificate, caCerts);
        config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false);
    }
    if (type == EapQtPluginHandle::PluginPeap){
        if (innerType == EapQtPluginHandle::PluginEapMschapv2){
            config.setValue(EapQtConfig::PeapVersion0Allowed, true);
            config.setValue(EapQtConfig::PeapVersion1Allowed, false);  
        }
        else {
            config.setValue(EapQtConfig::PeapVersion0Allowed, false);
            config.setValue(EapQtConfig::PeapVersion1Allowed, true);
        }
        config.setValue(EapQtConfig::PeapVersion2Allowed, false);
    }
    QList<QVariant> innerTypeList;
    EapQtPluginHandle inner(innerType);
    innerTypeList.append(qVariantFromValue(inner));
    config.setValue(EapQtConfig::InnerType, innerTypeList);
    
    setOuterConfig(type, config, true);
}

void EapQtConfigInterfaceContext::createEapTls(
    QList<EapQtCertificateInfo> &caCerts,
    int indexForCaCert,
    QList<EapQtCertificateInfo> &userCerts,
    int indexForUserCert)
{
    QList<EapQtPluginHandle> types;
    types.append(EapQtPluginHandle::PluginEapTls);
    setSupportedOuterTypes(types);
    setSelectectedOuterTypes(types, true);
    
    // Certs
    setCertsCa(caCerts);
    setCertsUser(userCerts);
    
    // CREATE VALIDATOR
    createEapIdentifyValidators(EapQtPluginHandle::PluginEapTls);
    
    // CREATE CONFIGURATION FOR TTLS/PEAP
    
    EapQtConfig config;
    config.setValue(EapQtConfig::UseIdentityPrivacy, false);
    config.setValue(EapQtConfig::VerifyServerRealm, false);
    config.setValue(EapQtConfig::ClientAuthenticationRequired, true);
    
    config.setValue(EapQtConfig::UsernameAutomatic, true);
    config.setValue(EapQtConfig::Username, QString());
    config.setValue(EapQtConfig::RealmAutomatic, true);
    config.setValue(EapQtConfig::Realm, QString());
    
    if (caCerts.length() == 0){
        config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true);
    } else {
        QList<QVariant> caCertsVariant;
        caCertsVariant.append(qVariantFromValue(caCerts[indexForCaCert]));    
        config.setValue(EapQtConfig::AuthorityCertificate, caCertsVariant);
        config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false);
    }
    
    if (indexForUserCert != -1) {
        QList<QVariant> certs;
        certs.append(qVariantFromValue(userCerts[indexForUserCert]));
        config.setValue(EapQtConfig::UserCertificate, certs);
    }
    
    setOuterConfig(EapQtPluginHandle::PluginEapTls, config, true);
}

void EapQtConfigInterfaceContext::createInner(
    EapQtPluginHandle::Plugin outerType,
    EapQtPluginHandle::Plugin innerType, 
    const QString &username,
    const QString &password)
{
    EapQtPluginHandle innerHandle(innerType);
    
    QList<EapQtPluginHandle> types;
    types.append(innerHandle);
    setSupportedInnerTypes(outerType, types);

    EapQtConfig config;
    EapQtPluginHandle outerTypeHandle(outerType);
    config.setValue(EapQtConfig::OuterType, qVariantFromValue(outerTypeHandle));
    config.setValue(EapQtConfig::UsernameAutomatic, false);
    config.setValue(EapQtConfig::Username, username);
    config.setValue(EapQtConfig::PasswordPrompt, false);
    config.setValue(EapQtConfig::Password, password);
    setInnerConfig(innerType, config, true);
    
    createInnerTypeValidators(innerType);
}

void EapQtConfigInterfaceContext::createInnerTypeValidators(EapQtPluginHandle::Plugin innerType)
{
    EapQtPluginHandle innerHandle(innerType);
    
    // validators
    EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
    setValidator(innerHandle.type().type(), EapQtConfig::Username, valStub);
    
    valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
    setValidator(innerHandle.type().type(), EapQtConfig::Password, valStub);    
}

void EapQtConfigInterfaceContext::createEapFast(
    int pacState, const QString &password)
{
    QList<EapQtPluginHandle> types;
    types.append(EapQtPluginHandle::PluginEapFast);
    setSupportedOuterTypes(types);
    setSelectectedOuterTypes(types, true);

    EapQtPacStoreConfig pacStoreConfig;
    pacStoreConfig.setValue(EapQtPacStoreConfig::PacStoreState, pacState);
    setPacStoreConfigRead(pacStoreConfig, true);
    
    if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists ||
        pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) {
        pacStoreConfig.clear();
        pacStoreConfig.setValue(
            EapQtPacStoreConfig::PacStorePassword, 
            password);
        
        pacStoreConfig.setValue(
            EapQtPacStoreConfig::PacStoreSavePassword, 
            true);
        
        setPacStoreConfigSave(pacStoreConfig, true);
    }
    
    if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists) {
        EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk);
        setValidatorPacStore(EapQtPacStoreConfig::PacStorePassword, validator);
    }

    if (pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) {
        EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk);
        setValidatorPacStore(EapQtPacStoreConfig::PacStorePasswordConfirmation, validator);
    }
    
    EapQtConfig config;
    config.setValue(EapQtConfig::ProvisioningModeAuthenticated, false);
    config.setValue(EapQtConfig::ProvisioningModeUnauthenticated, true);
    config.setValue(EapQtConfig::VerifyServerRealm, false);
    config.setValue(EapQtConfig::UseIdentityPrivacy, false);
    
    QList<QVariant> innerTypeList;
    EapQtPluginHandle inner(EapQtPluginHandle::PluginEapMschapv2);
    innerTypeList.append(qVariantFromValue(inner));
    config.setValue(EapQtConfig::InnerType, innerTypeList);
    
    setOuterConfig(EapQtPluginHandle::PluginEapFast, config, true);
}

QStringList EapQtConfigInterfaceContext::calledMethods()
{
    QStringList methods = mEapQtConfig->mCalledMethods;
    mEapQtConfig->mCalledMethods.clear();
    return methods;
}

void EapQtConfigInterfaceContext::setConfigurationReference(
    int iapId, 
    bool retValue)
{
    mEapQtConfig->mIapId = iapId;
    setConfigurationReferenceReturn(retValue);
}

void EapQtConfigInterfaceContext::setConfigurationReferenceReturn(bool retValue)
{
    mEapQtConfig->mReturnSetConfigurationReference = retValue;    
}

void EapQtConfigInterfaceContext::setCertsCa(
    QList<EapQtCertificateInfo> &certs)
{
    mEapQtConfig->mCertsCa = certs;
}

void EapQtConfigInterfaceContext::setCertsUser(
    QList<EapQtCertificateInfo> &certs)
{
    mEapQtConfig->mCertsUser = certs;
}

void EapQtConfigInterfaceContext::setSupportedOuterTypes(
    QList<EapQtPluginHandle> &outerTypes)
{
    mEapQtConfig->mSupportedOuterTypes = outerTypes;
}

void EapQtConfigInterfaceContext::setSupportedInnerTypes(
    EapQtPluginHandle outerHandle, 
    QList<EapQtPluginHandle> &innerTypes)
{
    mEapQtConfig->mSupportedInnerTypes = innerTypes;
    mEapQtConfig->mSupportedInnerTypesOuterHandle = outerHandle.pluginId();
}

void EapQtConfigInterfaceContext::setSelectectedOuterTypes(
    QList<EapQtPluginHandle> &types,
    bool retValue)
{
    mEapQtConfig->mSetSelectectedOuterTypes = types;
    setSelectectedOuterTypesReturn(retValue);
}

void EapQtConfigInterfaceContext::setSelectectedOuterTypesReturn(bool retValue)
{
    mEapQtConfig->mReturnSetSelectedOuterTypes = retValue;
}

void EapQtConfigInterfaceContext::setOuterConfig(
    EapQtPluginHandle::Plugin handle,
    EapQtConfig &config, 
    bool retValue)
{
    mEapQtConfig->mOuterPlugin = handle;
    mEapQtConfig->mSaveConfigurationsOuter = config;
    setOuterConfigReturn(retValue);
}

void EapQtConfigInterfaceContext::setOuterConfigReturn(bool retValue)
{
    mEapQtConfig->mReturnSaveConfigurationOuter = retValue;
}

void EapQtConfigInterfaceContext::setInnerConfig(
    EapQtPluginHandle::Plugin handle,
    EapQtConfig &config, 
    bool retValue)
{
    mEapQtConfig->mInnerPlugin = handle;
    mEapQtConfig->mSaveConfigurationsInner = config;
    setInnerConfigReturn(retValue);
}

void EapQtConfigInterfaceContext::setInnerConfigReturn(bool retValue)
{
    mEapQtConfig->mReturnSaveConfigurationInner = retValue;
}

void EapQtConfigInterfaceContext::setValidator(
    EapQtExpandedEapType::Type eapType,
    EapQtConfig::SettingsId id, 
    EapQtValidator *validator)
{
    QCOMPARE(mEapQtConfig->mValidator[eapType][id] == NULL, true);
    mEapQtConfig->mValidator[eapType][id] = validator;
}


EapQtValidator *EapQtConfigInterfaceContext::validator(
    EapQtExpandedEapType::Type eapType,
    EapQtConfig::SettingsId id)
{
    return mEapQtConfig->mValidator[eapType][id];
}

void EapQtConfigInterfaceContext::setPacStoreConfigRead(
    EapQtPacStoreConfig &config,
    bool retValue)
{
    mEapQtConfig->mReadPacStoreConfiguration = config;
    setPacStoreConfigReadReturn(retValue);
}

void EapQtConfigInterfaceContext::setPacStoreConfigReadReturn(bool retValue)
{
    mEapQtConfig->mReadPacStoreConfigurationReturn = retValue;
}

void EapQtConfigInterfaceContext::setPacStoreConfigSave(
    EapQtPacStoreConfig &config,
    bool retValue)
{
    mEapQtConfig->mSavePacStoreConfiguration = config;
    setPacStoreConfigSaveReturn(retValue);
}

void EapQtConfigInterfaceContext::setPacStoreConfigSaveReturn(bool retValue)
{
    mEapQtConfig->mSavePacStoreConfigurationReturn = retValue;
}

void EapQtConfigInterfaceContext::setValidatorPacStore(int id, EapQtValidator * validator)
{
    mEapQtConfig->mValidatorPacStore[id] = validator;
}

EapQtValidator *EapQtConfigInterfaceContext::validatorPacStore(int id)
{
    return mEapQtConfig->mValidatorPacStore[id];
}