/**
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.airavata.k8s.api.server.service.util;

import org.apache.airavata.k8s.api.resources.experiment.ExperimentStatusResource;
import org.apache.airavata.k8s.api.resources.process.ProcessStatusResource;
import org.apache.airavata.k8s.api.resources.task.*;
import org.apache.airavata.k8s.api.resources.task.type.TaskInputTypeResource;
import org.apache.airavata.k8s.api.resources.task.type.TaskOutPortTypeResource;
import org.apache.airavata.k8s.api.resources.task.type.TaskOutputTypeResource;
import org.apache.airavata.k8s.api.resources.task.type.TaskTypeResource;
import org.apache.airavata.k8s.api.resources.workflow.WorkflowResource;
import org.apache.airavata.k8s.api.server.model.application.ApplicationDeployment;
import org.apache.airavata.k8s.api.server.model.application.ApplicationInterface;
import org.apache.airavata.k8s.api.server.model.application.ApplicationModule;
import org.apache.airavata.k8s.api.server.model.compute.ComputeResourceModel;
import org.apache.airavata.k8s.api.server.model.experiment.Experiment;
import org.apache.airavata.k8s.api.server.model.experiment.ExperimentInputData;
import org.apache.airavata.k8s.api.server.model.experiment.ExperimentOutputData;
import org.apache.airavata.k8s.api.server.model.experiment.ExperimentStatus;
import org.apache.airavata.k8s.api.server.model.process.ProcessModel;
import org.apache.airavata.k8s.api.server.model.process.ProcessStatus;
import org.apache.airavata.k8s.api.server.model.task.TaskInput;
import org.apache.airavata.k8s.api.server.model.task.TaskModel;
import org.apache.airavata.k8s.api.resources.application.*;
import org.apache.airavata.k8s.api.resources.compute.ComputeResource;
import org.apache.airavata.k8s.api.resources.experiment.ExperimentInputResource;
import org.apache.airavata.k8s.api.resources.experiment.ExperimentOutputResource;
import org.apache.airavata.k8s.api.resources.experiment.ExperimentResource;
import org.apache.airavata.k8s.api.resources.process.ProcessResource;
import org.apache.airavata.k8s.api.server.model.task.TaskOutput;
import org.apache.airavata.k8s.api.server.model.task.TaskStatus;
import org.apache.airavata.k8s.api.server.model.task.type.TaskInputType;
import org.apache.airavata.k8s.api.server.model.task.type.TaskModelType;
import org.apache.airavata.k8s.api.server.model.task.type.TaskOutPortType;
import org.apache.airavata.k8s.api.server.model.task.type.TaskOutputType;
import org.apache.airavata.k8s.api.server.model.workflow.Workflow;

import java.util.Optional;

/**
 * TODO: Class level comments please
 *
 * @author dimuthu
 * @since 1.0.0-SNAPSHOT
 */
public class ToResourceUtil {

    public static Optional<ExperimentStatusResource> toResource(ExperimentStatus experimentStatus) {
        if (experimentStatus != null) {
            ExperimentStatusResource resource = new ExperimentStatusResource();
            resource.setId(experimentStatus.getId());
            resource.setState(experimentStatus.getState().getValue());
            resource.setReason(experimentStatus.getReason());
            resource.setStateStr(experimentStatus.getState().name());
            resource.setTimeOfStateChange(experimentStatus.getTimeOfStateChange());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ExperimentResource> toResource(Experiment experiment) {

        if (experiment != null) {
            ExperimentResource resource = new ExperimentResource();
            resource.setId(experiment.getId());
            resource.setExperimentName(experiment.getExperimentName());
            resource.setDescription(experiment.getDescription());
            resource.setCreationTime(experiment.getCreationTime());
            Optional.ofNullable(experiment.getErrors())
                    .ifPresent(errs -> errs.forEach(err -> resource.getErrorsIds().add(err.getId())));
            Optional.ofNullable(experiment.getExperimentStatus())
                    .ifPresent(sts -> sts.forEach(status -> resource.getExperimentStatus().add(toResource(status).get())));
            Optional.ofNullable(experiment.getExperimentInputs())
                    .ifPresent(ips -> ips.forEach(ip -> resource.getExperimentInputs().add(toResource(ip).get())));
            Optional.ofNullable(experiment.getExperimentOutputs())
                    .ifPresent(ops -> ops.forEach(op -> resource.getExperimentOutputs().add(toResource(op).get())));
            Optional.ofNullable(experiment.getApplicationDeployment())
                    .ifPresent(appDep -> {
                        resource.setApplicationDeploymentId(appDep.getId());
                        resource.setApplicationDeploymentName(appDep.getName());
                    });
            Optional.ofNullable(experiment.getApplicationInterface())
                    .ifPresent(iface -> {
                        resource.setApplicationInterfaceId(iface.getId());
                        resource.setApplicationInterfaceName(iface.getName());
                    });
            Optional.ofNullable(experiment.getProcesses())
                    .ifPresent(processModels -> processModels
                            .forEach(processModel -> resource.getProcessIds().add(processModel.getId())));
            return Optional.of(resource);

        } else {
            return Optional.empty();
        }
    }

    public static Optional<ExperimentInputResource> toResource(ExperimentInputData input) {
        if (input != null) {
            ExperimentInputResource resource = new ExperimentInputResource();
            resource.setId(input.getId());
            resource.setName(input.getName());
            resource.setValue(input.getValue());
            resource.setType(input.getType().getValue());
            resource.setArguments(input.getArguments());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ExperimentOutputResource> toResource(ExperimentOutputData output) {
        if (output != null) {
            ExperimentOutputResource resource = new ExperimentOutputResource();
            resource.setId(output.getId());
            resource.setName(output.getName());
            resource.setValue(output.getValue());
            resource.setType(output.getType().getValue());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ComputeResource> toResource(ComputeResourceModel computeResourceModel) {

        if (computeResourceModel != null) {
            ComputeResource resource = new ComputeResource();
            resource.setId(computeResourceModel.getId());
            resource.setName(computeResourceModel.getName());
            resource.setUserName(computeResourceModel.getUserName());
            resource.setPassword(computeResourceModel.getPassword());
            resource.setCommunicationType(computeResourceModel.getCommunicationType());
            resource.setHost(computeResourceModel.getHost());
            return Optional.of(resource);

        } else {
            return Optional.empty();
        }
    }

    public static Optional<ApplicationModuleResource> toResource(ApplicationModule applicationModule) {

        if (applicationModule != null) {
            ApplicationModuleResource resource = new ApplicationModuleResource();
            resource.setId(applicationModule.getId());
            resource.setName(applicationModule.getName());
            resource.setDescription(applicationModule.getDescription());
            resource.setVersion(applicationModule.getVersion());
            return Optional.of(resource);

        } else {
            return Optional.empty();
        }
    }

    public static Optional<ApplicationDeploymentResource> toResource(ApplicationDeployment applicationDeployment) {
        if (applicationDeployment != null) {
            ApplicationDeploymentResource resource = new ApplicationDeploymentResource();
            resource.setId(applicationDeployment.getId());
            resource.setExecutablePath(applicationDeployment.getExecutablePath());
            resource.setPreJobCommand(applicationDeployment.getPreJobCommand());
            resource.setPostJobCommand(applicationDeployment.getPostJobCommand());
            resource.setName(applicationDeployment.getName());
            Optional.ofNullable(applicationDeployment.getApplicationModule())
                    .ifPresent(module -> resource.setApplicationModuleId(module.getId()));
            Optional.ofNullable(applicationDeployment.getComputeResource())
                    .ifPresent(cr -> resource.setComputeResourceId(cr.getId()));
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ApplicationIfaceResource> toResource(ApplicationInterface applicationInterface) {
        if (applicationInterface != null) {
            ApplicationIfaceResource resource = new ApplicationIfaceResource();
            resource.setId(applicationInterface.getId());
            resource.setName(applicationInterface.getName());
            resource.setApplicationModuleId(applicationInterface.getId());
            resource.setDescription(applicationInterface.getDescription());

            Optional.ofNullable(applicationInterface.getInputs()).ifPresent(ips -> ips.forEach(ip -> {
                ApplicationInputResource ipResource = new ApplicationInputResource();
                ipResource.setId(ip.getId());
                ipResource.setName(ip.getName());
                ipResource.setArguments(ip.getArguments());
                ipResource.setType(ip.getType().getValue());
                ipResource.setValue(ip.getValue());
                resource.getInputs().add(ipResource);
            }));

            Optional.ofNullable(applicationInterface.getOutputs()).ifPresent(ops -> ops.forEach(op -> {
                ApplicationOutputResource opResource = new ApplicationOutputResource();
                opResource.setId(op.getId());
                opResource.setName(op.getName());
                opResource.setType(op.getType().getValue());
                opResource.setValue(op.getValue());
                resource.getOutputs().add(opResource);
            }));

            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskResource> toResource(TaskModel taskModel) {
        if (taskModel != null) {
            TaskResource resource = new TaskResource();
            resource.setName(taskModel.getName());
            resource.setId(taskModel.getId());
            resource.setLastUpdateTime(taskModel.getLastUpdateTime());
            resource.setCreationTime(taskModel.getCreationTime());
            resource.setParentProcessId(taskModel.getParentProcess().getId());
            resource.setTaskTypeId(taskModel.getTaskType().getId());
            resource.setTaskDetail(taskModel.getTaskDetail());
            resource.setStartingTask(taskModel.isStartingTask());
            resource.setStoppingTask(taskModel.isStoppingTask());
            Optional.ofNullable(taskModel.getTaskInputs())
                    .ifPresent(inputs ->
                            inputs.forEach(input -> resource.getInputs()
                                    .add(toResource(input).get())));

            Optional.ofNullable(taskModel.getTaskOutputs())
                    .ifPresent(outputs ->
                            outputs.forEach(output -> resource.getOutputs()
                                    .add(toResource(output).get())));


            Optional.ofNullable(taskModel.getTaskStatuses())
                    .ifPresent(taskStatuses ->
                            taskStatuses.forEach(taskStatus -> resource.getTaskStatus()
                                    .add(toResource(taskStatus).get())));

            resource.setOrder(taskModel.getOrderIndex());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskStatusResource> toResource(TaskStatus taskStatus) {
        if (taskStatus != null) {
            TaskStatusResource resource = new TaskStatusResource();
            resource.setId(taskStatus.getId());
            resource.setState(taskStatus.getState().getValue());
            resource.setTimeOfStateChange(taskStatus.getTimeOfStateChange());
            resource.setTaskId(taskStatus.getTaskModel().getId());
            resource.setStateStr(taskStatus.getState().name());
            resource.setReason(taskStatus.getReason());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskInputResource> toResource(TaskInput taskInput) {
        if (taskInput != null) {
            TaskInputResource resource = new TaskInputResource();
            resource.setId(taskInput.getId());
            resource.setName(taskInput.getName());
            resource.setValue(taskInput.getValue());
            resource.setType(taskInput.getType());
            resource.setImportFrom(taskInput.getImportFrom());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskOutputResource> toResource(TaskOutput taskOutput) {
        if (taskOutput != null) {
            TaskOutputResource resource = new TaskOutputResource();
            resource.setId(taskOutput.getId());
            resource.setName(taskOutput.getName());
            resource.setValue(taskOutput.getValue());
            resource.setType(taskOutput.getType());
            resource.setExportTo(taskOutput.getExportTo());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ProcessResource> toResource(ProcessModel processModel) {
        if (processModel != null) {
            ProcessResource processResource = new ProcessResource();
            processResource.setId(processModel.getId());
            processResource.setLastUpdateTime(processModel.getLastUpdateTime());
            processResource.setExperimentId(processModel.getExperiment().getId());
            processResource.setTaskDag(processModel.getTaskDag());
            processResource.setCreationTime(processModel.getCreationTime());
            Optional.ofNullable(processModel.getProcessStatuses())
                    .ifPresent(stss -> stss.forEach(sts -> processResource.getProcessStatuses().add(toResource(sts).get())));
            Optional.ofNullable(processModel.getTasks())
                    .ifPresent(tasks -> tasks.forEach(task -> processResource.getTasks().add(toResource(task).get())));
            Optional.ofNullable(processModel.getProcessErrors())
                    .ifPresent(errs -> errs.forEach(err -> processResource.getProcessErrorIds().add(err.getId())));
            return Optional.of(processResource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<ProcessStatusResource> toResource(ProcessStatus processStatus) {
        if (processStatus != null) {
            ProcessStatusResource resource = new ProcessStatusResource();
            resource.setId(processStatus.getId());
            resource.setState(processStatus.getState().getValue());
            resource.setTimeOfStateChange(processStatus.getTimeOfStateChange());
            resource.setStateStr(processStatus.getState().name());
            resource.setReason(processStatus.getReason());
            resource.setProcessId(processStatus.getProcessModel().getId());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskTypeResource> toResource(TaskModelType taskModelType) {

        if (taskModelType != null) {
            TaskTypeResource resource = new TaskTypeResource();
            resource.setName(taskModelType.getName());
            resource.setId(taskModelType.getId());
            resource.setTopicName(taskModelType.getTopicName());
            resource.setIcon(taskModelType.getIcon());

            Optional.ofNullable(taskModelType.getInputTypes())
                    .ifPresent(taskInputTypes -> taskInputTypes.forEach(taskInputType -> {
                        resource.getInputTypes().add(toResource(taskInputType).get());
                    }));

            Optional.ofNullable(taskModelType.getOutputTypes())
                    .ifPresent(taskOutputTypes -> taskOutputTypes.forEach(taskOutputType -> {
                        resource.getOutputTypes().add(toResource(taskOutputType).get());
                    }));

            Optional.ofNullable(taskModelType.getOutPorts())
                    .ifPresent(taskOutPorts -> taskOutPorts.forEach(taskOutPort -> {
                        resource.getOutPorts().add(toResource(taskOutPort).get());
                    }));
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskInputTypeResource> toResource(TaskInputType taskInputType) {
        if (taskInputType != null) {
            TaskInputTypeResource resource = new TaskInputTypeResource();
            resource.setId(taskInputType.getId());
            resource.setName(taskInputType.getName());
            resource.setType(taskInputType.getType());
            resource.setDefaultValue(taskInputType.getDefaultValue());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskOutputTypeResource> toResource(TaskOutputType taskOutputType) {
        if (taskOutputType != null) {
            TaskOutputTypeResource resource = new TaskOutputTypeResource();
            resource.setId(taskOutputType.getId());
            resource.setName(taskOutputType.getName());
            resource.setType(taskOutputType.getType());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<TaskOutPortTypeResource> toResource(TaskOutPortType taskOutPort) {
        if (taskOutPort != null) {
            TaskOutPortTypeResource resource = new TaskOutPortTypeResource();
            resource.setId(taskOutPort.getId());
            resource.setName(taskOutPort.getName());
            resource.setOrder(taskOutPort.getOrder());
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }

    public static Optional<WorkflowResource> toResource(Workflow workflow) {
        if (workflow != null) {
            WorkflowResource resource = new WorkflowResource();
            resource.setId(workflow.getId());
            resource.setName(workflow.getName());
            resource.setWorkflowGraphXML(new String(workflow.getWorkFlowGraph()));
            Optional.ofNullable(workflow.getProcesses()).ifPresent(processModels -> {
                processModels.forEach(processModel -> {
                    resource.getProcessIds().add(processModel.getId());
                });
            });
            return Optional.of(resource);
        } else {
            return Optional.empty();
        }
    }
}