""" module to provide date classes among them 
    daterange. 
"""
from __future__ import generators

if __name__ == '__main__':
    import tool.autopath

from datetime import date as Date
from dateutil import parser 

parsedate = parser.parse 

class DateRange(object):
    """ a range of Dates. """
    def __init__(self, begin=None, end=None): 
        if isinstance(begin, (unicode, str)):
            begin = parsedate(begin) 
        if isinstance(end, (unicode, str)):
            end = parsedate(end) 
        if end is not None and begin is not None and end < begin:
            begin, end = end, begin 
        self.begin = begin
        self.end = end

    def __eq__(self, other):
        return self.begin == other.begin and self.end == other.end

    def __ne__(self, other):
        return self.begin != other.begin or self.end != other.end

    def __contains__(self, arg):
        if self.begin:
            if self.begin <= arg:
                if self.end is None or arg < self.end:
                    return 1

    def __nonzero__(self):
        """return true value if this range does not contain a valid date"""
        if not self.begin and not self.end:
            return True # open to both ends 
        if not self.begin or not self.end:
            return True # open to one end
        if self.end > self.begin:
            return True # daterange contains something
        return False

    def month(self):
        """ return list of month begin dates. """
        if self.begin is None or self.end is None:
            raise ValueError, "cannot return infinite number of months from %r" % self
        if self.begin.day != 1 or self.end.day != 1:
            raise ValueError, "daterange has to start and end at the first of a month"

        current = self.begin
        while current < self.end:
            yield current
            if current.month < 12:
                current = Date(current.year, current.month+1, current.day)
            else:
                current = Date(current.year+1, 1, current.day)

    def intersect(self, other):
        """ return one intersecting zeitraum. """
        begin1, end1 = self.begin, self.end
        begin2, end2 = other.begin, other.end

        if begin1 is None:
            begin = begin2
        elif begin2 is None:
            begin = begin1
        else:
            begin = max(begin1, begin2)

        if end1 is None:
            end = end2
        elif end2 is None:
            end = end1
        else:
            end = min(end1, end2)
        return DateRange(begin, end)

    def __str__(self):
        if not (self.begin or self.end):
            return "EmptyDateRange"
        if not self.end:
            return "%s-" % (self.begin,)
        if not self.begin:
            return "-%s" % (self.end,) 
        return "%s-%s" %(self.begin, self.end) 
    __repr__ = __str__