import publish

"""
Some classes which are specific to Z3 but could possibly be
made more generic in the future.
"""
import tempfile, os, shutil

class Z3Page(publish.RstPage):
    def __init__(self, package, path, name=None):
        publish.RstPage.__init__(
            self, publish.UrlSource(
            'http://codespeak.net/svn/z3/%s/%s' % (package, path)),
            name)

class ZopeOrgPage(publish.RstPage):
    def __init__(self, package, path, name=None):
        publish.RstPage.__init__(
            self, publish.SvnSource(
            'svn://svn.zope.org/repos/main/%s/%s' % (package, path)),
            name)

class Z3TestPage(publish.RstPage):
    """A page from sources on your local disk

    By switching out the Z3Page for a Z3TestPage you can test a pages layout 
    before you check it in. This should not be used when producing the final
    web site, and so prints a warning.
    """

    def __init__(self, path, name=None):
        print "Warning! File generated from local disk, and not from SVN:"
        print path
        publish.RstPage.__init__(self, publish.PathSource(path), name)


class Z3ReleaseResource(publish.Resource):
    """Convenience way to create a Resource from svn tag.
    """
    def __init__(self, release_name, svn_path, name=None):
        publish.Resource.__init__(
            self, SvnReleaseSource(release_name, svn_path), name)

class SvnReleaseSource:
    def __init__(self, release_name, svn_path):
        self._svn_path = svn_path
        self._release_name = release_name
        
    def _getFileName(self):
        i = self._svn_path.rfind('/')
        return self._svn_path[i + 1:]
    
    def getName(self):
        name = self._getFileName() + '.tgz'
        if not name.startswith(self._release_name):
            name = self._release_name + '-' + name
        return name
    
    def getData(self):
        path = tempfile.mkdtemp()
        prev = os.getcwd()
        try:
            os.chdir(path)
            os.system('svn export -q %s' % self._svn_path)
            os.rename(self._getFileName(), self._release_name)
            os.system('tar czf %s %s' % (self.getName(), self._release_name)) 
            f = open(self.getName(), 'r')
            data = f.read()
            f.close()
        finally:
            os.chdir(prev)
            shutil.rmtree(path)
        return data
    
class Site(publish.Website):
    def __init__(self, path, root_project, css_link):
        publish.Website.__init__(self, path)
        self._root = root_project
        self._projects = []
        self._css_link = css_link
        
    def registerProject(self, project):
        self._projects.append(project)

    def getMainProjectLinks(self, short_title=True):
        if short_title:
            title = self._root.getShortTitle()
        else:
            title = self._root.getTitle()
        result = [(title, 'index.html')]
        for project in self._projects:
            if short_title:
                title = project.getShortTitle()
            else:
                title = project.getTitle()
            result.append((title, project.getName()))
        return result
    
    def getProjectLinks(self):
        result = []
        for title, link in self.getMainProjectLinks():
            if link == 'index.html':
                link = '..'
            else:
                link = '../' + link
            result.append((title, link))
        return result

    def getRootLayouter(self):
        # layouter for pages in the website root
        return publish.FileSimpleLayouter(
            self._root.getTemplatePath(),
            style=self._css_link,
            banner=self._root.getBannerLink(),
            site_links=self.getMainProjectLinks(),
            )
    
    def getProjectLayouter(self, project):
        # layouter for pages in directories under root
        banner_link = project.getBannerLink()
        if banner_link is None:
            banner_link = '../' + self._root.getBannerLink()
        return publish.FileSimpleLayouter(
            project.getTemplatePath(),
            style='../' + self._css_link,
            banner=banner_link,
            site_links=self.getProjectLinks(),
            )

    def construct(self):
        self._root.construct(self)
        for project in self._projects:
            project.construct(self)
            
class Project:
    def __init__(self, name, short_title, title, factory,
                 template_path=None, banner_link=None, release_files=None):
        self._name = name
        self._short_title = short_title
        self._title = title
        self._factory = factory
        self._template_path = template_path
        self._banner_link = banner_link
        self._release_files = []
        
    def getName(self):
        return self._name

    def getShortTitle(self):
        return self._short_title
    
    def getTitle(self):
        return self._title

    def getTemplatePath(self):
        return self._template_path
    
    def getBannerLink(self):
        return self._banner_link
    
    def construct(self, site):
        self._factory(site, self)