package com.atsistemas.jira.addons.createLinkedIssue.workflow;

import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import com.atlassian.jira.component.ComponentAccessor;
import com.atlassian.jira.config.IssueTypeManager;
import com.atlassian.jira.event.type.EventDispatchOption;
import com.atlassian.jira.exception.CreateException;
import com.atlassian.jira.issue.AttachmentManager;
import com.atlassian.jira.issue.CustomFieldManager;
import com.atlassian.jira.issue.IssueFactory;
import com.atlassian.jira.issue.IssueManager;
import com.atlassian.jira.issue.MutableIssue;
import com.atlassian.jira.issue.attachment.Attachment;
import com.atlassian.jira.issue.comments.CommentManager;
import com.atlassian.jira.issue.fields.CustomField;
import com.atlassian.jira.issue.link.IssueLinkManager;
import com.atlassian.jira.project.Project;
import com.atlassian.jira.project.ProjectManager;
import com.atlassian.jira.security.JiraAuthenticationContext;
import com.atlassian.jira.user.util.UserManager;
import com.atlassian.jira.workflow.function.issue.AbstractJiraFunctionProvider;
import com.atlassian.pocketknife.api.commons.error.AnError;
import com.atlassian.servicedesk.api.requesttype.RequestType;
import com.atlassian.servicedesk.api.requesttype.RequestTypeQuery;
import com.atlassian.servicedesk.api.requesttype.RequestTypeService;
import com.atlassian.servicedesk.api.util.paging.PagedResponse;
import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.workflow.WorkflowException;
/**
 * This is the post-function class that gets executed at the end of the
 * transition. Any parameters that were saved in your factory class will be
 * available in the transientVars Map.
 */
public class CreateLinkedIssuePostFunction extends AbstractJiraFunctionProvider {
    private static final Logger log = LoggerFactory.getLogger(CreateLinkedIssuePostFunction.class);
    public static final String SELECTED_ORIGIN_PROJECT = "originProjectSelect";
    public static final String SELECTED_PROJECT = "projectSelect";
    public static final String SELECTED_LINKTYPE = "linkTypeSelect";
    public static final String SELECTED_ORIGIN_ISSUETYPE = "originIssueTypeSelect";
    public static final String SELECTED_ISSUETYPE = "issueTypeSelect";
    public static final String SELECTED_USER = "userSelect";
    public static final String SELECTED_CF_CUSTOMER = "cfCustomerSelect";
    public static final String SELECTED_CF_REQTYPE = "cfReqtypeSelect";

    private final ProjectManager projectManager;
    private final IssueFactory issueFactory;
    private final IssueManager issueManager;
    private final IssueLinkManager issueLinkManager;
    private final IssueTypeManager issueTypeManager;
    private final AttachmentManager attachmentManager;
    private final UserManager userManager;
    private final CustomFieldManager customFieldManager;
    private final CommentManager commentManager;
    private final JiraAuthenticationContext jiraAuthenticationContext;

    public CreateLinkedIssuePostFunction(ProjectManager projectManager, IssueFactory issueFactory,
            IssueManager issueManager, IssueLinkManager issueLinkManager, IssueTypeManager issueTypeManager,
            AttachmentManager attachmentManager, UserManager userManager, CustomFieldManager customFieldManager,
            CommentManager commentManager, JiraAuthenticationContext jiraAuthenticationContext) {
        this.projectManager = projectManager;
        this.issueFactory = issueFactory;
        this.issueManager = issueManager;
        this.issueLinkManager = issueLinkManager;
        this.issueTypeManager = issueTypeManager;
        this.attachmentManager = attachmentManager;
        this.userManager = userManager;
        this.customFieldManager = customFieldManager;
        this.commentManager = commentManager;
        this.jiraAuthenticationContext = jiraAuthenticationContext;
    }

    public void execute(Map transientVars, Map args, PropertySet ps) throws WorkflowException {

        MutableIssue issue = getIssue(transientVars);
        String originProjectId = (String) args.get(SELECTED_ORIGIN_PROJECT);
        String projectId = (String) args.get(SELECTED_PROJECT);
        String linkTypeId = (String) args.get(SELECTED_LINKTYPE);
        String originIssueTypeId = (String) args.get(SELECTED_ORIGIN_ISSUETYPE);
        String issueTypeId = (String) args.get(SELECTED_ISSUETYPE);
        String userKey = (String) args.get(SELECTED_USER);
        String cfCustomer = (String) args.get(SELECTED_CF_CUSTOMER);
        String cfReqtype = (String) args.get(SELECTED_CF_REQTYPE);

        if (issue.getProjectId().toString().equals(originProjectId)
                && issue.getIssueTypeId().equals(originIssueTypeId)) {

            final Project project = projectManager.getProjectObj(new Long(projectId));

            final MutableIssue linkedIssue = issueFactory.getIssue();
            linkedIssue.setProjectObject(project);
            linkedIssue.setSummary(issue.getSummary());
            linkedIssue.setIssueType(issueTypeManager.getIssueType(issueTypeId));
            linkedIssue.setDescription(issue.getDescription());
            linkedIssue.setPriority(issue.getPriority());
            linkedIssue.setComponent(issue.getComponents());
            linkedIssue.setLabels(issue.getLabels());
            linkedIssue.setDueDate(issue.getDueDate());
            linkedIssue.setReporter(userManager.getUserByKey(userKey));

            final List<CustomField> customfields = customFieldManager.getCustomFieldObjects();
            for (CustomField cs : customfields) {
                linkedIssue.setCustomFieldValue(cs, issue.getCustomFieldValue(cs));
            }

            if(cfCustomer != null) {
                CustomField cf = customFieldManager.getCustomFieldObject(cfCustomer);
                if(cf != null) {
                    linkedIssue.setCustomFieldValue(cf, issue.getReporterUser().getDisplayName()+" ("+issue.getReporterUser().getUsername()+")");
                }
            }

            if(cfReqtype != null) {
                CustomField cf = customFieldManager.getCustomFieldObject(cfReqtype);
                if(cf != null) {
                    RequestTypeService requestTypeService = ComponentAccessor.getOSGiComponentInstanceOfType(RequestTypeService.class) ;
                    if(requestTypeService != null) {
                        RequestTypeQuery issueQuery = requestTypeService.newQueryBuilder().issue(issue.getId()).build();
                        PagedResponse<RequestType> requestTypeEither =  requestTypeService.getRequestTypes(
                            jiraAuthenticationContext.getLoggedInUser(),
                            issueQuery
                        );
                        if(requestTypeEither.getResults()==null) {
                            log.error("REQUEST TYPE ERROR >>>>>>>>>>>>>>>>");
                            log.error(requestTypeEither.toString());
                        }else {
                            if(requestTypeEither.getResults().size() > 0) {
                                RequestType requestType = requestTypeEither.getResults().get(0);
                                String reqGroup = "";
                                if(requestType.getGroups().size() > 0) {
                                    reqGroup = requestType.getGroups().get(0).getName();
                                }
                                String requestTypeValue = reqGroup+" / "+requestType.getName();
                                linkedIssue.setCustomFieldValue(cf, requestTypeValue);
                            }
                        }
                    }
                }
            }

            try {
                issueManager.createIssueObject(userManager.getUserByKey(userKey), linkedIssue);
                issueLinkManager.createIssueLink(issue.getId(), linkedIssue.getId(), new Long(linkTypeId), null,
                        userManager.getUserByKey(userKey));
                attachmentManager.copyAttachments(issue, userManager.getUserByKey(userKey), linkedIssue.getKey());
                issueManager.updateIssue(userManager.getUserByKey(userKey), linkedIssue,
                        EventDispatchOption.ISSUE_UPDATED, false);

            } catch (CreateException e) {
                log.error("Error creating linked issue: " + e.getMessage());
            }

            Collection<Attachment> attachments = issue.getAttachments();
            String bodyComment = "";
            if (!attachments.isEmpty()) {
                for (Attachment at : attachments) {
                    if (at.getMimetype().contains("image")) {
                        bodyComment = bodyComment + "\n\n!" + at.getFilename() + "|thumbnail!";
                    } else {
                        bodyComment = bodyComment + "\n\n[^" + at.getFilename() + "] _(" + Math.round(at.getFilesize()/1024.0) + " kB)_";
                    }
                }
                commentManager.create(linkedIssue, jiraAuthenticationContext.getLoggedInUser(), bodyComment, false);
            }
        }
    }
}