# Copyright (C) 2010 by Intevation GmbH
# Authors:
# Bjoern Ricks <bjoern.ricks@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Build treepkg status information"""

import os.path
import xml.dom.minidom

from treepkg.report import get_packager_group


TREEPKG_NAMESPACE_URI = "http://wald.intevation.org/projects/treepkg/"
TREEPKG_NAMESPACE_PREFIX = "tpkg"

def createTpkgElement(doc, name):
    return doc.createElementNS(TREEPKG_NAMESPACE_URI, name)

def createTpkgRoot(name):
    domimpl = xml.dom.minidom.getDOMImplementation()
    doc = domimpl.createDocument(TREEPKG_NAMESPACE_URI, name, None)
    root = doc.documentElement
    return (doc, root)

class TreepkgInfo:

    def __init__(self, config):
        group = get_packager_group(config)
        self.tpkgroot = TreepkgRootInfo(group.name, group.treepkg_dir, 
                                        group.tracks_dir)
        tracks = group.get_package_tracks()

        for track in tracks:
            trackinfo = TreepkgTrackInfo(track.name)
            self.tpkgroot.add_track(trackinfo)
            self.add_revisions(track, trackinfo)

    def toxml(self):
        return self.tpkgroot.toxml()

    def add_revisions(self, track, trackinfo):
        revisions = track.get_revisions()
        for rev in revisions:
            revision = rev.revision
            rules_revision = rev.rules_revision
            status  = rev.status.status # extend status
            platforminfo = self.get_platform(rev)
            revinfo = TreepkgTrackRevisionInfo(revision, rules_revision, 
                                               status, platforminfo)
            trackinfo.add_revision(revinfo)

    def get_platform(self, revision):
        # FIXME
        os = "abc os"
        arch = "def arch"
        platforminfo = TreepkgPlatformInfo(os, arch)
        logs = revision.get_log_files()
        for (title, file) in logs:
            loginfo = TreepkgLogInfo(title, file)
            platforminfo.add_log(loginfo)
        sources = revision.list_source_files()
        for source in sources:
            self.add_package(source, "source", platforminfo)
        binaries = revision.list_binary_files()
        for binary in binaries:
            self.add_package(binary, "binary", platforminfo)
        return platforminfo

    def add_package(self, file, type, platform):
        name = os.path.basename(file)
        checksum = md5sum(file)
        checksuminfo = TreepkgChecksumInfo(checksum, "md5")
        pkginfo = TreepkgPackageInfo(name, file, type)
        pkginfo.add_checksum(checksuminfo)
        platform.add_package(pkginfo)

class TreepkgRootInfo:

    def __init__(self, name, treepkgpath=None, trackspath=None, version=None):
        self.name = name
        self.treepkgpath = treepkgpath
        self.trackspath = trackspath
        self.version = version
        self.tracks = []

    def add_track(self, track):
        self.tracks.append(track)

    def toxml(self):
        (doc, root) = createTpkgRoot("status")
        # add <name>
        nameele = createTpkgElement(doc, "name")
        text = doc.createTextNode(self.name)
        nameele.appendChild(text)
        root.appendChild(nameele)
        # add <treepkgpath>
        if self.treepkgpath:
            treepkgpathele = createTpkgElement(doc, "treepkgpath")
            text = doc.createTextNode(self.treepkgpath)
            treepkgpathele.appendChild(text)
            root.appendChild(treepkgpathele)
        # add <trackspath>
        if self.trackspath:
            trackspathele = createTpkgElement(doc, "trackspath")
            text = doc.createTextNode(self.trackspath)
            trackspathele.appendChild(text)
            root.appendChild(trackspathele)
        # add <version>
        if self.version:
            versionele = createTpkgElement(doc, "version")
            text = doc.createTextNode(self.version)
            versionele.appendChild(text)
            root.appendChild(version)
        if len(self.tracks) > 0:
            tracksele = createTpkgElement(doc, "tracks")
            for track in self.tracks:
                tracksele.appendChild(track.toxml())
            root.appendChild(tracksele)
        return root

class TreepkgTrackInfo:
    
    def __init__(self, name):
        self.name = name
        self.revisions = []

    def add_revision(self, revision):
        self.revisions.append(revision)

    def toxml(self):
        (doc, root) = createTpkgRoot("track")
        nameele = createTpkgElement(doc, "name")
        text = doc.createTextNode(self.name)
        nameele.appendChild(text)
        root.appendChild(nameele)
        for rev in self.revisions:
            root.appendChild(rev.toxml())
        return root

class TreepkgTrackRevisionInfo:

    def __init__(self, number, rules, status, platform):
        self.number = number
        self.rules = rules
        self.status = status
        self.platform = platform

    def toxml(self):
        (doc, root) = createTpkgRoot("revision")
        # add <number>
        numberele = createTpkgElement(doc, "number")
        text = doc.createTextNode(self.number)
        numbverele.appendChild(text)
        root.appendChild(numberele)
        # add <rules>
        rulesele = createTpkgElement(doc, "rules")
        text = doc.createTextNode(self.rules)
        rulesele.appendChild(text)
        root.appendChild(rulesele)
        # add <status><message></message></status>
        statusele = createTpkgElement(doc, "status")
        messageele = createTpkgElement(doc, "message")
        text = doc.createTextNode(self.status)
        messageele.appendChild(text)
        statusele.appendChild(messageele)
        root.appendChild(statusele)
        # add <platform>
        root.appendChild(platform.toxml())
        return root

class TreepkgPlatformInfo:

    def __init__(self, os, arch):
        self.os = os
        self.arch = arch
        self.packages = []
        self.logs = []

    def add_package(self, package):
        self.packages.append(package)

    def add_log(self, log):
        self.logs.append(log)

    def toxml(self):
        (doc, root) = createTpkgRoot("platform")
        # add <os>
        osele = createTpkgElement(doc, "os")
        text = doc.createTextNode(self.os)
        osele.appendChild(text)
        root.appendChild(osele)
        # add <arch>
        archele = createTpkgElement(doc, "arch")
        text = doc.createTextNode(sef.arch)
        archele.appendChild(text)
        root.appendChild(archele)
        # add <packages>
        packagesele = createTpkgElement(doc, "packages")
        for package in self.packages:
            packagesele.appendChild(package.toxml())
        root.appendChild(packagesele)
        # add <logs>
        logsele = createTpkgElement(doc, "logs")
        for log in self.logs:
            losele.appendChild(log)
        root.appendChild(logsele)
        return root

class TreepkgLogInfo:

    def __init__(self, name, path):
        self.name = name
        self.path = path

    def toxml(self):
        (doc, root) = createTpkgRoot("log")
        # add <name>
        nameele = createTpkgElement(doc, "name")
        text = doc.createTextNode(self.name)
        nameele.appendChild(text)
        root.appendChild(nameele)
        # add path
        pathele = createTpkgElement(doc, "path")
        text = doc.createTextNode(self.path)
        pathele.appendChild(text)
        root.appendChild(pathele)
        return root

class TreepkgPackageInfo:
        
    def __init__(self, name, path, type):
        self.name = name
        self.path = path
        self.type = type
        self.checksums = [] 

    def toxml(self):
        (doc, root) = createTpkgRoot("package")
        # add <name>
        nameele = createTpkgElement(doc, "name")
        text = doc.createTextNode(self.name)
        nameele.appendChild(text)
        root.appendChild(nameele)
        # add <path>
        pathele = createTpkgElement("path")
        text = doc.createTextNode(self.path)
        pathele.appendChild(text)
        root.appendChild(pathele)
        # add <checksum>
        for checksum in self.checksums:
            root.appendChild(checksum.toxml())
        # add <type>
        typeele = createTpkgElement(doc, "type")
        text = doc.createTextNode(self.type)
        typeele.appendChild(text)
        root.appendChild(typeele)
        return root

class TreepkgChecksumInfo:
    
    def __inif__(self, checksum, type="md5"):
        self.checksum = checksum
        self.type = type

    def toxml(self):
        (doc, root) = createTpkgRoot("checksum")
        text = doc.createTextNode(self.checksum)
        root.appendChild(text)
        # add attribute type
        root.setAttributeNS(TREEPKG_NAMESPACE_URI, "type", self.type)
        return root