# Copyright (C) 2003-2007 John Goerzen
# <jgoerzen@complete.org>
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import util
import os.path
from commandver import cmd, isdarcs, issvk, isgit, ishg, vcscmd

class wc:
    """Object for a working copy."""

    def __init__(self, wcpath, verbose = 0, fsonly = 0):
        self.wcpath = os.path.abspath(wcpath)
        self.verb = verbose
        self.fsonly = fsonly
        if not self.wcverify():
            raise Exception, "%s is not a tla working copy" % self.wcpath

    def gettreeversion(self):
        if isdarcs():
            #util.chdircmd(self.wcpath, util.getstdoutsafeexec, "darcs",
            #              ['check'])
            return "Darcs repository"
        elif ishg():
            return "Mercurial repository"
        elif issvk():
            return "Svk repository"
        elif isgit():
            return "Git repository"
        else:
            return util.chdircmd(self.wcpath, util.getstdoutsafeexec, vcscmd,
                                 ['tree-version'])[0].strip() 

    def wcverify(self):
        try:
            self.gettreeversion()
        except util.ExecProblem:
            return 0
        return 1

    def gettaggingmethod(self):
        if isdarcs() or isgit() or ishg():
            return 'explicit'
        else:
            return util.chdircmd(self.wcpath, util.getstdoutsafeexec, vcscmd,
                                 [cmd().tagging_method])[0].strip()

    def gettree(self):
        return util.maketree(self.wcpath,
                             ignore = [r'(^(\{arch\}$|,,|\.hg|\.hgtags|\.hgignore|\.git|_darcs|\.arch-ids$|\.arch-inventory$|\+\+)|/\.arch-ids/)'])
    
    def addtag(self, file):
        if self.verb:
            print "Adding %s" % file
        if (file[-1] == '/') and \
           (not os.path.exists(os.path.join(self.wcpath,
                                            file[:-1]))):
            try:
                print "addtag: making dir %s" % file[:-1]
                os.makedirs(os.path.join(self.wcpath, file[:-1]))
            except:
                raise
        file = self.slashstrip(file)
        isdir = os.path.isdir(os.path.join(self.wcpath, file))
        if (not self.fsonly) and \
               (not ishg()) and ((not isdarcs()) or isdir):
            # Darcs will see adds later, but we need to add dirs
            # now so darcs mv will work.
            #
            # Mercurial will see adds later, and doesn't track directories,
            # so we don't do anything with it.
            util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          cmd().add + [file])

    def movetag(self, src, dest):
        if self.verb:
            print "Moving %s to %s" % (src, dest)
        if src[-1] == '/' \
               and dest[-1] == '/' \
               and ((not isdarcs()) and (not isgit()) and (not ishg())):
            # Dir to dir -- darcs mv will catch it already.
            # Git doesn't do rename recording, so don't worry about it?
            return
        src, dest = self.slashstrip(src, dest)
        if not self.fsonly:
            util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          [cmd().move, src, dest])

    def movefile(self, src, dest):
        if self.verb:
            print "Moving file %s to %s" % (src, dest)
        src, dest = self.slashstrip(src, dest)

        def doit():
            destdir = os.path.dirname(dest)
            if (not os.path.exists(destdir)) and destdir != '':
                self.makedirs(destdir)
            if self.fsonly or \
               (not isdarcs() and (not isgit()) and (not ishg())):
                # Darcs, hg, and git actually do this when they move the tag
                os.rename(src, dest)

        util.chdircmd(self.wcpath, doit)

    def delfile(self, file):
        if self.verb:
            print "Deleting file %s" % file
        fullfile = os.path.join(self.wcpath, file)
        if os.path.isfile(fullfile):
            os.unlink(fullfile)
        else:
            util.safeexec("rm", ['-rf', fullfile])

    def deltag(self, file):
        if (not self.fsonly) and \
               ((not isdarcs()) and (not ishg())):
            if self.verb:
                print "Deleting %s" % file
            if os.path.islink(os.path.join(self.wcpath,file)) or os.path.exists(os.path.join(self.wcpath, file)):
                util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          cmd().delete + [file])

    def makelog(self, summary, logtext):
        self.summary = summary
        self.logtext = logtext
        if ishg() or isgit() or isdarcs():
            logfn = self.wcpath + "/../,,vcslog"
	else:
            logfn =  util.chdircmd(self.wcpath, util.getstdoutsafeexec, vcscmd,
                                   ['make-log'])[0].strip()

        self.logfn = os.path.abspath(logfn)
        
        fd = open(self.logfn, "w")
        if isgit():
            fd.write("%s\n\n" % summary)
        if ishg():
            fd.write("%s\n" % summary)
        elif not (isdarcs() or ishg()):
            fd.write("Summary: %s\n" % summary)
            fd.write("Keywords: \n\n")
        fd.write(logtext)
        print "LOGTEXT", logtext
        fd.close()


    def commit(self):
        if self.verb:
            print "Committing changes"
        if isdarcs():
            util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          [cmd().commit, "-l", "-a", "-m", self.summary,
                           "--logfile", self.logfn,
                           "--delete-logfile"])
        elif isgit():
            util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          [cmd().commit, "-a", "-F", self.logfn])
	    os.unlink(self.logfn)
        elif ishg():
            util.chdircmd(self.wcpath, util.safeexec, vcscmd,
                          [cmd().commit, "-A", "-l", self.logfn])
            os.unlink(self.logfn)
        else:
            if len(util.chdircmd(self.wcpath, util.getstdoutsafeexec, vcscmd, ['logs']))==0:
                util.chdircmd(self.wcpath, util.safeexec, vcscmd, [cmd().importcmd])
            else:
                util.chdircmd(self.wcpath, util.safeexec, vcscmd, [cmd().commit])
        
    def slashstrip(self, *args):
        retval = []
        for item in args:
            if not len(item):
                retval.append(item)
            if item[-1] == '/':
                item = item[:-1]
            retval.append(item)
        if len(args) == 1:
            return retval[0]
        return retval


    def makedirs(self, name, mode=0777):
        """makedirs(path [, mode=0777])

        Super-mkdir; create a leaf directory and all intermediate ones.
        Works like mkdir, except that any intermediate path segment (not
        just the rightmost) will be created if it does not exist.  This is
        recursive.

        (Modified from Python source)

        """
        head, tail = os.path.split(name)
        if not tail:
            head, tail = os.path.split(head)
        if head and tail and not os.path.exists(head):
            self.makedirs(head, mode)
        if self.verb:
            print "Created directory", name
        os.mkdir(name, mode)
        self.addtag(name)