import scribus
import datetime
import calendar

class ScribusCalendar(object):
    def __init__(self, objects, year):
        self.objects = objects
        self.year = year


    def createStyles(self):
        existing_styles = scribus.getAllStyles()
        for obj in self.objects:
            obj.createStyles(existing_styles)


    def createLayers(self):
        existingLayers = scribus.getLayers()
        for obj in self.objects:
            obj.createLayer(existingLayers)
            
    def plotStubs(self):
        created = False

        for obj in self.objects:
            created = obj.plotStub() or created

        return created

    def plotObjects(self):
        pass

    def readFromStubs(self):
        for obj in self.objects:
            obj.readFromStub()


class CalendarObject(object):
    def __init__(self, name):
        self.name = name

        self.position = (0,0)
        self.size = (100,100)

        self.paragraphStyle = "DefaultCalenderParagraphStyle"
        self.charStyle = "DefaultCalenderCharStyle"

        self.layer = "CalendarLayer"
        
        self.date = datetime.date.today()

    def setDate(self, date):
        self.date = date

    def setDimension(self, pos, size):
        self.position = pos
        self.size = size

    def createLayer(self, existingLayers):
        if self.layer not in existingLayers:
            scribus.createLayer(self.layer)
            existingLayers.append(self.layer)
        
    def createStyles(self, existingStyles):
            if self.charStyle not in existingStyles:
                scribus.createCharStyle(self.charStyle, "DejaVu Sans", 8)
                existingStyles.append(self.charStyle)
                
            if self.paragraphStyle not in existingStyles:
                scribus.createParagraphStyle(self.paragraphStyle ,1,0,0,0,0,0,0,0,0,0,0,self.charStyle)
                existingStyles.append(self.paragraphStyle)

    def plotStub(self):
        if not scribus.objectExists(self.name):
            scribus.createText(self.position[0],self.position[1], self.size[0],self.size[1], self.name)
            scribus.insertText(self.name, 0, self.name)
            scribus.sentToLayer(self.layer, self.name)
            return True
        return False

    def readFromStub(self):
        p = scribus.getPosition(self.name)
        s = scribus.getSize(self.name)

        self.setDimension(p, s)

    def plotObject(self):
        pass

    
    def configure(self, configParser):
        className = self.__class__.__name__
        settings = dict()

        try:
            settings = configParser.modules[className]
        except KeyError:
            return

        for key, val in settings.items():
                setattr(self,key, val)

        


class WeekDayNameObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.weekday = datetime.date.today().weekday()

    def getName(self):
        return calendar.day_name[self.date.weekday()]
    
    def getNameAbbrev(self):
        return calendar.day_abbr[self.date.weekday()]

class WeekNameObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.weeknumber = 1

    def setDate(self, date):
        CalendarObject.setDate(self, date)
        self.weeknumber = self.date.isocalendar()[1]

    def getName(self):
        return str(self.weeknumber)


    def getNameAbbrev(self):
        return self.getName()

    


class DailyCalendarObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.isActive = True

    def getName(self):
        return str(self.date.day)

    def setActive(self, state=True):
        self.isActive = state


class MonthlyCalendarObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)

    def setDate(self, date):
        CalendarObject.setDate(self, date)
        self.month = self.date.month


    def getName(self):
        return calendar.month_name[self.month]

    def getNameAbbrev(self):
        return calendar.month_abbr[self.month]