#!/usr/bin/perl -w

# Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer. 
# 2.  Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution. 
# 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
#     its contributors may be used to endorse or promote products derived
#     from this software without specific prior written permission. 
#
# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Merge and resolve ChangeLog conflicts for svn and git repositories

use strict;

use FindBin;
use lib $FindBin::Bin;

use File::Basename;
use File::Path;
use File::Spec;
use Getopt::Long;
use POSIX;
use VCSUtils;

sub conflictFiles($);
sub findChangeLog($);
sub fixChangeLogPatch($);
sub fixMergedChangeLogs($;@);
sub fixOneMergedChangeLog($);
sub mergeChanges($$$);
sub parseFixMerged($$;$);
sub removeChangeLogArguments();
sub resolveChangeLog($);
sub resolveConflict($);
sub showStatus($;$);
sub usageAndExit();

my $SVN = "svn";
my $GIT = "git";

my $fixMerged;
my $printWarnings = 1;
my $showHelp;

my $getOptionsResult = GetOptions(
    'f|fix-merged:s' => \&parseFixMerged,
    'h|help'         => \$showHelp,
    'w|warnings!'    => \$printWarnings,
);

my @changeLogFiles = removeChangeLogArguments();

if (scalar(@ARGV) > 0) {
    print STDERR "ERROR: Files listed on command-line that are not ChangeLogs.\n";
    undef $getOptionsResult;
} elsif (!defined $fixMerged && scalar(@changeLogFiles) == 0) {
    print STDERR "ERROR: No ChangeLog files listed on command-line.\n";
    undef $getOptionsResult;
} elsif (defined $fixMerged && !isGit()) {
    print STDERR "ERROR: --fix-merged may only be used with a git repository\n";
    undef $getOptionsResult;
}

sub usageAndExit()
{
    print STDERR <<__END__;
Usage: @{[ basename($0) ]} [options] path/to/ChangeLog [path/to/another/ChangeLog ...]
  -f|--fix-merged [revision-range] fix git-merged ChangeLog entries; if a revision-range
                                   is specified, run git filter-branch on the range
  -h|--help                        show this help message
  -w|--[no-]warnings               show or suppress warnings (default: show warnings)
__END__
    exit 1;
}

if (!$getOptionsResult || $showHelp) {
    usageAndExit();
}

if (defined $fixMerged && length($fixMerged) > 0) {
    my $commitRange = $fixMerged;
    $commitRange = $commitRange . "..HEAD" if index($commitRange, "..") < 0;
    fixMergedChangeLogs($commitRange, @changeLogFiles);
} elsif (@changeLogFiles) {
    for my $file (@changeLogFiles) {
        if (defined $fixMerged) {
            fixOneMergedChangeLog($file);
        } else {
            resolveChangeLog($file);
        }
    }
} else {
    print STDERR "ERROR: Unknown combination of switches and arguments.\n";
    usageAndExit();
}

exit 0;

sub conflictFiles($)
{
    my ($file) = @_;
    my $fileMine;
    my $fileOlder;
    my $fileNewer;

    if (-e $file && -e "$file.orig" && -e "$file.rej") {
        return ("$file.rej", "$file.orig", $file);
    }

    if (isSVN()) {
        open STAT, "-|", $SVN, "status", $file || die;
        my $status = <STAT>;
        close STAT;
        if (!$status || $status !~ m/^C\s+/) {
            print STDERR "WARNING: ${file} is not in a conflicted state.\n" if $printWarnings;
            return ();
        }

        $fileMine = "${file}.mine" if -e "${file}.mine";

        my $currentRevision;
        open INFO, "-|", $SVN, "info", $file || die;
        while (my $line = <INFO>) {
            $currentRevision = $1 if $line =~ m/^Revision: ([0-9]+)/;
        }
        close INFO;
        $fileNewer = "${file}.r${currentRevision}" if -e "${file}.r${currentRevision}";

        my @matchingFiles = grep { $_ ne $fileNewer } glob("${file}.r[0-9][0-9]*");
        if (scalar(@matchingFiles) > 1) {
            print STDERR "WARNING: Too many conflict files exist for ${file}!\n" if $printWarnings;
        } else {
            $fileOlder = shift @matchingFiles;
        }
    } elsif (isGit()) {
        my $gitPrefix = `$GIT rev-parse --show-prefix`;
        chomp $gitPrefix;
        open GIT, "-|", $GIT, "ls-files", "--unmerged", $file || die;
        while (my $line = <GIT>) {
            my ($mode, $hash, $stage, $fileName) = split(' ', $line);
            my $outputFile;
            if ($stage == 1) {
                $fileOlder = "${file}.BASE.$$";
                $outputFile = $fileOlder;
            } elsif ($stage == 2) {
                $fileNewer = "${file}.LOCAL.$$";
                $outputFile = $fileNewer;
            } elsif ($stage == 3) {
                $fileMine = "${file}.REMOTE.$$";
                $outputFile = $fileMine;
            } else {
                die "Unknown file stage: $stage";
            }
            system("$GIT cat-file blob :${stage}:${gitPrefix}${file} > $outputFile");
        }
        close GIT;
    } else {
        die "Unknown version control system";
    }

    if (!$fileMine && !$fileOlder && !$fileNewer) {
        print STDERR "WARNING: ${file} does not need merging.\n" if $printWarnings;
    } elsif (!$fileMine || !$fileOlder || !$fileNewer) {
        print STDERR "WARNING: ${file} is missing some conflict files.\n" if $printWarnings;
    }

    return ($fileMine, $fileOlder, $fileNewer);
}

sub findChangeLog($) {
    return $_[0] if basename($_[0]) eq "ChangeLog";

    my $file = File::Spec->catfile($_[0], "ChangeLog");
    return $file if -d $_[0] and -e $file;

    return undef;
}

sub fixChangeLogPatch($)
{
    my $patch = shift;
    my $contextLineCount = 3;

    return $patch if $patch !~ /\n@@ -1,(\d+) \+1,(\d+) @@\n( .*\n)+(\+.*\n)+( .*\n){$contextLineCount}$/m;
    my ($oldLineCount, $newLineCount) = ($1, $2);
    return $patch if $oldLineCount <= $contextLineCount;

    # The diff(1) command is greedy when matching lines, so a new ChangeLog entry will
    # have lines of context at the top of a patch when the existing entry has the same
    # date and author as the new entry.  This nifty loop alters a ChangeLog patch so
    # that the added lines ("+") in the patch always start at the beginning of the
    # patch and there are no initial lines of context.
    my $newPatch;
    my $lineCountInState = 0;
    my $oldContentLineCountReduction = $oldLineCount - $contextLineCount;
    my $newContentLineCountWithoutContext = $newLineCount - $oldLineCount - $oldContentLineCountReduction;
    my ($stateHeader, $statePreContext, $stateNewChanges, $statePostContext) = (1..4);
    my $state = $stateHeader;
    foreach my $line (split(/\n/, $patch)) {
        $lineCountInState++;
        if ($state == $stateHeader && $line =~ /^@@ -1,$oldLineCount \+1,$newLineCount @\@$/) {
            $line = "@@ -1,$contextLineCount +1," . ($newLineCount - $oldContentLineCountReduction) . " @@";
            $lineCountInState = 0;
            $state = $statePreContext;
        } elsif ($state == $statePreContext && substr($line, 0, 1) eq " ") {
            $line = "+" . substr($line, 1);
            if ($lineCountInState == $oldContentLineCountReduction) {
                $lineCountInState = 0;
                $state = $stateNewChanges;
            }
        } elsif ($state == $stateNewChanges && substr($line, 0, 1) eq "+") {
            # No changes to these lines
            if ($lineCountInState == $newContentLineCountWithoutContext) {
                $lineCountInState = 0;
                $state = $statePostContext;
            }
        } elsif ($state == $statePostContext) {
            if (substr($line, 0, 1) eq "+" && $lineCountInState <= $oldContentLineCountReduction) {
                $line = " " . substr($line, 1);
            } elsif ($lineCountInState > $contextLineCount && substr($line, 0, 1) eq " ") {
                next; # Discard
            }
        }
        $newPatch .= $line . "\n";
    }

    return $newPatch;
}

sub fixMergedChangeLogs($;@)
{
    my $revisionRange = shift;
    my @changedFiles = @_;

    if (scalar(@changedFiles) < 1) {
        # Read in list of files changed in $revisionRange
        open GIT, "-|", $GIT, "diff", "--name-only", $revisionRange || die;
        push @changedFiles, <GIT>;
        close GIT || die;
        die "No changed files in $revisionRange" if scalar(@changedFiles) < 1;
        chomp @changedFiles;
    }

    my @changeLogs = grep { defined $_ } map { findChangeLog($_) } @changedFiles;
    die "No changed ChangeLog files in $revisionRange" if scalar(@changeLogs) < 1;

    system("$GIT filter-branch --tree-filter 'PREVIOUS_COMMIT=\`$GIT rev-parse \$GIT_COMMIT^\` && MAPPED_PREVIOUS_COMMIT=\`map \$PREVIOUS_COMMIT\` $0 -f \"" . join('" "', @changeLogs) . "\"' $revisionRange");

    # On success, remove the backup refs directory
    if (WEXITSTATUS($?) == 0) {
        rmtree(qw(.git/refs/original));
    }
}

sub fixOneMergedChangeLog($)
{
    my $file = shift;
    my $patch;

    # Read in patch for incorrectly merged ChangeLog entry
    {
        local $/ = undef;
        open GIT, "-|", $GIT, "diff", ($ENV{GIT_COMMIT} || "HEAD") . "^", $file || die;
        $patch = <GIT>;
        close GIT || die;
    }

    # Always checkout the previous commit's copy of the ChangeLog
    system($GIT, "checkout", $ENV{MAPPED_PREVIOUS_COMMIT} || "HEAD^", $file);

    # The patch must have 0 or more lines of context, then 1 or more lines
    # of additions, and then 1 or more lines of context.  If not, we skip it.
    if ($patch =~ /\n@@ -(\d+),(\d+) \+(\d+),(\d+) @@\n( .*\n)*((\+.*\n)+)( .*\n)+$/m) {
        # Copy the header from the original patch.
        my $newPatch = substr($patch, 0, index($patch, "@@ -${1},${2} +${3},${4} @@"));

        # Generate a new set of line numbers and patch lengths.  Our new
        # patch will start with the lines for the fixed ChangeLog entry,
        # then have 3 lines of context from the top of the current file to
        # make the patch apply cleanly.
        $newPatch .= "@@ -1,3 +1," . ($4 - $2 + 3) . " @@\n";

        # We assume that top few lines of the ChangeLog entry are actually
        # at the bottom of the list of added lines (due to the way the patch
        # algorithm works), so we simply search through the lines until we
        # find the date line, then move the rest of the lines to the top.
        my @patchLines = map { $_ . "\n" } split(/\n/, $6);
        foreach my $i (0 .. $#patchLines) {
            if ($patchLines[$i] =~ /^\+\d{4}-\d{2}-\d{2}  /) {
                unshift(@patchLines, splice(@patchLines, $i, scalar(@patchLines) - $i));
                last;
            }
        }

        $newPatch .= join("", @patchLines);

        # Add 3 lines of context to the end
        open FILE, "<", $file || die;
        for (my $i = 0; $i < 3; $i++) {
            $newPatch .= " " . <FILE>;
        }
        close FILE;

        # Apply the new patch
        open(PATCH, "| patch -p1 $file > /dev/null") || die;
        print PATCH $newPatch;
        close(PATCH) || die;

        # Run "git add" on the fixed ChangeLog file
        system($GIT, "add", $file);

        showStatus($file, 1);
    } elsif ($patch) {
        # Restore the current copy of the ChangeLog file since we can't repatch it
        system($GIT, "checkout", $ENV{GIT_COMMIT} || "HEAD", $file);
        print STDERR "WARNING: Last change to ${file} could not be fixed and re-merged.\n" if $printWarnings;
    }
}

sub mergeChanges($$$)
{
    my ($fileMine, $fileOlder, $fileNewer) = @_;

    my $traditionalReject = $fileMine =~ /\.rej$/ ? 1 : 0;

    local $/ = undef;

    my $patch;
    if ($traditionalReject) {
        open(DIFF, "<", $fileMine);
        $patch = <DIFF>;
        close(DIFF);
        rename($fileMine, "$fileMine.save");
        rename($fileOlder, "$fileOlder.save");
    } else {
        open(DIFF, "-|", qw(diff -u), $fileOlder, $fileMine) || die;
        $patch = <DIFF>;
        close(DIFF);
    }

    unlink("${fileNewer}.orig");
    unlink("${fileNewer}.rej");

    open(PATCH, "| patch --fuzz=3 $fileNewer > /dev/null") || die;
    print PATCH fixChangeLogPatch($patch);
    close(PATCH);

    my $result;

    # Refuse to merge the patch if it did not apply cleanly
    if (-e "${fileNewer}.rej") {
        unlink("${fileNewer}.rej");
        unlink($fileNewer);
        rename("${fileNewer}.orig", $fileNewer);
        $result = 0;
    } else {
        unlink("${fileNewer}.orig");
        $result = 1;
    }

    if ($traditionalReject) {
        rename("$fileMine.save", $fileMine);
        rename("$fileOlder.save", $fileOlder);
    }

    return $result;
}

sub parseFixMerged($$;$)
{
    my ($switchName, $key, $value) = @_;
    if (defined $key) {
        if (defined findChangeLog($key)) {
            unshift(@ARGV, $key);
            $fixMerged = "";
        } else {
            $fixMerged = $key;
        }
    } else {
        $fixMerged = "";
    }
}

sub removeChangeLogArguments()
{
    my @results = ();

    for (my $i = 0; $i < scalar(@ARGV); ) {
        my $file = findChangeLog($ARGV[$i]);
        if (defined $file) {
            splice(@ARGV, $i, 1);
            push @results, $file;
        } else {
            $i++;
        }
    }

    return @results;
}

sub resolveChangeLog($)
{
    my ($file) = @_;

    my ($fileMine, $fileOlder, $fileNewer) = conflictFiles($file);

    return unless $fileMine && $fileOlder && $fileNewer;

    if (mergeChanges($fileMine, $fileOlder, $fileNewer)) {
        if ($file ne $fileNewer) {
            unlink($file);
            rename($fileNewer, $file) || die;
        }
        unlink($fileMine, $fileOlder);
        resolveConflict($file);
        showStatus($file, 1);
    } else {
        showStatus($file);
        print STDERR "WARNING: ${file} could not be merged using fuzz level 3.\n" if $printWarnings;
        unlink($fileMine, $fileOlder, $fileNewer) if isGit();
    }
}

sub resolveConflict($)
{
    my ($file) = @_;

    if (isSVN()) {
        system($SVN, "resolved", $file);
    } elsif (isGit()) {
        system($GIT, "add", $file);
    } else {
        die "Unknown version control system";
    }
}

sub showStatus($;$)
{
    my ($file, $isConflictResolved) = @_;

    if (isSVN()) {
        system($SVN, "status", $file);
    } elsif (isGit()) {
        my @args = qw(--name-status);
        unshift @args, qw(--cached) if $isConflictResolved;
        system($GIT, "diff", @args, $file);
    } else {
        die "Unknown version control system";
    }
}
