# 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, match as match_, node, \

        archival, error, merge

from mercurial.i18n import _

from mercurial.node import hex

from hgext import rebase

import lfutil

try:

    from mercurial import scmutil

except ImportError:

    pass

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(repo, pats=[], opts={}, globbed=False,

            default='relpath'):

        match = oldmatch(repo, 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)

# -- 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 override_add(orig, ui, repo, *pats, **opts):

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

    lfsize = lfutil.getminsize(

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

    lfmatcher = None

    if os.path.exists(repo.wjoin(lfutil.shortname)):

        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:

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

    finally:

        wlock.release()

    installnormalfilesmatchfn(repo[None].manifest())

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

    restorematchfn()

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

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

    manifest = repo[None].manifest()

    installnormalfilesmatchfn(manifest)

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

    restorematchfn()

    after, force = opts.get('after'), opts.get('force')

    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

    def warn(files, reason):

        for f in files:

            ui.warn(_('not removing %s: file %s (use -f to force removal)\n')

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

    if force:

        remove, forget = modified + deleted + clean, added

    elif after:

        remove, forget = deleted, []

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

    else:

        remove, forget = deleted + clean, []

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

        warn(added, _('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:

                os.unlink(repo.wjoin(f))

                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)

        lfutil.repo_remove(repo, remove, unlink=True)

    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)

# 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())

            return 0

        if repo.ui.promptchoice(_('largefile %s has a merge conflict\n'

                             'keep (l)ocal or take (o)ther?') %

                             lfutil.splitstandin(orig),

                             (_('&Local'), _('&Other')), 0) == 0:

            return 0

        else:

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

            return 0

# Copy first changes the matchers to match standins instead of

# largefiles.  Then it overrides util.copyfile in that function it

# checks if the destination largefile already exists. It also keeps a

# list of copied files so that the largefiles can be copied and the

# dirstate updated.

def override_copy(orig, ui, repo, pats, opts, rename=False):

    # doesn't remove largefile on rename

    if len(pats) < 2:

        # this isn't legal, let the original function deal with it

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

    def makestandin(relpath):

        path = scmutil.canonpath(repo.root, repo.getcwd(), relpath)

        return os.path.join(os.path.relpath('.', repo.getcwd()),

            lfutil.standin(path))

    fullpats = scmutil.expandpats(pats)

    dest = fullpats[-1]

    if os.path.isdir(dest):

        if not os.path.isdir(makestandin(dest)):

            os.makedirs(makestandin(dest))

    # This could copy both lfiles and normal files in one command,

    # but we don't want to do that. First replace their matcher to

    # only match normal files and run it, then replace it to just

    # match largefiles and run it again.

    nonormalfiles = False

    nolfiles = False

    try:

        installnormalfilesmatchfn(repo[None].manifest())

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

    except util.Abort, e:

        if str(e) != 'no files to copy':

            raise e

        else:

            nonormalfiles = True

        result = 0

    finally:

        restorematchfn()

    # The first rename can cause our current working directory to be removed.

    # In that case there is nothing left to copy/rename so just quit.

    try:

        repo.getcwd()

    except OSError:

        return result

    try:

        # When we call orig below it creates the standins but we don't add them

        # to the dir state until later so lock during that time.

        wlock = repo.wlock()

        manifest = repo[None].manifest()

        oldmatch = None # for the closure

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

                default='relpath'):

            newpats = []

            # The patterns were previously mangled to add the standin

            # directory; we need to remove that now

            for pat in pats:

                if match_.patkind(pat) is None and lfutil.shortname in pat:

                    newpats.append(pat.replace(lfutil.shortname, ''))

                else:

                    newpats.append(pat)

            match = oldmatch(repo, newpats, opts, globbed, default)

            m = copy.copy(match)

            lfile = lambda f: lfutil.standin(f) in manifest

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

            m._fmap = set(m._files)

            orig_matchfn = m.matchfn

            return m

        oldmatch = installmatchfn(override_match)

        listpats = []

        for pat in pats:

            if match_.patkind(pat) is not None:

                listpats.append(pat)

            else:

                listpats.append(makestandin(pat))