"""

dirstate.py - working directory tracking for mercurial

Copyright 2005 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 demandload import *

demandload(globals(), "time bisect stat util")

class dirstate:

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

        self.opener = opener

        self.root = root

        self.dirty = 0

        self.ui = ui

        self.map = None

        self.pl = None

        self.copies = {}

        self.ignorefunc = None

    def wjoin(self, f):

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

    def getcwd(self):

        cwd = os.getcwd()

        if cwd == self.root: return ''

        return cwd[len(self.root) + 1:]

    def ignore(self, f):

        if not self.ignorefunc:

            bigpat = []

            try:

                l = file(self.wjoin(".hgignore"))

                for pat in l:

                    p = pat.rstrip()

                    if p:

                        try:

                            re.compile(p)

                        except:

                            self.ui.warn("ignoring invalid ignore"

                                         + " regular expression '%s'\n" % p)

                        else:

                            bigpat.append(p)

            except IOError: pass

            if bigpat:

                s = "(?:%s)" % (")|(?:".join(bigpat))

                r = re.compile(s)

                self.ignorefunc = r.search

            else:

                self.ignorefunc = util.never

        return self.ignorefunc(f)

    def __del__(self):

        if self.dirty:

            self.write()

    def __getitem__(self, key):

        try:

            return self.map[key]

        except TypeError:

            self.read()

            return self[key]

    def __contains__(self, key):

        if not self.map: self.read()

        return key in self.map

    def parents(self):

        if not self.pl:

            self.read()

        return self.pl

    def markdirty(self):

        if not self.dirty:

            self.dirty = 1

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

        self.markdirty()

        self.pl = p1, p2

    def state(self, key):

        try:

            return self[key][0]

        except KeyError:

            return "?"

    def read(self):

        if self.map is not None: return self.map

        self.map = {}

        self.pl = [nullid, nullid]

        try:

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

            if not st: return

        except: return

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

        pos = 40

        while pos < len(st):

            e = struct.unpack(">cllll", st[pos:pos+17])

            l = e[4]

            pos += 17

            f = st[pos:pos + l]

            if '\0' in f:

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

                self.copies[f] = c

            self.map[f] = e[:4]

            pos += l

    def copy(self, source, dest):

        self.read()

        self.markdirty()

        self.copies[dest] = source

    def copied(self, file):

        return self.copies.get(file, None)

    def update(self, files, state, **kw):

        ''' current states:

        n  normal

        m  needs merging

        r  marked for removal

        a  marked for addition'''

        if not files: return

        self.read()

        self.markdirty()

        for f in files:

            if state == "r":

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

            else:

                s = os.stat(os.path.join(self.root, f))

                st_size = kw.get('st_size', s.st_size)

                st_mtime = kw.get('st_mtime', s.st_mtime)

                self.map[f] = (state, s.st_mode, st_size, st_mtime)

    def forget(self, files):

        if not files: return

        self.read()

        self.markdirty()

        for f in files:

            try:

                del self.map[f]

            except KeyError:

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

                pass

    def clear(self):

        self.map = {}

        self.markdirty()

    def write(self):

        st = self.opener("dirstate", "w")

        st.write("".join(self.pl))

        for f, e in self.map.items():

            c = self.copied(f)

            if c:

                f = f + "\0" + c

            e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f))

            st.write(e + f)

        self.dirty = 0

    def filterfiles(self, files):

        ret = {}

        unknown = []

        for x in files:

            if x is '.':

                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, x)

            if bs != 0 and  b[bs-1] == x:

                ret[x] = self.map[x]

                continue

            while bs < blen:

                s = b[bs]

                if len(s) > len(x) and s.startswith(x) and s[len(x)] == '/':

                    ret[s] = self.map[s]

                else:

                    break

                bs += 1

        return ret

    def walk(self, files=None, match=util.always, dc=None):

        self.read()

        # walk all files by default

        if not files:

            files = [self.root]

            if not dc:

                dc = self.map.copy()

        elif not dc:

            dc = self.filterfiles(files)

        known = {'.hg': 1}

        def seen(fn):

            if fn in known: return True

            known[fn] = 1

        def traverse():

            for ff in util.unique(files):

                f = os.path.join(self.root, ff)

                try:

                    st = os.stat(f)

                except OSError, inst:

                    if ff not in dc: self.ui.warn('%s: %s\n' % (

                        util.pathto(self.getcwd(), ff),

                        inst.strerror))

                    continue

                if stat.S_ISDIR(st.st_mode):

                    for dir, subdirs, fl in os.walk(f):

                        d = dir[len(self.root) + 1:]

                        nd = util.normpath(d)

                        if nd == '.': nd = ''

                        if seen(nd):

                            subdirs[:] = []

                            continue

                        for sd in subdirs:

                            ds = os.path.join(nd, sd +'/')

                            if self.ignore(ds) or not match(ds):

                                subdirs.remove(sd)

                        subdirs.sort()

                        fl.sort()

                        for fn in fl:

                            fn = util.pconvert(os.path.join(d, fn))

                            yield 'f', fn

                elif stat.S_ISREG(st.st_mode):

                    yield 'f', ff

                else:

                    kind = 'unknown'

                    if stat.S_ISCHR(st.st_mode): kind = 'character device'

                    elif stat.S_ISBLK(st.st_mode): kind = 'block device'

                    elif stat.S_ISFIFO(st.st_mode): kind = 'fifo'

                    elif stat.S_ISLNK(st.st_mode): kind = 'symbolic link'

                    elif stat.S_ISSOCK(st.st_mode): kind = 'socket'

                    self.ui.warn('%s: unsupported file type (type is %s)\n' % (

                        util.pathto(self.getcwd(), ff),

                        kind))

            ks = dc.keys()

            ks.sort()

            for k in ks:

                yield 'm', k

        # yield only files that match: all in dirstate, others only if

        # not in .hgignore

        for src, fn in util.unique(traverse()):

            fn = util.normpath(fn)

            if seen(fn): continue

            if fn not in dc and self.ignore(fn):

                continue

            if match(fn):

                yield src, fn

    def changes(self, files=None, match=util.always):

        self.read()

        if not files:

            dc = self.map.copy()

        else:

            dc = self.filterfiles(files)

        lookup, modified, added, unknown = [], [], [], []

        removed, deleted = [], []

        for src, fn in self.walk(files, match, dc=dc):

            try:

                s = os.stat(os.path.join(self.root, fn))

            except OSError:

                continue

            if not stat.S_ISREG(s.st_mode):

                continue

            c = dc.get(fn)

            if c:

                del dc[fn]

                if c[0] == 'm':

                    modified.append(fn)

                elif c[0] == 'a':

                    added.append(fn)

                elif c[0] == 'r':

                    unknown.append(fn)

                elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100:

                    modified.append(fn)

                elif c[3] != s.st_mtime:

                    lookup.append(fn)

            else:

                unknown.append(fn)

        for fn, c in [(fn, c) for fn, c in dc.items() if match(fn)]:

            if c[0] == 'r':

                removed.append(fn)

            else:

                deleted.append(fn)

        return (lookup, modified, added, removed + deleted, unknown)