# 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, discovery

from mercurial.i18n import _

from mercurial.node import hex

from hgext import rebase

import lfutil

import lfcommands

import basestore

# -- Utility functions: commonly/repeatedly needed functionality ---------------

def installnormalfilesmatchfn(manifest):

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

    largefiles'''

    oldmatch = None # for the closure

    def overridematch(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)

        m._always = False

        origmatchfn = m.matchfn

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

        return m

    oldmatch = installmatchfn(overridematch)

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)

def addlargefiles(ui, repo, *pats, **opts):

    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) and not lfutil.isstandin(f):

            wfile = repo.wjoin(f)

            # In case the file was removed previously, but not committed

            # (issue3507)

            if not os.path.exists(wfile):

                continue

            abovemin = (lfsize and

                        os.lstat(wfile).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 repo[None].add(standins)

                    if f in m.files()]

    finally:

        wlock.release()

    return bad

def removelargefiles(ui, repo, *pats, **opts):

    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

    manifest = repo[None].manifest()

    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, msg):

        for f in files:

            ui.warn(msg % m.rel(f))

        return int(len(files) > 0)

    result = 0

    if after:

        remove, forget = deleted, []

        result = warn(modified + added + clean,

                      _('not removing %s: file still exists\n'))

    else:

        remove, forget = deleted + clean, []

        result = warn(modified, _('not removing %s: file is modified (use -f'

                                  ' to force removal)\n'))

        result = warn(added, _('not removing %s: file has been marked for add'

                               ' (use forget to undo)\n')) or result

    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 in-between.

    wlock = repo.wlock()

    try:

        lfdirstate = lfutil.openlfdirstate(ui, repo)

        for f in remove:

            if not after:

                # If this is being called by addremove, notify the user that we

                # are removing the file.

                if getattr(repo, "_isaddremove", False):

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

                util.unlinkpath(repo.wjoin(f), ignoremissing=True)

            lfdirstate.remove(f)

        lfdirstate.write()

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

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

        repo[None].forget(forget)

        # If this is being called by addremove, let the original addremove

        # function handle this.

        if not getattr(repo, "_isaddremove", False):

            for f in remove:

                util.unlinkpath(repo.wjoin(f), ignoremissing=True)

        repo[None].forget(remove)

    finally:

        wlock.release()

    return result

# For overriding mercurial.hgweb.webcommands so that largefiles will

# appear at their right place in the manifests.

def decodepath(orig, path):

    return lfutil.splitstandin(path) or path

# -- Wrappers: modify existing commands --------------------------------

# Add works by going through the files that the user wanted to add and

# checking if they should be added as largefiles. Then it makes a new

# matcher which matches only the normal files and runs the original

# version of add.

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

    normal = opts.pop('normal')

    if normal:

        if opts.get('large'):

            raise util.Abort(_('--normal cannot be used with --large'))

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

    bad = addlargefiles(ui, repo, *pats, **opts)

    installnormalfilesmatchfn(repo[None].manifest())

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

    restorematchfn()

    return (result == 1 or bad) and 1 or 0

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

    installnormalfilesmatchfn(repo[None].manifest())

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

    restorematchfn()

    return removelargefiles(ui, repo, *pats, **opts) or result

def overridestatusfn(orig, repo, rev2, **opts):

    try:

        repo._repo.lfstatus = True

        return orig(repo, rev2, **opts)

    finally:

        repo._repo.lfstatus = False

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

    try:

        repo.lfstatus = True

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

    finally:

        repo.lfstatus = False

def overridedirty(orig, repo, ignoreupdate=False):

    try:

        repo._repo.lfstatus = True

        return orig(repo, ignoreupdate)

    finally:

        repo._repo.lfstatus = False

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

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

            default='relpath'):

        """Matcher that merges root directory with .hglf, suitable for log.

        It is still possible to match .hglf directly.

        For any listed files run log on the standin too.

        matchfn tries both the given filename and with .hglf stripped.

        """

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

        m = copy.copy(match)

        standins = [lfutil.standin(f) for f in m._files]

        m._files.extend(standins)

        m._fmap = set(m._files)

        m._always = False

        origmatchfn = m.matchfn

        def lfmatchfn(f):

            lf = lfutil.splitstandin(f)

            if lf is not None and origmatchfn(lf):

                return True

            r = origmatchfn(f)

            return r

        m.matchfn = lfmatchfn

        return m

    oldmatch = installmatchfn(overridematch)

    try:

        repo.lfstatus = True

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

    finally:

        repo.lfstatus = False

        restorematchfn()

def overrideverify(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 or all or contents:

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

    return result

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

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

    if large:

        lfcommands.debugdirstate(ui, repo)

    else:

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

# 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 overridden so that the merge

# will merge standins correctly.

def overrideupdate(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 overridecheckunknownfile(origfn, repo, wctx, mctx, f):

    if lfutil.standin(f) in wctx:

        return False

    return origfn(repo, wctx, mctx, f)

# 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 overridemanifestmerge(origfn, repo, p1, p2, pa, branchmerge, force,

                          partial, acceptremote=False):

    overwrite = force and not branchmerge

    actions = origfn(repo, p1, p2, pa, branchmerge, force, partial,

                     acceptremote)