import os
from datetime import datetime, timedelta

from django.conf import settings
from django.contrib.auth.models import Group, User
from django.contrib.contenttypes import generic
from django.contrib.contenttypes.models import ContentType
from django.contrib.sites.managers import CurrentSiteManager
from django.contrib.sites.models import Site
from django.db import models
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _
from django_extensions.db.fields import AutoSlugField
from django_extensions.db.models import TimeStampedModel
from django_inlines import inlines
from taggit.managers import TaggableManager
from taggit.models import Tag

from darkroom.inlines import GraphicInline, PhotoInline
from darkroom.models import Gallery, Graphic, Movie, Photo, Slideshow
from directory.models import Person, Place, Town
from documents.models import Document, PDFDocument
from newsroom.managers import (
    AdvantagesEditionManager,
    CompassEditionManager,
    EditionManager,
    EditorialManager,
    PacketEditionManager,
    PatriotEditionManager,
    StoryManager,
)
from remember.models import Announcement, InMemoriam, Remembrance, Service

inlines.registry.register('photo', PhotoInline)
inlines.registry.register('graphic', GraphicInline)


# Get relative media path
NEWSROOM_DIR = getattr(settings, 'NEWSROOM_DIR', 'newsroom/')

MARKUP_HTML = 'h'
MARKUP_MARKDOWN = 'm'
MARKUP_REST = 'r'
MARKUP_TEXTILE = 't'
MARKUP_OPTIONS = getattr(
    settings,
    'ARTICLE_MARKUP_OPTIONS',
    (
        (MARKUP_MARKDOWN, _('Markdown')),
        (MARKUP_HTML, _('HTML/Plain Text')),
        (MARKUP_REST, _('ReStructured Text')),
        (MARKUP_TEXTILE, _('Textile'))
    )
)
MARKUP_DEFAULT = getattr(settings, 'COPY_MARKUP_DEFAULT', MARKUP_MARKDOWN)
AUTO_TAG = getattr(settings, 'NEWSROOM_AUTO_TAG', True)


class Paper(TimeStampedModel):
    name = models.CharField(_('name'), max_length=100)
    towns = models.ManyToManyField(Town)
    slug = AutoSlugField(_('slug'), populate_from='name', editable=True)
    description = models.TextField(_('description'), blank=True, null=True)

    class Meta:
        verbose_name = _('paper')
        verbose_name_plural = _('papers')
        ordering = ('name',)

    def __unicode__(self):
        return self.name


class Link(TimeStampedModel):
    url = models.URLField('URL')
    title = models.CharField(_('title'), max_length=255)
    description = models.CharField(_('description'), max_length=200, blank=True, null=True)
    published = models.BooleanField(_('published'), default=False)
    published_on = models.DateTimeField(_('published on'))

    class Meta:
        verbose_name = _('link')
        verbose_name_plural = _('links')
        ordering = ('created',)
        get_latest_by = 'published_on'

    def __unicode__(self):
        return self.title

    @models.permalink
    def get_absolute_url(self):
        return ('link_detail', (), {'slug': self.slug})


class AuthorType(models.Model):
    title = models.CharField(_('name'), max_length=100)
    slug = AutoSlugField(_('slug'), populate_from='title', editable=True)
    description = models.TextField(_('description'), blank=True, null=True)

    class Meta:
        ordering = ('title',)

    def __unicode__(self):
        return self.title

    @models.permalink
    def get_absolute_url(self):
        return ('author_type_detail', (), {'slug': self.slug})


class Author(TimeStampedModel):
    name = models.CharField(_('name'), max_length=100)
    slug = AutoSlugField(_('slug'), populate_from='name', editable=True)
    fixed_initials = models.CharField(_('initials'), blank=True, null=True, max_length=5)
    type = models.ForeignKey(AuthorType)
    title = models.CharField(_('Title'), blank=True, null=True, max_length=100)
    organization = models.ForeignKey(Place, blank=True, null=True)
    about = models.TextField(_('about'), blank=True, null=True)
    user = models.ForeignKey(User, blank=True, null=True)

    def initials(self):
        if self.fixed_initials:
            return self.fixed_initials
        else:
            initials = ''
            for i in self.name.split(" "):
                initials += i[0]
            return initials

    def __unicode__(self):
        return self.name

    @models.permalink
    def get_absolute_url(self):
        return ('nr-author-detail', (), {'type_slug': self.type.slug, 'slug': self.slug})

    class Meta:
        verbose_name = _('author')
        verbose_name_plural = _('authors')
        ordering = ('name',)
        get_latest_by = 'created'


class AttachedLink(models.Model):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    link = models.ForeignKey(Link)

    def __unicode__(self):
        return self.link.title


class AttachedGraphic(models.Model):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    graphic = models.ForeignKey(Graphic)

    def __unicode__(self):
        return self.graphic.title


class AttachedMovie(models.Model):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    movie = models.ForeignKey(Movie)

    def __unicode__(self):
        return self.movie.title


class AttachedSlideshow(models.Model):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    slideshow = models.ForeignKey(Slideshow)

    def __unicode__(self):
        return self.slideshow.title


class AttachedDocument(TimeStampedModel):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    document = models.ForeignKey(Document)

    class Meta:
        ordering = ['-created']
        get_latest_by = 'created'

    def __unicode__(self):
        return self.document.title

    def get_absolute_url(self):
        return self.document.get_absolute_url()

    def doc_dir(self):
        return os.path.dirname(self.get_file_filename())

    def remove_dirs(self):
        if os.path.isdir(self.doc_dir()):
            if os.listdir(self.doc_dir()) == []:
                os.removedirs(self.doc_dir())

    def delete(self):
        super(AttachedDocument, self).delete()
        self.remove_dirs()


class AttachedGallery(models.Model):
    content_type = models.ForeignKey(ContentType)
    object_id = models.IntegerField(db_index=True)
    content_object = generic.GenericForeignKey()
    gallery = models.ForeignKey(Gallery)

    def __unicode__(self):
        return self.gallery.title


class Dateline(TimeStampedModel):
    """A dateline specifies where a story's action takes place.

    The reason for the separate model is so that the string displayed
    can be custom, while the towns the dateline refers to are predetermined
    in the database. Thus a date line of: One Town and Anotehr Town or
    Our Community, can have specific locations related to them, while
    being able to be displayed per editorial spec."""

    title = models.CharField(_('title'), max_length=100)
    slug = AutoSlugField(_('slug'), populate_from='title', editable=True)
    towns = models.ManyToManyField(Town)

    class Meta:
        ordering = ('title',)

    def __unicode__(self):
        return self.title

    @models.permalink
    def get_absolute_url(self):
        return ('dateline_detail', (), {'slug': self.slug})


MARKUP_HELP = _(
    """Select the type of markup you are using in this article.
<ul>
<li><a href="http://daringfireball.net/projects/markdown/basics" target="_blank">Markdown Guide</a></li>
<li><a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html" target="_blank">ReStructured Text Guide</a></li>
<li><a href="http://thresholdstate.com/articles/4312/the-textile-reference-manual" target="_blank">Textile Guide</a></li>
</ul>"""
)


class StandingHed(TimeStampedModel):
    '''Standing Hed model.

    In lieu of a proper column or blog application, this is a hack to get some
    stories to always be associated with one author or column.
    '''
    title = models.CharField(_('Title'), max_length=100)
    slug = AutoSlugField(_('Slug'), populate_from='title', editable=True)

    def __unicode__(self):
        return self.title


class Copy(TimeStampedModel):
    '''Copy model.

       An abstract model for anything that can be copy.

       By default, we have two choices for heds.

       If a different web_hed isn't specified, we use the one from print.
    '''

    print_hed = models.CharField(_('print headline'), max_length=255)
    web_hed = models.CharField(_('web headline'), max_length=255)
    standing_hed = models.ForeignKey(StandingHed, blank=True, null=True)
    slug = AutoSlugField(_('slug'), populate_from='web_hed', editable=True)
    kicker = models.CharField(_('kicker'), max_length=255, blank=True, null=True)
    subhed = models.CharField(_('sub-headline'), max_length=255, blank=True, null=True)
    body = models.TextField(_('body'))
    summary = models.TextField(_('summary'), blank=True)
    markup = models.CharField(max_length=1, choices=MARKUP_OPTIONS, default=MARKUP_DEFAULT, help_text=MARKUP_HELP)
    published = models.BooleanField(_('publish'), default=False)
    published_on = models.DateTimeField(_('publish date'), default=datetime.now())
    paper_editions = models.ManyToManyField('PaperEdition', blank=True, null=True)
    sites = models.ManyToManyField(Site)
    view_count = models.PositiveIntegerField(default=0, editable=False)
    created_by = models.ForeignKey(User, editable=False)
    auto_tag = models.BooleanField(_('auto-tag'), default=True)

    tags = TaggableManager(blank=True)

    class Meta:
        abstract = True
        ordering = ('-published_on', 'print_hed')
        get_latest_by = 'published_on'

    @property
    def hed(self):
        if self.web_hed:
            return self.web_hed
        else:
            return self.print_hed

    @property
    def paragraphs(self):
        """
        Return the paragraphs as a list
        """
        import re
        if self.markup == 'm':
            import markdown
            html=markdown.markdown(self.body)
        elif self.markup == 't':
            import textile
            html=textile.textile(self.body)
        elif self.markup == 'r':
            html = 'Cant figure out how to implement RST yet...'
        else:
            html = self.body
        return re.findall("(<p.+?>.+?</p>)", html, re.I | re.S)

    def do_auto_tag(self):
        """
        Performs the auto-tagging work if necessary.

        Returns True if an additional save is required, False otherwise.
        """

        found = False
        if self.auto_tag:
            import re
            # don't clobber any existing tags!
            existing_ids = [t.id for t in self.tags.all()]

            unused = Tag.objects.all()
            unused = unused.exclude(id__in=existing_ids)

            for tag in unused:
                regex = re.compile(r'\b%s\b' % tag.name, re.I)
                regex_found = (
                    regex.search(self.body)
                    or regex.search(self.web_hed)
                    or regex.search(self.print_hed)
                    or regex.search(self.subhed)
                    or regex.search(self.kicker)
                )
                if regex_found:
                    self.tags.add(tag)
                    found = True

        return found

    def do_scrub_rich_text(self):
        scrubbed = False
        if self.markup == 'h':
            import re
            from django.template.defaultfilters import removetags
            self.body = re.sub('\n', ' ', re.sub('style=".*?"', '', re.sub('align=".*?"', '', removetags(
                self.body, "font br"
            ))))
            scrubbed = True
        return scrubbed

    def do_set_summary(self):
        summarized = False
        if (len(self.paragraphs[0].split(' ')) > 100) or (len(self.paragraphs) == 1):
            self.summary = self.paragraphs[0]
            summarized=True
        elif len(self.paragraphs) == 0:
            summarized = False
        else:
            self.summary = self.paragraphs[0] + self.paragraphs[1]
            summarized = True
        return summarized

    def save(self, *args, **kwargs):
        self.do_set_summary()
        super(Copy, self).save(*args, **kwargs)
        self.do_auto_tag()
        self.do_scrub_rich_text()
        super(Copy, self).save(*args, **kwargs)


class Story(Copy):
    """A story is one of our primary types of content"""
    STATUS_CHOICES = ((0, 'None'), (1, 'Primary'), (2, 'Secondary'), )

    dateline = models.ForeignKey(Dateline)
    authors = models.ManyToManyField(Author, blank=True, null=True)
    lead_photo = models.ForeignKey(Photo, blank=True, null=True)
    cropped_photo = models.ImageField(_('cropped photo'), blank=True, null=True,upload_to='newsroom/cropped_photos/')
    status = models.IntegerField(_('status'), choices=STATUS_CHOICES, default=0)
    towns = models.ManyToManyField(Town)
    weight = models.IntegerField(
        _('Weight'),
        null=True,
        blank=True,
        default=0,
        help_text='Stories weighted higher appear before those with lower weights.',
    )
    press_release = models.BooleanField(_('press release'), default=False)
    source = models.ForeignKey(Place, blank=True, null=True, help_text="Source of original copy if is a press release.")

    attached_documents = generic.GenericRelation(AttachedDocument)
    attached_gallery = generic.GenericRelation(AttachedGallery)
    attached_graphic = generic.GenericRelation(AttachedGraphic)
    attached_movie = generic.GenericRelation(AttachedMovie)
    attached_slideshow = generic.GenericRelation(AttachedSlideshow)

    # Custom story manager (see manager.py)
    objects = StoryManager()
    on_site = CurrentSiteManager('sites')

    class Meta:
        verbose_name_plural = ('stories')
        ordering = ('-published_on', 'web_hed', 'print_hed')
        get_latest_by = 'published_on'

    def prod_slug(self):
        authors=''
        for a in self.authors.all():
            authors = a.initials()
        if authors:
            return u'%s-%s' % (authors, self.slug)
        else: 
            return u'PR-%s' % (self.slug)
    
    def __unicode__(self):
        return self.hed
   
    def editions(self):
        list = ""
        for e in self.edition_set.all():
            list += e.paper.name +" " + e.published_on.strftime("%m-%d-%y") + "; "
        return list 

    @property
    def author(self):
        #link='<a href="%s" title="%s">%s</a>'
	string='%s'
        #authors=[link % (a.get_absolute_url(), a, a.name) for a in self.authors.all()]
	authors = [string % (a.name) for a in self.authors.all()]
        if len(authors) > 1:
            author_string="%s and %s" % (", ".join(authors[:-1]), authors[-1])
        if len(authors) == 1:
            author_string=authors[0]
        else:
            author_string = ''
        return mark_safe(author_string)

    @models.permalink 
    def get_absolute_url(self, site=''):
        return ('nr-story-detail', (), {
                'year': self.published_on.year,
                'month': self.published_on.strftime('%b').lower(),
                'day': self.published_on.day,
                'slug': self.slug})

    def get_admin_url(self):
        return u'admin/newsroom/story/%s/' % (str(self.id))

    def get_relative_url(self):
        return u'news/%s/%s/%s/%s' % (self.published_on.year, self.published_on.strftime('%b').lower(), self.published_on.day, self.slug)
    

class EditorialType(models.Model):
    '''Editorial Type model.

       A type of editorial...
    '''

    name= models.CharField(_('name'), max_length=100)
    slug = AutoSlugField(_('slug'), populate_from='name', editable=True)
    description = models.TextField(_('description'), blank=True, null=True)

    def __unicode__(self):
        return self.name

    @models.permalink
    def get_absolute_url(self):
        return ('editorial_type_detail', (), {'slug':self.slug})

class Editorial(Copy):
    '''Editorial model.
    
       Manages editorial content: letter to the editor, editor's notes, corrections.
    '''

    dateline = models.ForeignKey(Dateline, blank=True, null=True)
    type = models.ForeignKey(EditorialType)
    author = models.ForeignKey(Author, blank=True, null=True)
    citizen_authors = models.ManyToManyField(Person, blank=True, null=True)
    towns = models.ManyToManyField(Town)

    # Custom story manager (see manager.py)
    objects = EditorialManager()
    on_site = CurrentSiteManager('sites')

    class Meta:
        verbose_name_plural=('editorials')
        ordering=('-published_on', 'web_hed', 'print_hed')
        get_latest_by='published_on'

    def __unicode__(self):
        return self.web_hed

    def editions(self):
	list = ""
        for e in self.edition_set.all():
	    list += e.paper.name +" " + e.published_on.strftime("%m-%d-%y") + "; "
	return list 
    
    @models.permalink 
    def get_absolute_url(self, site=''):
        return ('nr-editorial-detail', (), {
                'year': self.published_on.year,
                'month': self.published_on.strftime('%b').lower(),
                'day': self.published_on.day,
                'slug': self.slug})

    def get_relative_url(self):
        return u'%s/%s/%s/%s' % (self.published_on.year, self.published_on.strftime('%b').lower(), self.published_on.day, self.slug)

class PaperEdition(TimeStampedModel):
    paper = models.ForeignKey(Paper)
    published_on = models.DateField(_('publish on'))
    published = models.BooleanField(_('published'), default=False)
    site = models.ManyToManyField(Site)

    class Meta:
        verbose_name=_('Paper edition')
        verbose_name_plural=_('Paper editions')
        ordering=('-published_on', 'paper')
        get_latest_by='published_on'
        
    def __unicode__(self):
        return u'%s published %s' % (self.paper, self.published_on)

class WebEdition(TimeStampedModel):
    paper = models.ForeignKey(Paper)
    published_on = models.DateField(_('publish on'))
    published = models.BooleanField(_('published'), default=False)
    site = models.ForeignKey(Site)
    featured_photo = models.ForeignKey(Photo, null=True, blank=True, related_name="featured_photo")
    featured_story = models.ForeignKey(Story, related_name="featured_story", null=True, blank=True)
    stories = models.ManyToManyField(
        Story,
        blank=True,
        null=True,
        help_text="Include the featured story in this list of all stories in this edition.",
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    photos = models.ManyToManyField(
        Photo,
        blank=True,
        null=True,
        related_name="photos",
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    galleries = models.ManyToManyField(
        Gallery,
        blank=True,
        null=True,
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    movies = models.ManyToManyField(Movie, blank=True, null=True)
    slideshows = models.ManyToManyField(Slideshow, blank=True, null=True)
    editorials = models.ManyToManyField(Editorial, blank=True, null=True)
    pdfdocuments = models.ManyToManyField(PDFDocument, blank=True, null=True)
    remembrances = models.ManyToManyField(
        Remembrance,
        blank=True,
        null=True,
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    death_announcements = models.ManyToManyField(
        Announcement,
        blank=True,
        null=True,
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    memorial_services = models.ManyToManyField(
        Service,
        blank=True,
        null=True,
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )
    inmemoriams = models.ManyToManyField(
        InMemoriam,
        blank=True,
        null=True,
        limit_choices_to={'published_on__gte': datetime.today()-timedelta(days=45)},
    )

    objects=EditionManager()
    on_site = CurrentSiteManager('site')

    # per-paper managers
    patriot = PatriotEditionManager()
    advantages = AdvantagesEditionManager()
    packet = PacketEditionManager()
    compass = CompassEditionManager()

    class Meta:
        verbose_name =_('Web edition')
        verbose_name_plural =_('Web editions')
        ordering = ('-published_on', 'paper')
        get_latest_by = 'published_on'

    def __unicode__(self):
        return u'Web edition of %s published on %s' % (self.paper, self.published_on)


'''
    def save(self):
        if not self.id:
            super(Edition, self).save(*args, **kwargs)
        if self.published==True:
            self.stories.all().update(published=True)
            self.galleries.all().update(published=True)
            self.slideshows.all().update(published=True)
            self.movies.all().update(published=True)
            self.editorials.all().update(published=True)
            for p in self.photos.all():
                p.published=True
                p.save()
            for s in self.stories.all():
                if s.lead_photo:
                    s.lead_photo.published=True 
                    s.lead_photo.save()
                s.photos.all().update(published=True)
                for g in s.galleries.all():
                    for p in g.photos.all():
                        p.published=True
                        p.save()
            for g in self.galleries.all():
                for p in g.photos.all():
                    p.published=True
                    p.save()
            for a in self.death_announcements.all():
                a.published=True
                a.save()
            for s in self.memorial_services.all():
                s.published=True
                s.save()
            for i in self.inmemoriams.all():
                i.published=True
                i.save()
            for r in self.remembrances.all():
                r.published=True
                r.save()
        else:
            self.stories.all().update(published=False)
            self.galleries.all().update(published=False)
            self.photos.all().update(published=False)
            self.slideshows.all().update(published=False)
            self.movies.all().update(published=False)
            self.editorials.all().update(published=False)
            for s in self.stories.all():
                if s.lead_photo:
                    s.lead_photo.published=False 
                    s.lead_photo.save()
            for g in self.galleries.all():
                for p in g.photos.all():
                    p.published=False
                    p.save()
            for a in self.death_announcements.all():
                a.published=False
                a.save()
            for s in self.memorial_services.all():
                s.published=False
                s.save()
            for i in self.inmemoriams.all():
                i.published=False
                i.save()
            for r in self.remembrances.all():
                r.published=False
                r.save()
        super(WebEdition, self).save(*args, **kwargs)
'''


class ArchiveItem(TimeStampedModel):
    '''A base class inherited by whatever content class we want to stuff in
    the archive.

    Items are associated with a particular paper, can expire and belong
    to "groups"

    The groups allow for very basic access control, so we could sell access to
    certain archive items.

    '''

    archived_on = models.DateTimeField(_('Archived on'), default=datetime.now())
    expires_on = models.DateTimeField(_('Expires on'), blank=True, null=True)
    groups = models.ManyToManyField(Group, blank=True, null=True)
    paper = models.ForeignKey(Paper)


class ArchiveSection(ArchiveItem):
    '''Archive section model.

       This model is used to collect editioral content into a produced section

       The group can then be displayed on as an archive on a particular subject.

       It actually duplicates a lot of what's in a story because section objects
       don't exist in and of their own like stories or documents.
    '''

    GROUP_BY_CHOICES = (
        ('type', _('Type')),
        ('dline', _('Dateline')),
        ('both', _('Both')),
    )
    title = models.CharField(_('title'), max_length=200)
    slug = AutoSlugField(_('slug'), populate_from='title', editable=True)
    description = models.TextField(_('body'))
    published = models.BooleanField(_('published'), default=False)
    published_on = models.DateTimeField(_('published on'))
    thumbnail = models.ImageField(_('Thumbnail'), blank=True, null=True, upload_to="newsroom/archives/thumbnails/")
    lead_image = models.ImageField(_('Lead image'), blank=True, null=True, upload_to="newsroom/archives/lead_images/")
    dateline = models.ForeignKey(Dateline, blank=True, null=True)
    stories = models.ManyToManyField(Story, blank=True, null=True)
    editorials = models.ManyToManyField(Editorial, blank=True, null=True)
    pdf_documents = models.ManyToManyField(PDFDocument, blank=True, null=True)
    photos = models.ManyToManyField(Photo, blank=True, null=True)
    galleries = models.ManyToManyField(Gallery, blank=True, null=True)
    movies = models.ManyToManyField(Movie, blank=True, null=True)
    slideshows = models.ManyToManyField(Slideshow, blank=True, null=True)
    group_by = models.CharField(_('Group by'), choices=GROUP_BY_CHOICES,
        default='type', max_length=10)

    class Meta:
        verbose_name=_('archive section')
        verbose_name_plural=('archive sections')                               
        ordering=['-modified']

    def __unicode__(self):
        return u'%s' % self.title

    @models.permalink
    def get_absolute_url(self):
        return ('nr-archive-section-detail', (), {'year':self.published_on.year, 'slug':self.slug})

    def get_relative_url(self):
        return u'%s/%s/' % (self.published_on.year, self.slug)


class ArchiveStory(ArchiveItem):
    """A wrapper class for putting stories into our "archive" section"""
    story = models.ForeignKey(Story)

    class Meta:
        verbose_name=_('Archived story')
        verbose_name_plural=_('Archived stories')

    def __unicode__(self):
        return u'%s' % self.story.hed()

    @models.permalink
    def get_absolute_url(self):
        return self.story.get_absolute_url


class ArchiveMovie(ArchiveItem):
    """A wrapper class for putting movies into our "archive" section"""

    movie = models.ForeignKey(Movie)

    class Meta:
        verbose_name=_('Archived movie')
        verbose_name_plural=_('Archived movies')

    def __unicode__(self):
        return u'%s' % self.movie.title()

    @models.permalink
    def get_absolute_url(self):
        return self.movie.get_absolute_url


class ArchiveSlideshow(ArchiveItem):
    """A wrapper class for putting slideshows into our "archive" section"""
    slideshow = models.ForeignKey(Slideshow)

    class Meta:
        verbose_name =_('Archived slideshow')
        verbose_name_plural =_('Archived slideshows')

    def __unicode__(self):
        return u'%s' % self.slideshow.title()

    @models.permalink
    def get_absolute_url(self):
        return self.slideshow.get_absolute_url


class ArchiveDocument(ArchiveItem):
    """We need a way to stick documents in the archive..."""

    document = models.ForeignKey(Document)

    class Meta:
        verbose_name =_('Archived document')
        verbose_name_plural =_('Archived documents')

    def __unicode__(self):
        return u'%s' % self.document.title

    @models.permalink
    def get_absolute_url(self):
        return self.document.get_absolute_url


'''
class PageType(models.Model):
    name = models.CharField(_('name'), max_length=150)
    slug = AutoSlugField(_('slug'), populate_from='name', editable=True)
    description = models.TextField(_('description'), blank=True, null=True)

    class Meta:
        verbose_name=_('page type')
        verbose_name_plural=('page types')                               

    def __unicode__(self):
        return u'%s' % (self.name) 

class Page(models.Model):
    number = models.IntegerField(_('number'), max_length=3)
    edition = models.ForeignKey(Edition)
    copy_inches = models.IntegerField(_('inches of copy'), max_length=3, blank=True, null=True, help_text='If left blank, will be calcuated by included copy.' )
    ad_inches = models.IntegerField(_('inches of ads'), max_length=3, blank=True, null=True, help_text='If left blank, will be calcuated by included ads.' )
    ad_group = models.ForeignKey(AdCategory, null=True, blank=True, help_text='Primary ad group for page.')
    ad_notes = models.TextField(_('ad notes'), null=True, blank=True)
    ad_spec_pos = models.TextField(_('ad special position'), null=True, blank=True)
    ads = models.ManyToManyField(BannerAd, blank=True, null=True)
    copy = models.ManyToManyField(Story, blank=True, null=True )
    photos = models.ManyToManyField(Photo, blank=True, null=True )
    type = models.ForeignKey(PageType, blank=True, null=True )

    class Meta:
        verbose_name=_('page')
        verbose_name_plural=('pages')                               
        unique_together = (("number", "edition"),)

    def __unicode__(self):
        return u'Page %s of %s' % (self.number, self.edition)


'''
