# 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, util, cmdutil, scmutil, match as match_, \

        archival, pathutil, revset

from mercurial.i18n import _

from mercurial.node import hex

import lfutil

import lfcommands

import basestore

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

def composelargefilematcher(match, manifest):

    '''create a matcher that matches only the largefiles in the original

    matcher'''

    m = copy.copy(match)

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

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

    m._fmap = set(m._files)

    m._always = False

    origmatchfn = m.matchfn

    m.matchfn = lambda f: lfile(f) and origmatchfn(f)

    return m

def composenormalfilematcher(match, manifest):

    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)

    return m

def installnormalfilesmatchfn(manifest):

    '''installmatchfn with a matchfn that ignores all largefiles'''

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

            default='relpath'):

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

        return composenormalfilematcher(match, manifest)

    oldmatch = installmatchfn(overridematch)

def installmatchfn(f):

    '''monkey patch the scmutil module with a custom match function.

    Warning: it is monkey patching the _module_ on runtime! Not thread safe!'''

    oldmatch = scmutil.match

    setattr(f, 'oldmatch', oldmatch)

    scmutil.match = f

    return oldmatch

def restorematchfn():

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

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

    Note that n calls to installmatchfn will require n calls to

    restore the original matchfn.'''

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

def installmatchandpatsfn(f):

    oldmatchandpats = scmutil.matchandpats

    setattr(f, 'oldmatchandpats', oldmatchandpats)

    scmutil.matchandpats = f

    return oldmatchandpats

def restorematchandpatsfn():

    '''restores scmutil.matchandpats to what it was before

    installmatchandpatsfn was called. No-op if scmutil.matchandpats

    is its original function.

    Note that n calls to installmatchandpatsfn will require n calls

    to restore the original matchfn.'''

    scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats',

            scmutil.matchandpats)

def addlargefiles(ui, repo, matcher, **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 = copy.copy(matcher)

    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 = []

    # 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'):

            standins = []

            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, isaddremove, *pats, **opts):

    after = opts.get('after')

    if not pats and not after:

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

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

                                repo[None].manifest())

    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.modified, s.added,

                                                    s.deleted, s.clean)]

    def warn(files, msg):

        for f in files:

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

        return int(len(files) > 0)

    result = 0

    if after:

        remove = deleted

        result = warn(modified + added + clean,

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

    else:

        remove = 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

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

            if not opts.get('dry_run'):

                if not after:

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

                lfdirstate.remove(f)

        if opts.get('dry_run'):

            return result

        lfdirstate.write()

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

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

        # function handle this.

        if not isaddremove:

            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)

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

    bad = addlargefiles(ui, repo, matcher, **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, False, *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 overridematchandpats(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.

        """

        matchandpats = oldmatchandpats(ctx, pats, opts, globbed, default)

        m, p = copy.copy(matchandpats)

        if m.always():

            # We want to match everything anyway, so there's no benefit trying

            # to add standins.

            return matchandpats

        pats = set(p)

        # TODO: handling of patterns in both cases below

        if m._cwd:

            if os.path.isabs(m._cwd):

                # TODO: handle largefile magic when invoked from other cwd

                return matchandpats

            back = (m._cwd.count('/') + 1) * '../'

            pats.update(back + lfutil.standin(m._cwd + '/' + f) for f in p)

        else:

            pats.update(lfutil.standin(f) for f in p)

        for i in range(0, len(m._files)):

            standin = lfutil.standin(m._files[i])

            if standin in repo[ctx.node()]:

                m._files[i] = standin

            elif m._files[i] not in repo[ctx.node()]:

                m._files.append(standin)

            pats.add(standin)

        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, pats

    # For hg log --patch, the match object is used in two different senses:

    # (1) to determine what revisions should be printed out, and

    # (2) to determine what files to print out diffs for.

    # The magic matchandpats override should be used for case (1) but not for

    # case (2).

    def overridemakelogfilematcher(repo, pats, opts):

        pctx = repo[None]

        match, pats = oldmatchandpats(pctx, pats, opts)

        return lambda rev: match

    oldmatchandpats = installmatchandpatsfn(overridematchandpats)

    oldmakelogfilematcher = cmdutil._makenofollowlogfilematcher

    setattr(cmdutil, '_makenofollowlogfilematcher', overridemakelogfilematcher)

    try:

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

    finally:

        restorematchandpatsfn()

        setattr(cmdutil, '_makenofollowlogfilematcher', oldmakelogfilematcher)

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:

        class fakerepo(object):

            dirstate = lfutil.openlfdirstate(ui, repo)

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

    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.