# Decorator, lots of __ methods, formatting, and more

class parrot(object):
        def __init__(self,val=1):
                self.number = val
        def __add__(this, that):
                newbird = parrot(this.number + that)
                return newbird
        def __iadd__(this, that):
                this.number += that
                return this
        def __str__(this):
                return str(this.number) + " [user format]"
        def __repr__(this):
                return str(this.number) + " [dump / geek format]"

def identity(what):
        myname = what.func_name
        # A do-nothing decorator for illustration

        def wrapped(*args, **kwargs):
                finalanswer = what(*args, **kwargs)
                return finalanswer

        wrapped.__doc__ = what.__doc__
        return wrapped

def logger(what):
        try:
                # print what
                # next line to be resolved
                myname = what.getclass() + "/" + what.func_name
        except:
                myname = "//" + what.func_name

        def wrapped(*args, **kwargs):
                finalanswer = what(*args, **kwargs)
                try:
                        covercount[myname] += 1
                except:
                        covercount[myname] = parrot()
                return finalanswer

        wrapped.__doc__ = what.__doc__
        return wrapped

covercount = {}

class table(object):

        @logger
        def getmaterial(self):
                return self.mat

        @logger
        def __init__(self,material):
                self.mat = material
                print "HELLO!"
        def __str__(self):
                return "A Fancy table type " + self.__class__.__name__
        def __format__(this,fs):
                return this.mat.swapcase()

        @staticmethod
        @logger
        def factory(source):
                bits = source.split(" ")
                if bits[0] == "Circular":
                        rv = circtable(float(bits[2]),bits[1])
                elif bits[0] == "Rectangular":
                        rv = recttable(float(bits[2]),float(bits[3]),bits[1])
                else:
                        rv = None
                return rv

        def getmaxdim(this):
                return int(this.maxdim)
        def setmaxdim(this,nooval):
                print "STOP MESSIN ABOUT"
                this.maxdim = nooval

        largest_size = property(getmaxdim,setmaxdim)

class recttable(table):
        @logger
        def __init__(current,w,h,material):
                super(recttable,current).__init__(material)
                current.w = w
                current.h = h
                current.maxdim = current.h
                if current.h < current.w: current.maxdim = current.w
                current.cached = False
        @logger
        def getseats(current):
                "Work out how many people can eat dinner around the table easily"
                if current.cached: return current.canseat
                elbows = 850
                current.canseat = (int (current.w / elbows) + int(current.h / elbows)) * 2
                current.cached = True
                return current.canseat
        @logger
        def islonglegs(self):
                minlegs = 1100
                if self.w < minlegs or self.h < minlegs:
                        return False
                return True
        @logger
        def __str__(self):
                rv = "Rectangular table " + str(self.w) + " by " + str(self.h)
                return rv

class circtable(table):
        @logger
        def __init__(current,d,material):
                current.mat = material
                current.d = d
                current.maxdim = current.d
        @logger
        def getseats(current):
                "Work out how many people can eat dinner around the table easily"
                elbows = 850
                s = int (current.d * 3.14159265 / elbows)
                return s
        @logger
        def islonglegs(self):
                minlegs = 1100
                if self.d < minlegs:
                        return False
                return True

# -----------------------------------------------------------

if __name__ == "__main__":
        demo = recttable(1000,3000,"wood")
        another = recttable(2000,4500,"plastic")
        arthur = circtable(1900,"glass")

        refline ="Circular timber 1780"

        filetable = table.factory(refline)

        lot = [demo,another,arthur,filetable]

        for tab in lot:
                s1 = tab.getseats()
                s2 = tab.getmaterial()
                if tab.islonglegs():
                        print "Michael can sit at this table"
                else:
                        print "Michael will be scrunched up"

                print "{0.largest_size:6b}".format(tab)

                tab.largest_size = 4444
                tops = tab.largest_size

                # print s1,s2,tab,tops
                print "%3d %12s %30s %6d" % (s1,s2,tab,tops)
                print "{:3d} {:12s} {:30s} {:6d}".format(s1,s2,tab,tops)
                print "{0:3d} {0:3x} {2:^12s} {1:30s} {3:6d}".format(s1,tab,s2,tops)
                print "{} !".format(tab)

        print covercount
        print covercount["//getmaterial"]