# 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, '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, '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, '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, '_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(dirstate.dirstate, 'running_status')

@contextlib.contextmanager

def running_status(orig, self, repo):

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

            if sub_dirstate is None:

                yield

            else:

                with sub_dirstate.running_status(repo):

                    yield

    finally:

        self._sub_dirstate = pre

@eh.wrapfunction(subrepo.hgsubrepo, '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, 'dirty')

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