import de.hybris.platform.workflow.model.WorkflowTemplateModel;
import de.hybris.platform.workflow.model.WorkflowActionTemplateModel;
import de.hybris.platform.workflow.enums.WorkflowActionType;
import de.hybris.platform.workflow.model.WorkflowDecisionTemplateModel;
import de.hybris.platform.workflow.model.AutomatedWorkflowActionTemplateModel;
import de.hybris.platform.workflow.model.WorkflowModel;
import de.hybris.platform.workflow.model.WorkflowItemAttachmentModel;
import de.hybris.platform.core.model.product.ProductModel;
import java.util.Locale;
import java.util.ArrayList;
import java.util.List;
import de.hybris.platform.core.model.ItemModel;
import java.util.Collection;
import java.util.Collections; 

modelService = spring.getBean('modelService');
userService = spring.getBean('userService');
productService = spring.getBean('productService');
catalogVersionService = spring.getBean('catalogVersionService')
workflowService = spring.getBean('workflowService');
workflowTemplateService = spring.getBean('workflowTemplateService');
workflowProcessingService = spring.getBean('workflowProcessingService');
newestWorkflowService = spring.getBean('newestWorkflowService');


workflowTemplateCode = "productPriceWorkflowTemplate";
workflowTemplateName = "product price workflow template";

//action code | action name | action user | action type | jobHandler
ACTION_PLAN = """
        createProductPriceAction|create product price|creatorUser1|START
        createProductPriceReviewAction|create product price review|approverUser1|NORMAL
        makeWebserviceCallForPriceAction|make webservice call for price|workflowAdminUser1|NORMAL|shopzoneAutomatedWorkflowAction
        createProductPriceSignOffAction|create product price sign off|workflowAdminUser1|END
""";


//decision code | decision name | origin action for this decision
DECISION_PLAN = """
        productPriceCompletedDecision|product price completed|createProductPriceAction
        productPriceApprovedDecision|product price approved|createProductPriceReviewAction
        productPriceRejectedDecision|product price rejected|createProductPriceReviewAction
        webservicesCallSuccessDecision|webservice call success|makeWebserviceCallForPriceAction
        webservicesCallFailureDecision|webservice call failure|makeWebserviceCallForPriceAction
""";

//decision code | target next action for this decision
WORKFLOW_LINK = """
        productPriceCompletedDecision|createProductPriceReviewAction
        productPriceApprovedDecision|makeWebserviceCallForPriceAction
        productPriceRejectedDecision|createProductPriceAction
        webservicesCallSuccessDecision|createProductPriceSignOffAction
        webservicesCallFailureDecision|createProductPriceReviewAction
""";

prepareWorkflow(ACTION_PLAN,DECISION_PLAN,WORKFLOW_LINK);

def prepareWorkflow(ACTION_PLAN,DECISION_PLAN,WORKFLOW_LINK)
{
    WorkflowTemplateModel workflowTemplate = createWorkflowTemplate(workflowTemplateCode,workflowTemplateName);
    List<WorkflowActionTemplateModel> workflowActionTemplateList = createWorkflowActions(workflowTemplate, ACTION_PLAN);
    List<WorkflowDecisionTemplateModel> workflowDecisionTemplateList = createWorkflowDecisions(DECISION_PLAN);
    createWorkflowInstance();
}

def createWorkflowTemplate(workflowTemplateCode,workflowTemplateName)
{
    WorkflowTemplateModel workflowTemplate = modelService.create(WorkflowTemplateModel.class);
    workflowTemplate.setOwner(userService.getUserForUID("admin"));
    workflowTemplate.setCode(workflowTemplateCode);
    workflowTemplate.setName(workflowTemplateName, Locale.ENGLISH);
    modelService.save(workflowTemplate);
    return workflowTemplate;
}

def createWorkflowActions(workflowTemplate, ACTION_PLAN)
{
    //action code | action name | action user | action type | jobHandler

    //create list of WorkflowActionTemplateModel
    workflowActionTemplateList = [];

    def actions = ACTION_PLAN.split("\n");

    for (String action : actions) 
    {
        //if action is not blank 
        if(action.isBlank())
        {
            continue;
        }

        def actionDetails = action.split("\\|");
        workflowActionTemplate = null;
        if(actionDetails.length > 4 && actionDetails[4] != null && !actionDetails[4].isBlank())
        {
            workflowActionTemplate = modelService.create(AutomatedWorkflowActionTemplateModel.class);
        }
        else
        {
            workflowActionTemplate = modelService.create(WorkflowActionTemplateModel.class);
        }
        
        workflowActionTemplate.setOwner(userService.getUserForUID("admin"));
        workflowActionTemplate.setCode(actionDetails[0].trim());
        workflowActionTemplate.setName(actionDetails[1], Locale.ENGLISH);
        workflowActionTemplate.setPrincipalAssigned(userService.getUserForUID(actionDetails[2]));
        workflowActionTemplate.setActionType(WorkflowActionType.valueOf(actionDetails[3]));
        workflowActionTemplate.setWorkflow(workflowTemplate);
        //actionDetails[3] is not blanck then set jobHandler
        if(actionDetails.length > 4 && actionDetails[4] != null && !actionDetails[4].isBlank())
        {
            workflowActionTemplate.setJobHandler(actionDetails[4]);
        }
        modelService.save(workflowActionTemplate);
        workflowActionTemplateList.add(workflowActionTemplate);
    }
    return workflowActionTemplateList;
}

def createWorkflowDecisions(DECISION_PLAN)
{
    //decision code | decision name | origin action for this decision

    //create list of WorkflowDecisionTemplateModel
    List<WorkflowDecisionTemplateModel> workflowDecisionTemplateList = new ArrayList<WorkflowDecisionTemplateModel>();

    def decisions = DECISION_PLAN.split("\n");
    for (String decision : decisions) 
    {
        if(decision.isBlank())
        {
            continue;
        }

        def decisionDetails = decision.split("\\|");
        WorkflowDecisionTemplateModel workflowDecisionTemplate = modelService.create(WorkflowDecisionTemplateModel.class);
        workflowDecisionTemplate.setOwner(userService.getUserForUID("admin"));
        workflowDecisionTemplate.setCode(decisionDetails[0].trim());
        workflowDecisionTemplate.setName(decisionDetails[1], Locale.ENGLISH);
        println  decisionDetails[0]+' source action > '+decisionDetails[2];
        workflowDecisionTemplate.setActionTemplate(workflowActionTemplateList.find { it.code == decisionDetails[2] });

        def targetActionModels = findAllTargetActionsForDecision(decisionDetails[0]);

        workflowDecisionTemplate.setToTemplateActions(targetActionModels);
        modelService.save(workflowDecisionTemplate);
        workflowDecisionTemplateList.add(workflowDecisionTemplate);
    }
    return workflowDecisionTemplateList;
}

def findAllTargetActionsForDecision(decisionCode)
{
    //decision code | target next action for this decision

    def links = WORKFLOW_LINK.split("\n");
    def targetActions = new ArrayList<String>();
    for (String link : links) 
    {
        def linkDetails = link.split("\\|");
        if(linkDetails[0] == decisionCode)
        {
            targetActions.add(linkDetails[1]);
        }
    }

    def targetActionModels = [];
    targetActionModels = targetActions.collect { targetAction ->
    WorkflowActionTemplateModel foundModel = workflowActionTemplateList.find { it.getCode() == targetAction }
            if (foundModel == null) {
                throw new RuntimeException("No model found with the code: ${targetAction}")
            }
            return foundModel
    }

   
    targetActionModels.removeAll([null]);
    return targetActionModels;
}


def createWorkflowInstance()
{
    WorkflowTemplateModel workflowTemplate = workflowTemplateService.getWorkflowTemplateForCode(workflowTemplateCode);
                            
    catalog = catalogVersionService.getCatalogVersion('apparelProductCatalog', 'Online');
    ProductModel product = productService.getProduct(catalog,"300618506");

    WorkflowModel workflow = newestWorkflowService.createWorkflow("prodPriceWorkEx1",workflowTemplate, Collections.<ItemModel> singletonList(product),userService.getUserForUID("admin"));
    workflowProcessingService.startWorkflow(workflow);
}