/src/main/java/com/atlassian/bamboo/plugins/xcode/build/XCodeTaskType.java

package com.atlassian.bamboo.plugins.xcode.build;

import com.atlassian.bamboo.build.logger.BuildLogger;
import com.atlassian.bamboo.configuration.ConfigurationMap;
import com.atlassian.bamboo.plugins.xcode.tests.OCUnitLogInterceptor;
import com.atlassian.bamboo.process.EnvironmentVariableAccessor;
import com.atlassian.bamboo.process.ExternalProcessBuilder;
import com.atlassian.bamboo.process.ProcessService;
import com.atlassian.bamboo.task.TaskContext;
import com.atlassian.bamboo.task.TaskException;
import com.atlassian.bamboo.task.TaskResult;
import com.atlassian.bamboo.task.TaskResultBuilder;
import com.atlassian.bamboo.task.TaskState;
import com.atlassian.bamboo.task.TaskType;
import com.atlassian.bamboo.v2.build.agent.capability.Capability;
import com.atlassian.bamboo.v2.build.agent.capability.CapabilityContext;
import com.atlassian.bamboo.v2.build.agent.capability.CapabilityDefaultsHelper;
import com.atlassian.utils.process.ExternalProcess;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class XCodeTaskType implements TaskType
{
    public static final String XCODE_CAPABILITY_PREFIX = CapabilityDefaultsHelper.CAPABILITY_BUILDER_PREFIX + ".xcode";

    public static final String XCRUN_PATH = "/usr/bin/xcrun";

    private final ProcessService processService;
    private final EnvironmentVariableAccessor environmentVariableAccessor;
    private final CapabilityContext capabilityContext;

    public XCodeTaskType(final ProcessService processService, final EnvironmentVariableAccessor environmentVariableAccessor, final CapabilityContext capabilityContext)
    {
        this.processService = processService;
        this.environmentVariableAccessor = environmentVariableAccessor;
        this.capabilityContext = capabilityContext;
    }

    @NotNull
    public TaskResult execute(@NotNull TaskContext taskContext) throws TaskException
    {
        final OCUnitLogInterceptor ocUnitLogInterceptor = new OCUnitLogInterceptor();

        final TaskResultBuilder resultBuilder = TaskResultBuilder.create(taskContext);
        final BuildLogger buildLogger = taskContext.getBuildLogger();
        try
        {
            final ConfigurationMap configurationMap = taskContext.getConfigurationMap();
            final String project = configurationMap.get(XCodeConfigurator.PROJECT);
            final boolean shouldClean = configurationMap.getAsBoolean(XCodeConfigurator.CLEAN);
            final File workingDirectory = taskContext.getWorkingDirectory();
            if (shouldClean)
            {
                final List<String> arguments = Lists.newArrayList(XCodeBuild.getXcodebuildPath());

                if (StringUtils.isNotEmpty(project))
                {
                    arguments.add("-project");
                    arguments.add(project);
                }

                arguments.add(XCodeBuild.XCODEBUILD_ARG_CLEAN);

                resultBuilder.checkReturnCode(processService.executeProcess(taskContext, new ExternalProcessBuilder()
                        .command(arguments)
                        .workingDirectory(workingDirectory)));

                if (resultBuilder.getTaskState() != TaskState.SUCCESS)
                {
                    return resultBuilder.build();
                }
            }

            final boolean buildAllTargets = configurationMap.getAsBoolean(XCodeConfigurator.ALL_TARGETS);
            final String target = configurationMap.get(XCodeConfigurator.TARGET);
            final String configuration = configurationMap.get(XCodeConfigurator.CONFIGURATION);
            final String sdk = configurationMap.get(XCodeConfigurator.SDK);
            final boolean parseOcUnitResults = configurationMap.getAsBoolean(XCodeConfigurator.OCUNIT);

            final List<String> arguments = new LinkedList<String>();

            final Capability capability = capabilityContext.getCapabilitySet().getCapability(XCODE_CAPABILITY_PREFIX  + "." + sdk);
            Preconditions.checkNotNull(capability, "The Xcode SDK capability is missing");
            final String sdkLabel = capability.getValue();

            arguments.add(XCodeBuild.getXcodebuildPath());
            arguments.add("-sdk");
            arguments.add(sdkLabel);

            if (StringUtils.isNotEmpty(project))
            {
                arguments.add("-project");
                arguments.add(project);
            }

            if (buildAllTargets)
            {
                arguments.add("-alltargets");
            }
            else if (StringUtils.isNotEmpty(target))
            {
                arguments.add("-target");
                arguments.add(target);
            }

            if (StringUtils.isNotEmpty(configuration))
            {
                arguments.add("-configuration");
                arguments.add(configuration);
            }

            final Map<String, String> environment = environmentVariableAccessor.splitEnvironmentAssignments(configurationMap.get(XCodeConfigurator.ENVIRONMENT));

            if (parseOcUnitResults)
            {
                buildLogger.getInterceptorStack().add(ocUnitLogInterceptor);
            }

            final ExternalProcess externalProcess = processService.executeProcess(taskContext, new ExternalProcessBuilder()
                    .command(arguments)
                    .env(environment)
                    .workingDirectory(workingDirectory));

            if (parseOcUnitResults)
            {
                taskContext.getBuildContext().getBuildResult().setTestResults(Sets.newHashSet(ocUnitLogInterceptor.getSuccessfulTestResults()), Sets.newHashSet(ocUnitLogInterceptor.getFailingTestResults()));

                resultBuilder.checkTestFailures();
            }
            else if (resultBuilder.getTaskState() == TaskState.SUCCESS)
            {
                resultBuilder.checkReturnCode(externalProcess);
                taskContext.getBuildContext().getBuildResult().getBuildErrors().addAll(buildLogger.getStringErrorLogs());
            }

            if (resultBuilder.getTaskState() == TaskState.SUCCESS && configurationMap.getAsBoolean(XCodeConfigurator.BUILD_IPA))
            {
                final String appPath = configurationMap.get(XCodeConfigurator.APP_PATH);
                final String identity = configurationMap.get(XCodeConfigurator.IDENTITY);
                final String embeddedProfilePath = configurationMap.get(XCodeConfigurator.EMBEDDED_PROFILE_PATH);

                final File appFile = new File(workingDirectory, appPath);

                final String outputPath = FilenameUtils.removeExtension(appFile.getAbsolutePath()) + ".ipa";

                final List<String> command = Lists.newArrayList(XCRUN_PATH,
                                                                "-sdk", sdk,
                                                                "PackageApplication",
                                                                "-v", appFile.getAbsolutePath(),
                                                                "-o", outputPath);
                
                if (StringUtils.isNotEmpty(embeddedProfilePath))
                {
                    final File embeddedProfileFile = new File(embeddedProfilePath).isAbsolute() ? new File(embeddedProfilePath) : new File(workingDirectory, embeddedProfilePath);
                    command.add("--embed");
                    command.add(embeddedProfileFile.getAbsolutePath());
                }
                
                if (StringUtils.isNotEmpty(identity))
                {
                    command.add("--sign");
                    command.add(identity);
                }

                resultBuilder.checkReturnCode(processService.executeProcess(taskContext, new ExternalProcessBuilder()
                                                .workingDirectory(workingDirectory)
                                                .command(command)));

                if (resultBuilder.getTaskState() == TaskState.SUCCESS)
                {
                    buildLogger.addBuildLogEntry("IPA created at '" + outputPath + "'");
                }
            }

            return resultBuilder.build();
        }
        finally
        {
            buildLogger.getInterceptorStack().remove(ocUnitLogInterceptor);
        }
    }
}