import com.atlassian.bitbucket.commit.Changeset
import com.atlassian.bitbucket.commit.ChangesetsRequest
import com.atlassian.bitbucket.commit.Commit
import com.atlassian.bitbucket.commit.CommitService
import com.atlassian.bitbucket.content.Change
import com.atlassian.bitbucket.content.ChangeType
import com.atlassian.bitbucket.hook.HookResponse
import com.atlassian.bitbucket.repository.RefChange
import com.atlassian.bitbucket.repository.RefChangeType
import com.atlassian.bitbucket.repository.Repository
import com.atlassian.bitbucket.scm.CommandOutputHandler
import com.atlassian.bitbucket.scm.git.command.GitCommandBuilderFactory
import com.atlassian.bitbucket.util.*
import com.atlassian.plugin.PluginAccessor
import com.atlassian.sal.api.component.ComponentLocator
import com.atlassian.utils.process.BaseOutputHandler
import com.google.common.collect.Iterables
import com.onresolve.scriptrunner.canned.bitbucket.util.BitbucketCannedScriptUtils
import com.onresolve.scriptrunner.runner.ScriptRunnerImpl
import org.apache.commons.io.IOUtils
import org.apache.commons.io.input.ProxyInputStream

def refChanges = refChanges as Collection<RefChange>
def repository = repository as Repository
def hookResponse = hookResponse as HookResponse

def pluginAccessor = ComponentLocator.getComponent(PluginAccessor)
def gitCmdBuilderFactory = pluginAccessor.getEnabledPluginModule(ScriptRunnerImpl.PLUGIN_KEY + ":gitCmdBuilderFactory").getModule() as GitCommandBuilderFactory

refChanges = refChanges.findAll { it.type != RefChangeType.DELETE }

if (! refChanges) {
    return true
}

def commits = refChanges.getCommits(repository)
def changesets = getChangesets(repository, commits)

def changes = getChanges(changesets)

def changesWithCollisions = [] as List<Change>

changes
    .findAll { it.type != ChangeType.DELETE }
    .each { change ->

    def file = new File(change.path.name)

    try {
        gitCmdBuilderFactory.builder(repository)
            .command("cat-file")
            .argument("blob")
            .argument(change.contentId)
            .build(new FileOutputHandler(file))
            .call()

        def result = "sha1dcsum $change.path.name".execute().text

        if (collisionFound(result)) {
            changesWithCollisions << change
        }
    } finally {
        file.delete()
    }
}

if (changesWithCollisions) {
    def sb = new StringBuilder()
    sb << "SHA-1 collision detected in the following files:\n"

    changesWithCollisions.each { change ->
        sb << "${change.path.toString()} - $change.contentId"
    }

    hookResponse.out().write(BitbucketCannedScriptUtils.wrapHookResponse(sb))
    return false
}

return true

private Iterable<Change> getChanges(Iterable<Changeset> changesets) {
    Iterables.concat(changesets.collect {
        it.changes.values
    })
}

private Iterable<Changeset> getChangesets(Repository repository, Iterable<Commit> commits) {
    def commitService = ComponentLocator.getComponent(CommitService)

    new PagedIterable<Changeset>(new PageProvider<Changeset>() {
        @Override
        public Page<Changeset> get(PageRequest pageRequest) {
            return commitService.getChangesets(new ChangesetsRequest.Builder(repository)
                .commitIds(commits*.id)
                .maxChangesPerCommit(100)
                .ignoreMissing(true)
                .build(), pageRequest)
        }
    }, new PageRequestImpl(0, 100))
}

private boolean collisionFound(String result) {
    def parts = result.split(" ")

    parts[1] == "*coll*"
}

// Adapted from com.atlassian.stash.internal.scm.git.command.FileOutputHandler
class FileOutputHandler extends BaseOutputHandler implements CommandOutputHandler<Boolean> {

    private final File file
    private long bytes

    FileOutputHandler(File file) {
        this.file = file
    }

    @Override
    Boolean getOutput() {
        return bytes > 0
    }

    @Override
    void process(InputStream output) {
        InputStream inputStream = new WatchdogAwareInputStream(output)
        try {
            bytes = IoUtils.copy(inputStream, file)
        } catch (IOException e) {
            throw new RuntimeException("Output could not be copied to " + file.getAbsolutePath(), e)
        } finally {
            IOUtils.closeQuietly(inputStream)
        }
    }

    private class WatchdogAwareInputStream extends ProxyInputStream {

        WatchdogAwareInputStream(InputStream proxy) {
            super(proxy)
        }

        @Override
        protected void beforeRead(int n) throws IOException {
            resetWatchdog()
        }
    }
}