"""

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.

"""

import struct, os

from node import *

from demandload import *

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

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)

            if self.copies.has_key(f):

                del self.copies[f]

    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

                    continue

                    yield 'f', ff

                yield 'm', k

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

            if not stat.S_ISREG(s.st_mode):

            if c:

                    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)