package org.caebeans.unicore.client;

import com.google.inject.Inject;
import de.fzj.unicore.uas.TargetSystemFactory;
import de.fzj.unicore.uas.client.*;
import de.fzj.unicore.uas.security.ClientProperties;
import de.fzj.unicore.ucc.utils.FileDownloader;
import de.fzj.unicore.ucc.utils.FileUploader;
import de.fzj.unicore.ucc.utils.Mode;
import de.fzj.unicore.wsrflite.xmlbeans.WSUtilities;
import de.fzj.unicore.wsrflite.xmlbeans.client.RegistryClient;
import org.apache.commons.configuration.Configuration;
import org.caebeans.lib.Config;
import org.caebeans.lib.LoggerManager;
import org.ggf.schemas.jsdl.x2005.x11.jsdl.ApplicationDocument;
import org.ggf.schemas.jsdl.x2005.x11.jsdl.ApplicationType;
import org.ggf.schemas.jsdl.x2005.x11.jsdl.JobDefinitionType;
import org.ggf.schemas.jsdl.x2005.x11.jsdlPosix.EnvironmentType;
import org.ggf.schemas.jsdl.x2005.x11.jsdlPosix.POSIXApplicationDocument;
import org.ggf.schemas.jsdl.x2005.x11.jsdlPosix.POSIXApplicationType;
import org.unigrids.x2006.x04.services.tss.SubmitDocument;
import org.w3.x2005.x08.addressing.EndpointReferenceType;

import java.io.FileOutputStream;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * Created with IntelliJ IDEA.
 * User: zakharov
 * Date: 5/1/12
 * Time: 10:01 PM
 * To change this template use File | Settings | File Templates.
 */
public class ClientImpl implements Client {
    private static final String SSL_KEYSTORE = "wsrf.ssl.keystore";
    private static final String SSL_KEYPASS = "wsrf.ssl.keypass";
    private static final String SSL_KEYALIAS = "wsrf.ssl.keyalias";
    private static final String SSL_TRUSTSTORE = "wsrf.ssl.truststore";
    private static final String SSL_TRUSTPASS = "wsrf.ssl.trustpass";
    public static final String UNICORE_REGISTRY_URL = "unicore.registry_url";

    private RegistryClient registry;

    @Inject
    private Config config;

    @Inject
    private LoggerManager logger;

    @Inject
    ClientImpl() {

    }

    @Override
    public void run(String dir, String appName, Map<String, String> parameters, List<String> inputs, List<String> outputs) throws Exception {
        registry = initRegistryClient();

        JobClient jobClient = createJob(appName, parameters);
        StorageClient storageClient = jobClient.getUspaceClient();

        for (String input : inputs) {
            FileUploader uploader = new FileUploader(dir + "/" + input, "/" + input, Mode.overwrite);
            uploader.perform(storageClient, new CAEMessageWriter());
        }

        jobClient.waitUntilReady(0);
        jobClient.start();
        jobClient.waitUntilDone(0);

        logger.warn("Appname " + appName);

        for (String output : outputs) {
            FileDownloader downloader = new FileDownloader(output, dir, Mode.overwrite);
            downloader.perform(storageClient, new CAEMessageWriter());
        }
    }

    private ClientProperties setupSecurity() {
        ClientProperties sp = new ClientProperties(new Properties());
        sp.setProperty(ClientProperties.WSRF_SSL, "true");

        Configuration conf = config.getConfig();

        sp.setProperty(ClientProperties.WSRF_SSL_KEYSTORE, conf.getString(SSL_KEYSTORE));
        sp.setProperty(ClientProperties.WSRF_SSL_KEYPASS, conf.getString(SSL_KEYPASS));
        sp.setProperty(ClientProperties.WSRF_SSL_KEYALIAS, conf.getString(SSL_KEYALIAS));
        sp.setProperty(ClientProperties.WSRF_SSL_TRUSTSTORE, conf.getString(SSL_TRUSTSTORE));
        sp.setProperty(ClientProperties.WSRF_SSL_TRUSTPASS, conf.getString(SSL_TRUSTPASS));

        return sp;
    }

    private RegistryClient initRegistryClient() throws Exception {
        String url = config.getConfig().getString(UNICORE_REGISTRY_URL);
        EndpointReferenceType epr = EndpointReferenceType.Factory.newInstance();
        epr.addNewAddress().setStringValue(url);
        RegistryClient registryClient = new RegistryClient(url, epr, setupSecurity());

        return registryClient;
    }

    private TSSClient findAndCreateTSS(RegistryClient registry) throws Exception {
        List<EndpointReferenceType> tsfEPRs = registry.listAccessibleServices(TargetSystemFactory.TSF_PORT);
        EndpointReferenceType epr = tsfEPRs.get(0);
        String url = epr.getAddress().getStringValue();
        TSFClient tsf = new TSFClient(url, epr, registry.getSecurityProperties());
        TSSClient tss = tsf.createTSS();

        return tss;
    }

    private JobClient createJob(String appName, Map<String, String> parameters) throws Exception {
        TSSClient targetSystem = findAndCreateTSS(registry);

        ApplicationDocument ad = ApplicationDocument.Factory.newInstance();
        ApplicationType app = ad.addNewApplication();

        SubmitDocument submitDoc = SubmitDocument.Factory.newInstance();
        JobDefinitionType job = submitDoc.addNewSubmit().addNewJobDefinition();
//        ApplicationType app = job.addNewJobDescription().addNewApplication();
        app.setApplicationName(appName);

        POSIXApplicationDocument pd = POSIXApplicationDocument.Factory.newInstance();
        POSIXApplicationType p = pd.addNewPOSIXApplication();

        for (Map.Entry<String, String> entry : parameters.entrySet()) {
            EnvironmentType et = p.addNewEnvironment();
            et.setName(entry.getKey());
            et.setStringValue(entry.getValue());
        }

        WSUtilities.append(pd, ad);

        job.addNewJobDescription().setApplication(app);

        JobClient jobClient = targetSystem.submit(submitDoc);

        return jobClient;
    }
}