import util

class Record(object):
    # assume: first field is pk
    fields = ['id']
    
    def __init__(self, *args):
        if len(args) != len(self.fields):
            raise TypeError, "%s() takes exactly %d arguments (%d given)" % (self.__class__.__name__, len(self.fields), len(args))
        for (field, arg) in zip(self.fields, args):
            self.__dict__[field] = arg
    
    def __repr__(self):
        return "<%s %s>" % (self.__class__.__name__, repr(self.__dict__[self.fields[0]]))
    
    def serialize(self):
        data = []
        for field in self.fields:
            data.append(self.__dict__[field])
        return util.serialize(data)
    
    @classmethod
    def unserialize(cls, data):
        return cls(*util.unserialize(data))

class IRCUser(Record):
    fields = ['username', 'netid', 'password']

class NetID(Record):
    fields = ['netid', 'namesallowed', 'names']
    
    def __init__(self, *args):
        print args
        super(NetID, self).__init__(*args)
        self.namesallowed = int(self.namesallowed)
        if self.names:
            self.names = self.names.split(',')
        else:
            self.names = []
    
    def serialize(self):
        names = self.names
        namesallowed = self.namesallowed
        self.names = ','.join(names)
        self.namesallowed = str(namesallowed)
        retval = super(NetID, self).serialize()
        self.names = names
        self.namesallowed = namesallowed
        return retval
        
class Store(object):
    def __init__(self, cls, filename=None):
        if filename is None:
            filename = "%ss.dat" % cls.__name__
        self.filename = filename
        self.cls = cls
        self.read()
    
    def read(self):
        self.records = {}
        try:
            fd = open(self.filename, 'r')
        except IOError, e:
            return
        for line in fd:
            line = line.strip()
            if not line:
                continue
            item = self.cls.unserialize(line)
            pk = item.__dict__[item.fields[0]]
            self.records[pk] = item
        fd.close()
    
    def __iter__(self):
        return self.records.itervalues()
    
    def save(self):
        fd = open(self.filename, 'w')
        for record in self.records.itervalues():
            fd.write("%s\n" % record.serialize())
        fd.close()
    
    def __getitem__(self, key):
        return self.records[key]
    
    def __setitem__(self, key, val):
        self.update(val)
    
    def __delitem__(self, key):
        del self.records[key]
    
    def __contains__(self, key):
        return (key in self.records)
    
    def update(self, record):
        assert type(record) == self.cls, "Can only store objects of type %s" % self.cls.__name__
        pk = record.__dict__[record.fields[0]]
        self.records[pk] = record
    
    append = update