"""

dirstate.py - working directory tracking for mercurial

Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

This software may be used and distributed according to the terms

of the GNU General Public License, incorporated herein by reference.

"""

from node import *

from i18n import _

import struct, os, time, bisect, stat, strutil, util, re, errno, ignore

import cStringIO, osutil

_unknown = ('?', 0, 0, 0)

_format = ">cllll"

class dirstate(object):

    def __init__(self, opener, ui, root):

        self._opener = opener

        self._root = root

        self._dirty = False

        self._dirtypl = False

        self._ui = ui

    def __getattr__(self, name):

        if name == '_map':

            self._read()

            return self._map

        elif name == '_copymap':

            self._read()

            return self._copymap

        elif name == '_branch':

            try:

                self._branch = (self._opener("branch").read().strip()

                                or "default")

            except IOError:

                self._branch = "default"

            return self._branch

        elif name == '_pl':

            self._pl = [nullid, nullid]

            try:

                st = self._opener("dirstate").read(40)

                if len(st) == 40:

                    self._pl = st[:20], st[20:40]

            except IOError, err:

                if err.errno != errno.ENOENT: raise

            return self._pl

        elif name == '_dirs':

            self._dirs = {}

            for f in self._map:

            return self._dirs

        elif name == '_ignore':

            files = [self._join('.hgignore')]

            for name, path in self._ui.configitems("ui"):

                if name == 'ignore' or name.startswith('ignore.'):

                    files.append(os.path.expanduser(path))

            self._ignore = ignore.ignore(self._root, files, self._ui.warn)

            return self._ignore

        elif name == '_slash':

            self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/'

            return self._slash

        else:

            raise AttributeError, name

    def _join(self, f):

        return os.path.join(self._root, f)

    def getcwd(self):

        cwd = os.getcwd()

        if cwd == self._root: return ''

        # self._root ends with a path separator if self._root is '/' or 'C:\'

        rootsep = self._root

        if not rootsep.endswith(os.sep):

            rootsep += os.sep

        if cwd.startswith(rootsep):

            return cwd[len(rootsep):]

        else:

            # we're outside the repo. return an absolute path.

            return cwd

    def pathto(self, f, cwd=None):

        if cwd is None:

            cwd = self.getcwd()

        path = util.pathto(self._root, cwd, f)

        if self._slash:

            return path.replace(os.sep, '/')

        return path

    def __getitem__(self, key):

        ''' current states:

        n  normal

        m  needs merging

        r  marked for removal

        a  marked for addition

        ?  not tracked'''

        return self._map.get(key, ("?",))[0]

    def __contains__(self, key):

        return key in self._map

    def __iter__(self):

        a = self._map.keys()

        a.sort()

        for x in a:

            yield x

    def parents(self):

        return self._pl

    def branch(self):

        return self._branch

    def setparents(self, p1, p2=nullid):

        self._dirty = self._dirtypl = True

        self._pl = p1, p2

    def setbranch(self, branch):

        self._branch = branch

        self._opener("branch", "w").write(branch + '\n')

    def _read(self):

        self._map = {}

        self._copymap = {}

        if not self._dirtypl:

            self._pl = [nullid, nullid]

        try:

            st = self._opener("dirstate").read()

        except IOError, err:

            if err.errno != errno.ENOENT: raise

            return

        if not st:

            return

        if not self._dirtypl:

            self._pl = [st[:20], st[20: 40]]

        # deref fields so they will be local in loop

        dmap = self._map

        copymap = self._copymap

        unpack = struct.unpack

        e_size = struct.calcsize(_format)

        pos1 = 40

        l = len(st)

        # the inner loop

        while pos1 < l:

            pos2 = pos1 + e_size

            e = unpack(">cllll", st[pos1:pos2]) # a literal here is faster

            pos1 = pos2 + e[4]

            f = st[pos2:pos1]

            if '\0' in f:

                f, c = f.split('\0')

                copymap[f] = c

            dmap[f] = e # we hold onto e[4] because making a subtuple is slow

    def invalidate(self):

        for a in "_map _copymap _branch _pl _dirs _ignore".split():

            if a in self.__dict__:

                delattr(self, a)

        self._dirty = False

    def copy(self, source, dest):

        self._dirty = True

        self._copymap[dest] = source

    def copied(self, file):

        return self._copymap.get(file, None)

    def copies(self):

        return self._copymap

    def _incpath(self, path):

        c = path.rfind('/')

        if c >= 0:

            dirs = self._dirs

            base = path[:c]

            if base not in dirs:

                self._incpath(base)

                dirs[base] = 1

            else:

                dirs[base] += 1

    def _decpath(self, path):

        if "_dirs" in self.__dict__:

            c = path.rfind('/')

            if c >= 0:

                base = path[:c]

                dirs = self._dirs

                if dirs[base] == 1:

                    del dirs[base]

                    self._decpath(base)

                else:

                    dirs[base] -= 1

    def _incpathcheck(self, f):

        if '\r' in f or '\n' in f:

            raise util.Abort(_("'\\n' and '\\r' disallowed in filenames"))

        # shadows

        if f in self._dirs:

            raise util.Abort(_('directory %r already in dirstate') % f)

        for c in strutil.rfindall(f, '/'):

            d = f[:c]

            if d in self._dirs:

                break

                raise util.Abort(_('file %r in dirstate clashes with %r') %

                                 (d, f))

        self._incpath(f)

    def normal(self, f):

        'mark a file normal and clean'

        self._dirty = True

        s = os.lstat(self._join(f))

        self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0)

        if self._copymap.has_key(f):

            del self._copymap[f]

    def normallookup(self, f):

        'mark a file normal, but possibly dirty'

        self._dirty = True

        self._map[f] = ('n', 0, -1, -1, 0)

        if f in self._copymap:

            del self._copymap[f]

    def normaldirty(self, f):

        'mark a file normal, but dirty'

        self._dirty = True

        self._map[f] = ('n', 0, -2, -1, 0)

        if f in self._copymap:

            del self._copymap[f]

    def add(self, f):

        'mark a file added'

        self._dirty = True

        self._map[f] = ('a', 0, -1, -1, 0)

        if f in self._copymap:

            del self._copymap[f]

    def remove(self, f):

        'mark a file removed'

        self._dirty = True

        self._map[f] = ('r', 0, 0, 0, 0)

        if f in self._copymap:

            del self._copymap[f]

    def merge(self, f):

        'mark a file merged'

        self._dirty = True

        s = os.lstat(self._join(f))

        self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0)

        if f in self._copymap:

            del self._copymap[f]

    def forget(self, f):

        'forget a file'

        self._dirty = True

        try:

            del self._map[f]

        except KeyError:

            self._ui.warn(_("not in dirstate: %s!\n") % f)

    def clear(self):

        self._map = {}

        self._copymap = {}

        self._pl = [nullid, nullid]

        self._dirty = True

    def rebuild(self, parent, files):

        self.clear()

        for f in files:

            if files.execf(f):

                self._map[f] = ('n', 0777, -1, 0, 0)

            else:

                self._map[f] = ('n', 0666, -1, 0, 0)

        self._pl = (parent, nullid)

        self._dirty = True

    def write(self):

        if not self._dirty:

            return

        cs = cStringIO.StringIO()

        copymap = self._copymap

        pack = struct.pack

        write = cs.write

        write("".join(self._pl))

        for f, e in self._map.iteritems():

            if f in copymap:

                f = "%s\0%s" % (f, copymap[f])

            e = pack(_format, e[0], e[1], e[2], e[3], len(f))

            write(e)

            write(f)

        st = self._opener("dirstate", "w", atomictemp=True)

        st.write(cs.getvalue())

        st.rename()

        self._dirty = self._dirtypl = False

    def _filter(self, files):

        ret = {}

        unknown = []

        for x in files:

            if x == '.':

                return self._map.copy()

            if x not in self._map:

                unknown.append(x)

            else:

                ret[x] = self._map[x]

        if not unknown:

            return ret

        b = self._map.keys()

        b.sort()

        blen = len(b)

        for x in unknown:

            bs = bisect.bisect(b, "%s%s" % (x, '/'))

            while bs < blen:

                s = b[bs]

                if len(s) > len(x) and s.startswith(x):

                    ret[s] = self._map[s]

                else:

                    break

                bs += 1

        return ret

    def _supported(self, f, mode, verbose=False):

        if stat.S_ISREG(mode) or stat.S_ISLNK(mode):

            return True

        if verbose:

            kind = 'unknown'