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

import copy

import os

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial.hgweb import webcommands

from mercurial import (

    archival,

    cmdutil,

    copies as copiesmod,

    dirstate,

    error,

    exchange,

    extensions,

    exthelper,

    filemerge,

    hg,

    logcmdutil,

    match as matchmod,

    merge,

    mergestate as mergestatemod,

    pathutil,

    pycompat,

    scmutil,

    smartset,

    subrepo,

    url as urlmod,

    util,

)

from mercurial.upgrade_utils import (

    actions as upgrade_actions,

)

from . import (

    lfcommands,

    lfutil,

    storefactory,

)

ACTION_ADD = mergestatemod.ACTION_ADD

ACTION_DELETED_CHANGED = mergestatemod.ACTION_DELETED_CHANGED

ACTION_GET = mergestatemod.ACTION_GET

ACTION_KEEP = mergestatemod.ACTION_KEEP

ACTION_REMOVE = mergestatemod.ACTION_REMOVE

eh = exthelper.exthelper()

lfstatus = lfutil.lfstatus

MERGE_ACTION_LARGEFILE_MARK_REMOVED = mergestatemod.MergeAction('lfmr')

# -- 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 = [lf for lf in m._files if lfile(lf)]

    m._fileset = set(m._files)

    m.always = lambda: False

    origmatchfn = m.matchfn

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

    return m

def composenormalfilematcher(match, manifest, exclude=None):

    excluded = set()

    if exclude is not None:

        excluded.update(exclude)

    m = copy.copy(match)

    notlfile = lambda f: not (

        lfutil.isstandin(f) or lfutil.standin(f) in manifest or f in excluded

    )

    m._files = [lf for lf in m._files if notlfile(lf)]

    m._fileset = set(m._files)

    m.always = lambda: False

    origmatchfn = m.matchfn

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

    return m

def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):

    large = opts.get('large')

    lfsize = lfutil.getminsize(

        ui, lfutil.islfilesrepo(repo), opts.get('lfsize')

    )

    lfmatcher = None

    if lfutil.islfilesrepo(repo):

        lfpats = ui.configlist(lfutil.longname, b'patterns')

        if lfpats:

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

    lfnames = []

    m = matcher

    wctx = repo[None]

    for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)):

        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(_(b'%s already a largefile\n') % uipathfn(f))

            continue

        if (exact or not exists) and not lfutil.isstandin(f):

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

            # (issue3507)

            if not repo.wvfs.exists(f):

                continue

            abovemin = (

                lfsize and repo.wvfs.lstat(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(_(b'adding %s as a largefile\n') % uipathfn(f))

    bad = []

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

    # when standins are created and added to the repo.

    with repo.wlock():

        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=b'',

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

                )

                standins.append(standinname)

                lfdirstate.set_tracked(f)

            lfdirstate.write(repo.currenttransaction())

            bad += [

                lfutil.splitstandin(f)

                for f in repo[None].add(standins)

                if f in m.files()

            ]

        added = [f for f in lfnames if f not in bad]

    return added, bad

def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts):

    after = opts.get('after')

    m = composelargefilematcher(matcher, repo[None].manifest())

    with lfstatus(repo):

        s = repo.status(match=m, clean=not isaddremove)

    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 % uipathfn(f))

        return int(len(files) > 0)

    if after:

        remove = deleted

        result = warn(

            modified + added + clean, _(b'not removing %s: file still exists\n')

        )

    else:

        remove = deleted + clean

        result = warn(

            modified,

            _(

                b'not removing %s: file is modified (use -f'

                b' to force removal)\n'

            ),

        )

        result = (

            warn(

                added,

                _(

                    b'not removing %s: file has been marked for add'

                    b' (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.

    with repo.wlock():

        lfdirstate = lfutil.openlfdirstate(ui, repo)

        for f in sorted(remove):

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

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

            if not dryrun:

                if not after:

                    repo.wvfs.unlinkpath(f, ignoremissing=True)

        if dryrun:

            return result

        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:

                repo.wvfs.unlinkpath(f, ignoremissing=True)

        repo[None].forget(remove)

        for f in remove:

            lfdirstate.set_untracked(lfutil.splitstandin(f))

        lfdirstate.write(repo.currenttransaction())

    return result

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

# appear at their right place in the manifests.

@eh.wrapfunction(webcommands, b'decodepath')

def decodepath(orig, path):

    return lfutil.splitstandin(path) or path

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

@eh.wrapcommand(

    b'add',

    opts=[

        (b'', b'large', None, _(b'add as largefile')),

        (b'', b'normal', None, _(b'add as normal file')),

        (

            b'',

            b'lfsize',

            b'',

            _(

                b'add all files above this size (in megabytes) '

                b'as largefiles (default: 10)'

            ),

        ),

    ],

)

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

    if opts.get('normal') and opts.get('large'):

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

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

@eh.wrapfunction(cmdutil, b'add')

def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts):

    # The --normal flag short circuits this override

    if opts.get('normal'):

        return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)

    ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)

    normalmatcher = composenormalfilematcher(

        matcher, repo[None].manifest(), ladded

    )

    bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts)

    bad.extend(f for f in lbad)

    return bad

@eh.wrapfunction(cmdutil, b'remove')

def cmdutilremove(

    orig, ui, repo, matcher, prefix, uipathfn, after, force, subrepos, dryrun

):

    normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())

    result = orig(

        ui,

        repo,

        normalmatcher,

        prefix,

        uipathfn,

        after,

        force,

        subrepos,

        dryrun,

    )

    return (

        removelargefiles(

            ui, repo, False, matcher, uipathfn, dryrun, after=after, force=force

        )

        or result

    )

@eh.wrapfunction(dirstate.dirstate, b'_changing')

@contextlib.contextmanager

def _changing(orig, self, repo, change_type):

    pre = sub_dirstate = getattr(self, '_sub_dirstate', None)

    try:

        lfd = getattr(self, '_large_file_dirstate', False)

        if sub_dirstate is None and not lfd:

            sub_dirstate = lfutil.openlfdirstate(repo.ui, repo)

            self._sub_dirstate = sub_dirstate

        if not lfd:

            assert self._sub_dirstate is not None

        with orig(self, repo, change_type):

            if sub_dirstate is None:

                yield

            else:

                with sub_dirstate._changing(repo, change_type):

                    yield

    finally:

        self._sub_dirstate = pre

@eh.wrapfunction(subrepo.hgsubrepo, b'status')

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

    with lfstatus(repo._repo):

        return orig(repo, rev2, **opts)

@eh.wrapcommand(b'status')

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

    with lfstatus(repo):

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

@eh.wrapfunction(subrepo.hgsubrepo, b'dirty')

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

    with lfstatus(repo._repo):

        return orig(repo, ignoreupdate=ignoreupdate, missing=missing)

@eh.wrapcommand(b'log')

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

    def overridematchandpats(

        orig,

        ctx,

        pats=(),

        opts=None,

        globbed=False,

        default=b'relpath',

        badfn=None,

    ):

        """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.

        """

        if opts is None:

            opts = {}

        matchandpats = orig(ctx, pats, opts, globbed, default, badfn=badfn)