# Copyright 2009-2010 Gregory P. Ward

# Copyright 2009-2010 Intelerad Medical Systems Incorporated

# Copyright 2010-2011 Fog Creek Software

# Copyright 2010-2011 Unity Technologies

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''Overridden Mercurial commands and functions for the largefiles extension'''

import os

import copy

from mercurial import hg, commands, util, cmdutil, scmutil, match as match_, \

    node, archival, error, merge

from mercurial.i18n import _

from mercurial.node import hex

from hgext import rebase

import lfutil

import lfcommands

def installnormalfilesmatchfn(manifest):

    '''overrides scmutil.match so that the matcher it returns will ignore all

    largefiles'''

    oldmatch = None # for the closure

    def override_match(ctx, pats=[], opts={}, globbed=False,

            default='relpath'):

        match = oldmatch(ctx, pats, opts, globbed, default)

        m = copy.copy(match)

        notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in

                manifest)

        m._files = filter(notlfile, m._files)

        m._fmap = set(m._files)

        orig_matchfn = m.matchfn

        m.matchfn = lambda f: notlfile(f) and orig_matchfn(f) or None

        return m

    oldmatch = installmatchfn(override_match)

def installmatchfn(f):

    oldmatch = scmutil.match

    setattr(f, 'oldmatch', oldmatch)

    scmutil.match = f

    return oldmatch

def restorematchfn():

    '''restores scmutil.match to what it was before installnormalfilesmatchfn

    was called.  no-op if scmutil.match is its original function.

    Note that n calls to installnormalfilesmatchfn will require n calls to

    restore matchfn to reverse'''

    scmutil.match = getattr(scmutil.match, 'oldmatch', scmutil.match)

    large = opts.pop('large', None)

    lfsize = lfutil.getminsize(

        ui, lfutil.islfilesrepo(repo), opts.pop('lfsize', None))

    lfmatcher = None

    if lfutil.islfilesrepo(repo):

        lfpats = ui.configlist(lfutil.longname, 'patterns', default=[])

        if lfpats:

            lfmatcher = match_.match(repo.root, '', list(lfpats))

    lfnames = []

    m = scmutil.match(repo[None], pats, opts)

    m.bad = lambda x, y: None

    wctx = repo[None]

    for f in repo.walk(m):

        exact = m.exact(f)

        lfile = lfutil.standin(f) in wctx

        nfile = f in wctx

        exists = lfile or nfile

        # Don't warn the user when they attempt to add a normal tracked file.

        # The normal add code will do that for us.

        if exact and exists:

            if lfile:

                ui.warn(_('%s already a largefile\n') % f)

            continue

        if exact or not exists:

            abovemin = (lfsize and

                        os.lstat(repo.wjoin(f)).st_size >= lfsize * 1024 * 1024)

            if large or abovemin or (lfmatcher and lfmatcher(f)):

                lfnames.append(f)

                if ui.verbose or not exact:

                    ui.status(_('adding %s as a largefile\n') % m.rel(f))

    bad = []

    standins = []

    # Need to lock, otherwise there could be a race condition between

    # when standins are created and added to the repo.

    wlock = repo.wlock()

    try:

        if not opts.get('dry_run'):

            lfdirstate = lfutil.openlfdirstate(ui, repo)

            for f in lfnames:

                standinname = lfutil.standin(f)

                lfutil.writestandin(repo, standinname, hash='',

                    executable=lfutil.getexecutable(repo.wjoin(f)))

                standins.append(standinname)

                if lfdirstate[f] == 'r':

                    lfdirstate.normallookup(f)

                else:

                    lfdirstate.add(f)

            lfdirstate.write()

            bad += [lfutil.splitstandin(f)

                    for f in lfutil.repo_add(repo, standins)

                    if f in m.files()]

    finally:

        wlock.release()

    after = opts.get('after')

    if not pats and not after:

        raise util.Abort(_('no files specified'))

    m = scmutil.match(repo[None], pats, opts)

    try:

        repo.lfstatus = True

        s = repo.status(match=m, clean=True)

    finally:

        repo.lfstatus = False

    modified, added, deleted, clean = [[f for f in list

                                        if lfutil.standin(f) in manifest]

                                       for list in [s[0], s[1], s[3], s[6]]]

    def warn(files, reason):

        for f in files:

            ui.warn(_('not removing %s: %s (use forget to undo)\n')

                    % (m.rel(f), reason))

    if after:

        remove, forget = deleted, []

        warn(modified + added + clean, _('file still exists'))

    else:

        remove, forget = deleted + clean, []

        warn(modified, _('file is modified'))

        warn(added, _('file has been marked for add'))

    for f in sorted(remove + forget):

        if ui.verbose or not m.exact(f):

            ui.status(_('removing %s\n') % m.rel(f))

    # Need to lock because standin files are deleted then removed from the

    # repository and we could race inbetween.

    wlock = repo.wlock()

    try:

        lfdirstate = lfutil.openlfdirstate(ui, repo)

        for f in remove:

            if not after:

                currentdir = os.path.split(f)[0]

                while currentdir and not os.listdir(repo.wjoin(currentdir)):

                    os.rmdir(repo.wjoin(currentdir))

                    currentdir = os.path.split(currentdir)[0]

            lfdirstate.remove(f)

        lfdirstate.write()

        forget = [lfutil.standin(f) for f in forget]

        remove = [lfutil.standin(f) for f in remove]

        lfutil.repo_forget(repo, forget)

    finally:

        wlock.release()

def override_status(orig, ui, repo, *pats, **opts):

    try:

        repo.lfstatus = True

        return orig(ui, repo, *pats, **opts)

    finally:

        repo.lfstatus = False

def override_log(orig, ui, repo, *pats, **opts):

    try:

        repo.lfstatus = True

        orig(ui, repo, *pats, **opts)

    finally:

        repo.lfstatus = False

def override_verify(orig, ui, repo, *pats, **opts):

    large = opts.pop('large', False)

    all = opts.pop('lfa', False)

    contents = opts.pop('lfc', False)

    result = orig(ui, repo, *pats, **opts)

    if large:

        result = result or lfcommands.verifylfiles(ui, repo, all, contents)

    return result

# Override needs to refresh standins so that update's normal merge

# will go through properly. Then the other update hook (overriding repo.update)

# will get the new files. Filemerge is also overriden so that the merge

# will merge standins correctly.

def override_update(orig, ui, repo, *pats, **opts):

    lfdirstate = lfutil.openlfdirstate(ui, repo)

    s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False,

        False, False)

    (unsure, modified, added, removed, missing, unknown, ignored, clean) = s

    # Need to lock between the standins getting updated and their

    # largefiles getting updated

    wlock = repo.wlock()

    try:

        if opts['check']:

            mod = len(modified) > 0

            for lfile in unsure:

                standin = lfutil.standin(lfile)

                if repo['.'][standin].data().strip() != \

                        lfutil.hashfile(repo.wjoin(lfile)):

                    mod = True

                else:

                    lfdirstate.normal(lfile)

            lfdirstate.write()

            if mod:

                raise util.Abort(_('uncommitted local changes'))

        # XXX handle removed differently

        if not opts['clean']:

            for lfile in unsure + modified + added:

                lfutil.updatestandin(repo, lfutil.standin(lfile))

    finally:

        wlock.release()

    return orig(ui, repo, *pats, **opts)

# Before starting the manifest merge, merge.updates will call

# _checkunknown to check if there are any files in the merged-in

# changeset that collide with unknown files in the working copy.

#

# The largefiles are seen as unknown, so this prevents us from merging

# in a file 'foo' if we already have a largefile with the same name.

#

# The overridden function filters the unknown files by removing any

# largefiles. This makes the merge proceed and we can then handle this

# case further in the overridden manifestmerge function below.

def override_checkunknown(origfn, wctx, mctx, folding):

    origunknown = wctx.unknown()

    wctx._unknown = filter(lambda f: lfutil.standin(f) not in wctx, origunknown)

    try:

        return origfn(wctx, mctx, folding)

    finally:

        wctx._unknown = origunknown

# The manifest merge handles conflicts on the manifest level. We want

# to handle changes in largefile-ness of files at this level too.

#

# The strategy is to run the original manifestmerge and then process

# the action list it outputs. There are two cases we need to deal with:

#

# 1. Normal file in p1, largefile in p2. Here the largefile is

#    detected via its standin file, which will enter the working copy

#    with a "get" action. It is not "merge" since the standin is all

#    Mercurial is concerned with at this level -- the link to the

#    existing normal file is not relevant here.

#

# 2. Largefile in p1, normal file in p2. Here we get a "merge" action

#    since the largefile will be present in the working copy and

#    different from the normal file in p2. Mercurial therefore

#    triggers a merge action.

#

# In both cases, we prompt the user and emit new actions to either

# remove the standin (if the normal file was kept) or to remove the

# normal file and get the standin (if the largefile was kept). The

# default prompt answer is to use the largefile version since it was

# presumably changed on purpose.

#

# Finally, the merge.applyupdates function will then take care of

# writing the files into the working copy and lfcommands.updatelfiles

# will update the largefiles.

def override_manifestmerge(origfn, repo, p1, p2, pa, overwrite, partial):

    actions = origfn(repo, p1, p2, pa, overwrite, partial)

    processed = []

    for action in actions:

        if overwrite:

            processed.append(action)

            continue

        f, m = action[:2]

        choices = (_('&Largefile'), _('&Normal file'))

        if m == "g" and lfutil.splitstandin(f) in p1 and f in p2:

            # Case 1: normal file in the working copy, largefile in

            # the second parent

            lfile = lfutil.splitstandin(f)

            standin = f

            msg = _('%s has been turned into a largefile\n'

                    'use (l)argefile or keep as (n)ormal file?') % lfile

            if repo.ui.promptchoice(msg, choices, 0) == 0:

                processed.append((lfile, "r"))

                processed.append((standin, "g", p2.flags(standin)))

            else:

                processed.append((standin, "r"))

        elif m == "m" and lfutil.standin(f) in p1 and f in p2:

            # Case 2: largefile in the working copy, normal file in

            # the second parent

            standin = lfutil.standin(f)

            lfile = f

            msg = _('%s has been turned into a normal file\n'

                    'keep as (l)argefile or use (n)ormal file?') % lfile

            if repo.ui.promptchoice(msg, choices, 0) == 0:

                processed.append((lfile, "r"))

            else:

                processed.append((standin, "r"))

                processed.append((lfile, "g", p2.flags(lfile)))

        else:

            processed.append(action)

    return processed

# Override filemerge to prompt the user about how they wish to merge

# largefiles. This will handle identical edits, and copy/rename +

# edit without prompting the user.

def override_filemerge(origfn, repo, mynode, orig, fcd, fco, fca):

    # Use better variable names here. Because this is a wrapper we cannot

    # change the variable names in the function declaration.

    fcdest, fcother, fcancestor = fcd, fco, fca

    if not lfutil.isstandin(orig):

        return origfn(repo, mynode, orig, fcdest, fcother, fcancestor)

    else:

        if not fcother.cmp(fcdest): # files identical?

            return None

        # backwards, use working dir parent as ancestor

        if fcancestor == fcother:

            fcancestor = fcdest.parents()[0]

        if orig != fcother.path():

            repo.ui.status(_('merging %s and %s to %s\n')

                           % (lfutil.splitstandin(orig),

                              lfutil.splitstandin(fcother.path()),

                              lfutil.splitstandin(fcdest.path())))

        else:

            repo.ui.status(_('merging %s\n')

                           % lfutil.splitstandin(fcdest.path()))

        if fcancestor.path() != fcother.path() and fcother.data() == \

                fcancestor.data():

            return 0

        if fcancestor.path() != fcdest.path() and fcdest.data() == \

                fcancestor.data():

            repo.wwrite(fcdest.path(), fcother.data(), fcother.flags())