package com.onresolve.jira.groovy.canned.admin

import com.atlassian.jira.ComponentManager

import com.atlassian.jira.util.ErrorCollection

import com.onresolve.jira.groovy.canned.CannedScript

import org.apache.log4j.Category
import com.atlassian.query.clause.Clause
import com.atlassian.query.clause.TerminalClauseImpl
import com.atlassian.query.operand.Operand
import com.atlassian.query.operand.SingleValueOperand
import com.atlassian.query.clause.OrClause
import com.atlassian.jira.issue.search.SearchRequestManager
import com.atlassian.jira.issue.search.SearchRequest

import com.atlassian.jira.bc.filter.SearchRequestService

import com.atlassian.jira.util.collect.EnclosedIterable

import com.atlassian.jira.util.Consumer
import com.atlassian.query.clause.ClauseVisitor
import com.atlassian.query.clause.AndClause
import com.atlassian.query.clause.NotClause

import com.atlassian.query.clause.TerminalClause

import com.atlassian.query.operand.OperandVisitor
import com.atlassian.query.operand.EmptyOperand
import com.atlassian.query.operand.FunctionOperand
import com.atlassian.query.operand.MultiValueOperand

import com.atlassian.query.Query
import com.atlassian.query.QueryImpl

import com.atlassian.jira.issue.search.managers.SearchHandlerManager
import com.atlassian.jira.jql.ClauseHandler
import com.atlassian.jira.issue.CustomFieldManager
import com.atlassian.jira.issue.customfields.CustomFieldType

import com.atlassian.jira.issue.fields.UserField
import com.atlassian.jira.bc.JiraServiceContextImpl
import com.atlassian.core.ofbiz.util.CoreTransactionUtil
import com.atlassian.jira.event.ClearCacheEvent
import com.atlassian.event.api.EventPublisher
import com.atlassian.jira.imports.project.parser.UserAssociationParser
import org.ofbiz.core.entity.GenericValue
import com.atlassian.jira.util.ImportUtils
import com.atlassian.jira.issue.index.IssueIndexManager
import com.atlassian.jira.ManagerFactory
import com.atlassian.jira.issue.IssueManager
import org.ofbiz.core.entity.DelegatorInterface
import org.ofbiz.core.entity.EntityOperator
import org.ofbiz.core.entity.EntityExpr
import org.ofbiz.core.entity.EntityConditionList
import com.atlassian.jira.security.roles.actor.UserRoleActorFactory
import com.atlassian.jira.security.roles.CachingProjectRoleAndActorStore
import com.atlassian.jira.notification.type.SingleUser
import com.atlassian.jira.issue.security.IssueSecuritySchemeManagerImpl
import com.atlassian.jira.permission.DefaultPermissionSchemeManager
import com.atlassian.jira.notification.DefaultNotificationSchemeManager
import com.atlassian.jira.issue.search.CachingSearchRequestStore
import com.atlassian.jira.util.SimpleErrorCollection
import com.atlassian.jira.util.BuildUtils
import com.atlassian.query.clause.WasClause
import com.atlassian.jira.user.util.UserUtil
import com.atlassian.query.clause.ChangedClause

public class RenameUser implements CannedScript {

    Category log = Category.getInstance(RenameUser.class)
    ComponentManager componentManager = ComponentManager.getInstance()
    UserUtil userUtil = componentManager.getUserUtil()
    SearchRequestManager searchRequestManager = componentManager.getSearchRequestManager()
    def searchRequestService = componentManager.getSearchRequestService()

    public static final String FIELD_FROM_USER_ID = 'FIELD_FROM_USER_ID'
    public static final String FIELD_TO_USER_ID = 'FIELD_TO_USER_ID'
    public static final String FIELD_MERGE = 'FIELD_MERGE'

    List msgs = []
    String msg
    Set<Long> reindexIssueIds = new HashSet()
    boolean preview = false
    Long nSearchReqsUpdated = 0
    boolean doMerge

    public String getName() {
        "Renames a user ID"
    }

    public String getDescription() {
        "Changes a user's ID without reindexing or restarting"
    }

    List getCategories() {
        ["ADMIN"]
    }

    public Boolean isFinalParamsPage(Map params) {
        true
    }

    public List getParameters(Map params) {
        [
            [
                Name: FIELD_FROM_USER_ID,
                Label: 'From user ID',
                Description: "Rename or merge from who?",
            ],
            [
                Name: FIELD_TO_USER_ID,
                Label: 'To user ID',
                Description: "Rename or merge to who?",
            ],
            [
                Name: FIELD_MERGE,
                Label: 'Merge',
                Type: 'radio',
                Description: "Merge the first user to the second user, rather than rename",
                Values: ["false": "Rename", "true": "Merge"],
            ],
        ]
    }

    ErrorCollection doValidate(Map params, boolean forPreview) {
        ErrorCollection errorCollection = new SimpleErrorCollection()
        String sourceUserId = params[FIELD_FROM_USER_ID] as String
        String targetUserId = params[FIELD_TO_USER_ID] as String

        if (! params[FIELD_MERGE]) {
            errorCollection.addError(FIELD_MERGE, "Please select an option")
        }
        doMerge = Boolean.parseBoolean(params[FIELD_MERGE] as String)

        [FIELD_FROM_USER_ID, FIELD_TO_USER_ID].each {String p ->
            if (! params[p]) {
                errorCollection.addError(p, "Please provide the user ID")
            }
        }
        if (errorCollection.hasAnyErrors()) {
            return errorCollection
        }

        if (! userUtil.getUser(sourceUserId as String)) {
            errorCollection.addError(FIELD_FROM_USER_ID, "Cannot find user ID")
        }

        if (sourceUserId == targetUserId) {
            errorCollection.addErrorMessage("From and to user can't be the same")
        }

        /* TODO: make rename/merge transparent
        boolean targetExists = userUtil.getUser(targetUserId as String) as Boolean
        if (doMerge && ! targetExists) {
            errorCollection.addError(FIELD_TO_USER_ID, "Target user ID must exist already for a merge")
        }
        */

        if (! doMerge && targetExists) {
            errorCollection.addError(FIELD_TO_USER_ID, "Target user ID must not exist already")
        }

        if (sourceUserId == componentManager.getJiraAuthenticationContext().getUser()?.name) {
            errorCollection.addError(FIELD_FROM_USER_ID, "You can't rename the logged in user")
        }

        errorCollection
    }

    Query transformSearchRequest(Query query, String sourceUser, String targetUser) {
        Clause whereClause = query.getWhereClause()
        Clause newWhereClause = whereClause.accept(new RenamingClauseVisitor(sourceUser, targetUser)) as Clause

//        log.debug("original whereClause: " + query.whereClause.toString())
//        log.debug "new where clause: " + newWhereClause.toString()

        Query newQuery = new QueryImpl(newWhereClause)
        newQuery = new QueryImpl(newWhereClause, query.orderByClause, newQuery.queryString)
        newQuery
    }

    Map doScript(Map params) {
        String sourceUser = params[FIELD_FROM_USER_ID] as String
        String targetUser = params[FIELD_TO_USER_ID] as String
        doMerge = Boolean.parseBoolean(params[FIELD_MERGE] as String)

        // make sure they're not logged on??

        if (!preview) {
            msgs << "<b>Completed</b><br>"
        }
        updateGenericValues(sourceUser, targetUser)
        updateAllSearchRequests(sourceUser, targetUser)

        if (!preview) {
            msg = "Completed ${doMerge ? "merge" : "rename"} of $sourceUser to $targetUser"
            log.warn(msg)
            msgs << msg
        }



        params["output"] = "<pre>" + msgs.join("\n") + "<pre>"
        params
    }

    private def reindexIssue(IssueManager issueManager, Long issueId, Category log, IssueIndexManager indexManager) {
        GenericValue issue = issueManager.getIssue(issueId)
        boolean wasIndexing = ImportUtils.isIndexIssues();
        ImportUtils.setIndexIssues(true);
        if ((BuildUtils.getCurrentBuildNumber() as Long) < 614) {
            ManagerFactory.getCacheManager().flush(com.atlassian.jira.issue.cache.CacheManager.ISSUE_CACHE, issue)
        }
        log.debug("Reindex issue ${issue.key}")
        indexManager.reIndex(issue);
        ImportUtils.setIndexIssues(wasIndexing)
    }

    def updateGenericValues(String sourceUser, String targetUser) {
        boolean began = false

        DelegatorInterface gd = (DelegatorInterface) componentManager.getComponentInstanceOfType(DelegatorInterface.class)
        IssueIndexManager indexManager = ComponentManager.getInstance().getIndexManager()
        CachingProjectRoleAndActorStore cachingProjectRoleAndActorStore = ComponentManager.getComponentInstanceOfType(CachingProjectRoleAndActorStore.class) as CachingProjectRoleAndActorStore
        DefaultNotificationSchemeManager notificationSchemeManager = ComponentManager.getComponentInstanceOfType(DefaultNotificationSchemeManager.class) as DefaultNotificationSchemeManager
        DefaultPermissionSchemeManager defaultPermissionSchemeManager = ComponentManager.getComponentInstanceOfType(DefaultPermissionSchemeManager.class) as DefaultPermissionSchemeManager
        IssueSecuritySchemeManagerImpl securitySchemeManager = ComponentManager.getComponentInstanceOfType(IssueSecuritySchemeManagerImpl.class) as IssueSecuritySchemeManagerImpl
        CachingSearchRequestStore cachingSearchRequestStore = ComponentManager.getComponentInstanceOfType(CachingSearchRequestStore.class) as CachingSearchRequestStore
        IssueManager issueManager = componentManager.getIssueManager()

        if (! preview) {
            log.debug("Begin transaction")
            began = CoreTransactionUtil.begin();
        }

        try {
            msg = "Beginning ${doMerge ? "merge" : "rename"} of $sourceUser to $targetUser"
            log.warn(msg)
            msgs << msg

            // Rename the user record itself
            if ((BuildUtils.getCurrentBuildNumber() as Long) < 614) {
                List gvs = gd.findByAnd("OSUser", [name: sourceUser])
                if (! preview) {
		            gvs.each { GenericValue usergv ->
                	if (doMerge) {
                    	    // todo: delete their associated property records
                    	    usergv.remove()
                	}
                	else {
                    	    usergv.set("name", targetUser)
                    	    usergv.store()
                	}
		    }
                }

                // group memberships
                gvs = gd.findByAnd("OSMembership", [userName: sourceUser])
                msg = "Update ${gvs.size()} OSMembership records"
                log.debug(msg)
                msgs << msg
                if (!preview) {

                    List<GenericValue> targetGvs = gd.findByAnd("OSMembership", [userName: targetUser])
                    List<Object> targetGroups = targetGvs*.get("groupName")

                    gvs.each {GenericValue gv ->
                        if (doMerge && targetGroups.contains (gv.get("groupName"))) {
                            gv.remove()
                        }
                        else {
                            gv.set("userName", targetUser)
                            gv.store()
                        }
                    }
                }
            }
            else {
                // todo: only look in jira internal directory
                List gvs = gd.findByAnd("User", [userName: sourceUser])
                gvs.each {GenericValue usergv ->
                    if (! preview) {
                        if (doMerge) {
                            usergv.remove()
                        }
                        else {
                            usergv.set("userName", targetUser)
                            usergv.set("lowerUserName", targetUser.toLowerCase())
                            usergv.store()
                        }
                    }
                }

                // group memberships
                gvs = gd.findByAnd("Membership", [childName: sourceUser, directoryId: 1, membershipType: "GROUP_USER"])
                msg = "Update ${gvs.size()} Membership records"
                log.debug(msg)
                msgs << msg
                if (!preview) {

                    List<GenericValue> targetGvs = gd.findByAnd("Membership", [childName: targetUser, directoryId: 1, membershipType: "GROUP_USER"])
                    List<Object> targetGroups = targetGvs*.get("parentName")

                    gvs.each {GenericValue gv ->
                        if (doMerge && targetGroups.contains (gv.get("parentName"))) {
                            gv.remove()
                        }
                        else {
                            gv.set("childName", targetUser)
                            gv.set("lowerChildName", targetUser)
                            gv.store()
                        }
                    }
                }
            }


            // trustedapp
            List gvs = gd.findByAnd("TrustedApplication", [createdBy: sourceUser])
            msg = "Update ${gvs.size()} TrustedApplication records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("createdBy", targetUser)
                    gv.store()
                }
            }

            // SearchRequest ownership
            // if this is a merge, we may get dupe filter names. Not ideal but handled OK by the UI
            gvs = gd.findByOr("SearchRequest", [user: sourceUser, author: sourceUser])
            msg = "Update ${gvs.size()} SearchRequest records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (gv.get("user")) {
                        gv.set("user", targetUser)
                    }
                    if (gv.get("author")) {
                        gv.set("author", targetUser)
                    }
                    cachingSearchRequestStore.removeFromCache(gv.getLong("id"))
                    gv.store()
                }
            }

            // ColumnLayout - choose one or tother.
            gvs = gd.findByAnd("ColumnLayout", [username: sourceUser])
            msg = "Update ${gvs.size()} ColumnLayout records"
            List<GenericValue> targetGvs = gd.findByAnd("ColumnLayout", [username: targetUser])
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (doMerge && targetGvs.find {it.getLong("searchrequest") == gv.getLong("searchrequest")}) {
                        gd.removeRelated("ChildColumnLayoutItem", gv)
                        gv.remove()
                    }
                    else {
                        gv.set("username", targetUser)
                        gv.store()
                    }
                }
            }

            if (!doMerge) {
                gvs = gd.findByAnd("UserHistoryItem", [username: sourceUser])
                msg = "Update ${gvs.size()} UserHistoryItem records"
                log.debug(msg)
                msgs << msg
                if (!preview) {
                    gvs.each {GenericValue gv ->
                        gv.set("username", targetUser)
                        gv.store()
                    }
                }
            }

            gvs = gd.findByAnd("FavouriteAssociations", [username: sourceUser])
            targetGvs = gd.findByAnd("FavouriteAssociations", [username: targetUser])
            msg = "Update ${gvs.size()} FavouriteAssociations records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                List matchFields = ["entityType", "entityId"]
                gvs.each {GenericValue gv ->
                    // favourite assocs, only fave if not already faved
                    if (doMerge && targetGvs.find {
                        it.getFields(matchFields) == gv.getFields(matchFields)
                    }) {
                        // favcount must be adjusted downwards when both are favouriting
                        log.debug("Remove fav association record and decrement favourite count")
                        GenericValue sharedEntityGv = gd.findByPrimaryKey(gv.get("entityType") as String, [id: gv.get("entityId")])
                        sharedEntityGv.set("favCount", (sharedEntityGv.get("favCount") as Long) - 1)
                        sharedEntityGv.store()

                        gv.remove()
                    }
                    else {
                        gv.set("username", targetUser)
                        gv.store()
                    }
                }
            }


            ["PortalPage", "FilterSubscription"].each {String entityName ->
                gvs = gd.findByAnd(entityName, [username: sourceUser])
                msg = "Update ${gvs.size()} $entityName records"
                log.debug(msg)
                msgs << msg
                if (!preview) {
                    gvs.each {GenericValue gv ->
                        gv.set("username", targetUser)
                        gv.store()
                    }
                }
            }
            // note: for versions prior to 4.1 the favouritesStoreCache needs to be flushed

            // Core issue fields
            gvs = gd.findByOr("Issue", [reporter: sourceUser, assignee: sourceUser])
            msg = "Update ${gvs.size()} Issue records"
            log.debug(msg)
            msgs << msg
            gvs.each {GenericValue gv ->
                if (!preview) {
                    if (gv.get("reporter") == sourceUser) {
                        gv.set("reporter", targetUser)
                    }
                    if (gv.get("assignee") == sourceUser) {
                        gv.set("assignee", targetUser)
                    }
                    gv.store()
                }
                reindexIssueIds.add(gv.getLong("id"))
            }

            // issue transition history
            gvs = gd.findByOr("Action", [author: sourceUser, updateauthor: sourceUser])
            msg = "Update ${gvs.size()} Action records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (gv.get("author") == sourceUser) {
                        gv.set("author", targetUser)
                    }
                    if (gv.get("updateauthor") == sourceUser) {
                        gv.set("updateauthor", targetUser)
                    }
                    gv.store()
                }
            }

            // change groups
            gvs = gd.findByAnd("ChangeGroup", [author: sourceUser])
            msg = "Update ${gvs.size()} ChangeGroup records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("author", targetUser)
                    gv.store()
                }
            }

            // Change items
            // todo: custom field history items - problem is they are referenced by name which is not unique
            EntityConditionList conditionList = new EntityConditionList(
                [new EntityConditionList(
                    [
                        // Stoopid oracle can't do equals on a clob, LIKE shd be OK
                        // alternative is to do the filtering in the code
                        new EntityExpr("oldvalue", EntityOperator.LIKE, sourceUser),
                        new EntityExpr("newvalue", EntityOperator.LIKE, sourceUser),
                    ], EntityOperator.OR),
                    new EntityConditionList([new EntityExpr("field", EntityOperator.IN, ["reporter", "assignee"])], EntityOperator.AND)
                ], EntityOperator.AND
            )
            gvs = gd.findByCondition("ChangeItem", conditionList, ["id", "field", "oldvalue", "newvalue"], Collections.<String> emptyList())
            msg = "Update ${gvs.size()} ChangeItem records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (gv.get("oldvalue") == sourceUser) {
                        gv.set("oldvalue", targetUser)
                    }
                    if (gv.get("newvalue") == sourceUser) {
                        gv.set("newvalue", targetUser)
                    }
                    gv.store()
                }
            }

            // Watchers and voters
            gvs = gd.findByAnd("UserAssociation", getUserAssociationConditionList(sourceUser))
            targetGvs = gd.findByAnd("UserAssociation", getUserAssociationConditionList(targetUser))
            msg = "Update ${gvs.size()} UserAssociation records"
            log.debug(msg)
            msgs << msg
                gvs.each {GenericValue gv ->
                if (gv.get("sinkNodeEntity") == "Issue") {
                    reindexIssueIds.add(gv.getLong("sinkNodeId"))
                }
                if (!preview) {
                    gd.removeValue(gv)

                    if (doMerge && targetGvs.find {
                        it.get("sinkNodeId") == gv.get("sinkNodeId") &&
                        it.get("sinkNodeEntity") == gv.get("sinkNodeEntity") &&
                        it.get("associationType") == gv.get("associationType")
                    }) {
                        // do nothing as always remove
                        log.debug("Removed userassoc record")
                    }
                    else {
                        // gv.store() doesn't work because we're changing the primary key
                        gv.set("sourceName", targetUser)
                        gd.create(gv)
                    }
                }
            }

            // roles
            gvs = gd.findByAnd("ProjectRoleActor", [roletype: UserRoleActorFactory.TYPE, roletypeparameter: sourceUser])
            targetGvs = gd.findByAnd("ProjectRoleActor", [roletype: UserRoleActorFactory.TYPE, roletypeparameter: targetUser])
            msg = "Update ${gvs.size()} ProjectRoleActor records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    List matchFields = ["pid", "projectroleid"]
                    /*
                    if (doMerge && targetGvs.find {
                        gv.getFields(matchFields) == it.getFields(matchFields)
                    }) {
                        log.debug("Remove role record")
                        gv.remove()
                    }
                    else {
                    */
                    // we do always want to merge
                        gv.set("roletypeparameter", targetUser)
                        gv.store()
                    //}
                }
                cachingProjectRoleAndActorStore.clearCaches()
            }

            // SharePermissions not required as cannot share with a user

            // worklogs
            gvs = gd.findByOr("Worklog", [author: sourceUser, updateauthor: sourceUser])
            msg = "Update ${gvs.size()} Worklog records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (gv.get("author") == sourceUser) {
                        gv.set("author", targetUser)
                    }
                    if (gv.get("updateauthor") == sourceUser) {
                        gv.set("updateauthor", targetUser)
                    }
                    gv.store()
                }
            }

            // project and comp leads
            gvs = gd.findByAnd("Project", [lead: sourceUser])
            msg = "Update ${gvs.size()} Project records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("lead", targetUser)
                    gv.store()
                }
            }
            gvs = gd.findByAnd("Component", [lead: sourceUser])
            msg = "Update ${gvs.size()} Component records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("lead", targetUser)
                    gv.store()
                }
            }

            // notification schemes
            gvs = gd.findByAnd("Notification", [type: SingleUser.DESC, parameter: sourceUser])
            targetGvs = gd.findByAnd("Notification", [type: SingleUser.DESC, parameter: targetUser])
            msg = "Update ${gvs.size()} Notification records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    if (doMerge && targetGvs.find {
                        gv.getFields(["scheme", "eventTypeId", "type"]) == it.getFields(["scheme", "eventTypeId", "type"])
                    }) {
                        log.debug("Remove Notification record")
                        gv.remove()
                    }
                    else {
                        gv.set("parameter", targetUser)
                        gv.store()
                    }
                }
                notificationSchemeManager.flushProjectSchemes()
            }

            // permission schemes
            gvs = gd.findByAnd("SchemePermissions", [type: "user", parameter: sourceUser])
            targetGvs = gd.findByAnd("SchemePermissions", [type: "user", parameter: targetUser])
            msg = "Update ${gvs.size()} SchemePermissions records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                List matchFields = ['scheme', 'permission', 'type', 'parameter']
                gvs.each {GenericValue gv ->
                    if (doMerge && targetGvs.find {
                        gv.getFields(matchFields) == it.getFields(matchFields)
                    }) {
                        log.debug("Remove Notification record")
                        gv.remove()
                    }
                    else {
                        gv.set("parameter", targetUser)
                        gv.store()
                    }
                }
                defaultPermissionSchemeManager.flushProjectSchemes()
                defaultPermissionSchemeManager.flushSchemeEntities()
            }

            // issue security schemes
            gvs = gd.findByAnd("SchemeIssueSecurities", [type: "user", parameter: sourceUser])
            targetGvs = gd.findByAnd("SchemePermissions", [type: "user", parameter: targetUser])
            msg = "Update ${gvs.size()} SchemeIssueSecurities records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                List matchFields = ['scheme', 'security', 'type', 'parameter']
                gvs.each {GenericValue gv ->
                    if (doMerge && targetGvs.find {
                        gv.getFields(matchFields) == it.getFields(matchFields)
                    }) {
                        log.debug("Remove Notification record")
                        gv.remove()
                    }
                    else {
                        gv.set("parameter", targetUser)
                        gv.store()
                    }
                }
                securitySchemeManager.flushProjectSchemes()
            }

            // user and multi-user custom fields
            gvs = gd.findByCondition("CustomField",
                new EntityExpr("customfieldtypekey", EntityOperator.IN,
                    [
                        "com.atlassian.jira.plugin.system.customfieldtypes:userpicker",
                        "com.atlassian.jira.plugin.system.customfieldtypes:multiuserpicker"
                    ])
                ,
                ["id"], Collections.<String> emptyList())
            Long cfValueKount = 0
            gvs.each {GenericValue gv ->
                gv.getRelatedByAnd("ChildCustomFieldValue", [stringvalue: sourceUser]).each {GenericValue cfGv ->
                    cfValueKount++
                    if (!preview) {
                        cfGv.set("stringvalue", targetUser)
                        cfGv.store()
                    }
                    reindexIssueIds.add(cfGv.getLong("issue"))
                }
            }
            msg = "Update $cfValueKount CustomFieldValue records"
            log.debug(msg)
            msgs << msg

            gvs = gd.findByAnd("OSHistoryStep", [caller: sourceUser])
            msg = "Update ${gvs.size()} OSHistoryStep records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("caller", targetUser)
                    gv.store()
                }
            }

            // fileattachments
            gvs = gd.findByAnd("FileAttachment", [author: sourceUser])
            msg = "Update ${gvs.size()} FileAttachment records"
            log.debug(msg)
            msgs << msg
            if (!preview) {
                gvs.each {GenericValue gv ->
                    gv.set("author", targetUser)
                    gv.store()
                }
            }

            // -------------------------------------- Finalise --------------------------------------
            if (! preview) {
                log.debug("Commit transaction")
                CoreTransactionUtil.commit(began);

                // Only for 4.1 and above - clearing the other caches are not necessary above but kept there if
                // I decide to backport this
                log.debug("Publish clear cache event")
                ComponentManager.getComponentInstanceOfType(EventPublisher.class).publish(ClearCacheEvent.INSTANCE);

                // reindex issues
                reindexIssueIds.each {Long issueId ->
                    reindexIssue(issueManager, issueId, log, indexManager);
                }
            }

            msg = "Reindex ${reindexIssueIds.size()} issues"
            log.debug(msg)
            msgs << msg
        }
        catch (Exception e) {
            log.error("Problem renaming user, rolling back")
            CoreTransactionUtil.rollback(began)
            throw e
        }
        finally {
            // not sure if we need anything here
        }

    }

    private List<EntityExpr> getUserAssociationConditionList(String userId) {
        List userAssocCList = [
            new EntityExpr("sourceName", EntityOperator.EQUALS, userId),
            new EntityExpr("associationType", EntityOperator.IN,
                [UserAssociationParser.ASSOCIATION_TYPE_WATCH_ISSUE, UserAssociationParser.ASSOCIATION_TYPE_VOTE_ISSUE]),
        ]
        return userAssocCList
    }

    def updateSingleRequest(SearchRequest sr, String sourceUser, String targetUser) {
        Query query = sr.getQuery()

        Query newQuery
        // A query may have no where clause and select everything... if so .accept dies
        if (query.getWhereClause()) {
            newQuery = transformSearchRequest(query, sourceUser, targetUser)
        }
        else {
            newQuery = query
        }

        if (query.whereClause.toString() != newQuery.whereClause.toString()) {
            // this is stupid but setting a queryString seems to blow away the whereClause, so we do this twice
            nSearchReqsUpdated++
            log.debug("Update sr name: " + sr.name)
            // log.debug("queryString: " + newQuery.queryString)
            // log.debug("newQuery: $newQuery")

            sr.setQuery(newQuery)
            JiraServiceContextImpl ctx = new JiraServiceContextImpl(userUtil.getUser(sr.ownerUserName))
            searchRequestService.validateFilterForUpdate(ctx, sr)
            if (ctx.errorCollection.hasAnyErrors()) {
                log.error("errors: " + ctx.getErrorCollection())
            }
            else {
                if (! preview) {
                    searchRequestService.updateFilter(ctx, sr)
                }
            }
        }
        else {
            log.debug("No need to update name: " + sr.name)
        }
    }

    private def updateAllSearchRequests(String sourceUser, String targetUser) {
        EnclosedIterable<SearchRequest> srs = searchRequestManager.getAll()
        srs.foreach(new Consumer<SearchRequest>() {
            void consume(SearchRequest sr) {

                try {
                    updateSingleRequest(sr, sourceUser, targetUser)
                } catch (Exception e) {
                    log.error("Error checking or updating search request: $sr - this is not fatal but you may wish to check this manually", e)
                }
            }
        })
        msg = "Update parameters for $nSearchReqsUpdated search requests"
        log.debug(msg)
        msgs << msg
    }

    String getDescription(Map params, boolean forPreview) {
        preview = true
        Map out = doScript(params)
        out["output"]
    }

    public String getHelpUrl() {
        "https://studio.plugins.atlassian.com/wiki/display/GRV/Built-In+Scripts#Built-InScripts-RenameaUserID"
    }
}

private class RenamingClauseVisitor implements ClauseVisitor {

    Category log = Category.getInstance(RenamingClauseVisitor.class)
    SearchHandlerManager searchHandlerManager = ComponentManager.getComponentInstanceOfType(SearchHandlerManager.class) as SearchHandlerManager
    ComponentManager componentManager = ComponentManager.getInstance()
    CustomFieldManager customFieldManager = componentManager.getCustomFieldManager()

    String sourceUser
    String targetUser

    RenamingClauseVisitor(String sourceUser, String targetUser) {
        this.sourceUser = sourceUser
        this.targetUser = targetUser
    }

    Object visit(AndClause andClause) {
        Collection<Clause> newClauses = transformSubClauses(andClause)
        new AndClause(newClauses)
    }

    Object visit(NotClause notClause) {
        new NotClause(notClause.getSubClause().accept(new RenamingClauseVisitor(sourceUser, targetUser)) as Clause)
    }

    Object visit(OrClause orClause) {
        Collection<Clause> newClauses = transformSubClauses(orClause)
        new OrClause(newClauses)
    }

    private Collection<Clause> transformSubClauses(Clause mainClause) {
        Collection<Clause> newClauses = []
        mainClause.getClauses().each {Clause clause ->
            newClauses.add(clause.accept(new RenamingClauseVisitor(sourceUser, targetUser)) as Clause)
        }
        return newClauses
    }

    Object visit(TerminalClause clause) {
        final Collection<ClauseHandler> handlers = searchHandlerManager.getClauseHandler(clause.getName());
        Collection<String> fieldIds = searchHandlerManager.getFieldIds(clause.getName())

        // If there are multiple handers, eg field has multiple duplicate names, don't deal with it
        // ie multiple fields with the same name visible to this user
        if (fieldIds?.size() != 1) {
            return clause
        }

        String fieldId = fieldIds.toList().first()
        boolean isUserField = false
        if (fieldId.startsWith("customfield_")) {
            CustomFieldType cfType = customFieldManager.getCustomFieldObject(fieldId).getCustomFieldType()
            if (cfType instanceof UserField) {
                isUserField = true
            }
        }

        if (["reporter", "assignee"].contains(fieldId) || isUserField) {
            Operand operand = clause.getOperand()
            Operand newOp = operand.accept(new RenamingOperandVisitor(sourceUser, targetUser)) as Operand
            TerminalClauseImpl newTermClause = new TerminalClauseImpl(clause.name, clause.getOperator(), newOp)
            return newTermClause
        }

        clause
    }

    Object visit(WasClause wasClause) {
        // wasClause in 4.3 not handled at the moment
        wasClause
    }

    Object visit(ChangedClause changedClause) {
        // changed not handled
        return null
    }
}

private class RenamingOperandVisitor implements OperandVisitor {

    Category log = Category.getInstance(RenamingOperandVisitor.class)
    String sourceUser
    String targetUser

    RenamingOperandVisitor(String sourceUser, String targetUser) {
        this.sourceUser = sourceUser
        this.targetUser = targetUser
    }

    Object visit(EmptyOperand empty) {
        empty
    }

    Object visit(FunctionOperand function) {
        function
    }

    Object visit(MultiValueOperand multiValue) {
        List<Operand> newOps = multiValue.getValues().collectAll {Operand operand ->
            if (operand instanceof SingleValueOperand && operand.getStringValue() == sourceUser) {
                return new SingleValueOperand(targetUser)
            }
            operand
        }
        new MultiValueOperand(newOps)
    }

    Object visit(SingleValueOperand singleValueOperand) {
        if (singleValueOperand.getStringValue() == sourceUser) {
            return new SingleValueOperand(targetUser)
        }
        singleValueOperand
    }

}