import datetime
import os
from xml.dom.minidom import parse, parseString
from dynastie.generators.generator import DynastieGenerator, StrictUTF8Writer
from dynastie.generators.index import Index
from django.db import models

class Post(Index):

    def createComments(self, post, dom, post_elem, root):
        from dynastie.models import Post, Blog, Comment

        base_url = root.getAttribute('base_url')
        add_comment = (root.getAttribute('add_comment') == '1')

        comments = Comment.objects.filter(post=post)

        comment_list_list = []
        for comment in comments:
            try:
                if comment.parent_id == 0:
                    comment_list_list.append([comment])
                else:
                    for comment_list in comment_list_list:
                        if comment_list[0].id == comment.parent_id:
                            comment_list.append(comment)
                            break
            except Comment.DoesNotExist:
                comment_list_list.append([comment])

        initial_root_comment = root_comment = self.createElement(dom, 'comments')
        for comment_list in comment_list_list:
            for comment in comment_list:
                comment_element = self.createElement(dom, 'comment')
                comment_content = self.createElement(dom, 'comment_content', comment.the_comment)
                comment_element.appendChild(comment_content)
                root_comment.appendChild(comment_element)
                root_comment = comment_element
            root_comment = initial_root_comment
        post_elem.replaceChild(root_comment, root)        

    def createMetas(self, post, dom, meta_elem, root):
        name = root.getAttribute('name')
        if name is None:
            self.addError('Missing name attribute in dyn:meta')
            return

        new_elem = None
        if name == 'keywords':
            new_elem = self.createMeta(dom, name, post.keywords)
        elif name == 'title':
            new_elem = self.createMeta(dom, name, post.title)
        elif name == 'description':
            new_elem = self.createMeta(dom, name, post.description)
        elif name == 'author':
            new_elem = self.createMeta(dom, name, post.author.first_name + ' ' + post.author.last_name)

        if not new_elem is None:
            root.parentNode.replaceChild(new_elem, root)
        else:
            self.addError('name attribute \'' + name + '\' unknown for dyn:meta' )

    def _createPost(self, post, dom, post_elem, root):
        import sys, traceback

        if post.id == 122:
            print post_elem.toxml()
        self.createPost(post, dom, post_elem, root)

        # Post are appended by index. Remove template
        post_nodes = dom.getElementsByTagNameNS(self.URI, 'post')
        post_elem = post_nodes[0]
        post_elem.parentNode.removeChild(post_elem)

        title_nodes = dom.getElementsByTagName('title')

        # Set title to be title's post
        for node in title_nodes:
            if node.hasChildNodes():
                node.removeChild(node.childNodes[0])
            node.appendChild(dom.createTextNode(post.title))

    def _generate(self, blog, src, output, posts):
        import xml
        hooks = {'post' : self._createPost,
                 'meta' : self.createMetas,
                 'comments' : self.createComments}

        if not os.path.exists(src + '/_post.html'):
            self.addError('No _post.html found, exiting')
            return self.report

        if not os.path.exists(output + '/post'):
            os.mkdir(output + '/post')

        try:
            dom = parse(src + '/_post.html')
        except xml.dom.DOMException as e:
            self.addError('Error parsing _post.html : ' + e)
            return self.report

        for post in posts:
            #print 'Generate ' + filename
            nodes = dom.getElementsByTagName("*")
            nodes[0] = self.parse(src, hooks, post, dom, nodes[0])
            
            filename = output + '/post/' 
            filename = filename + post.creation_date.strftime("%Y") + '/' + post.creation_date.strftime("%m") + '/' 
            if not os.path.exists(filename):
                os.makedirs(filename)
            filename = filename + post.title_slug + '.html'
            self.writeIfNotTheSame(filename, nodes[0])
            dom = parse(src + '/_post.html')

        if not self.somethingWrote:
            self.addReport('Nothing changed')

        return self.report

    def generate(self, blog, src, output):
        from dynastie.models import Post, Blog

        posts = Post.objects.all()

        return self._generate(blog, src, output, posts)

    def createPreview(self, values, dom, root, node):
        now = datetime.datetime.now()

        v = {}
        v['title'] = self.createLinkElem(dom, '/preview.html', values['title'])
        v['author'] = values['author']
        v['date'] = now.strftime("%A, %d %B %Y %H:%m")
        v['post_content'] = ''

        self.simpleTransform(v, dom, root, node)

        content_nodes = root.getElementsByTagName("div")
        post_transform = ('post_content')
        for content_node in content_nodes:
            the_class = content_node.getAttribute('class')
            if not the_class in post_transform:
                continue
            if the_class == 'post_content':
                new_node = dom.createTextNode(values['content'])
                content_node.appendChild(new_node)

        post_nodes = dom.getElementsByTagNameNS(self.URI, "post")
        post_elem = post_nodes[0]
        post_elem.parentNode.removeChild(post_elem)

    def preview(self, src, values):
        from dynastie.models import Blog

        hooks = {'post' : self.createPreview}

        if not os.path.exists(src + '/_post.html'):
            self.addError('No _post.html found, exiting')
            return self.report

        try:
            dom = parse(src + '/_post.html')
        except xml.dom.DOMException as e:
            self.addError('Error parsing _post.html : ' + e)
            return self.report
            
        post_nodes = dom.getElementsByTagNameNS(self.URI, "posts")

        if post_nodes is None:
            self.addError('No tag dyn:posts found')
            return self.report

        nodes = dom.getElementsByTagName("*")
        nodes[0] = self.parse(src, hooks, values, dom, nodes[0])
        writer = StrictUTF8Writer()
        nodes[0].writexml(writer)

        return writer.getvalue().encode('utf-8')