from twisted.python import log

from ConfigParser import ConfigParser
import signal
from functools import partial

from validate import vInteger
from error import NeededOption 

class MyConfigParser(ConfigParser):
    def __init__(self):
        ConfigParser.__init__(self)
        self.reloadList=[]

    def read(self,files):
        from offer import getProvider
        r = ConfigParser.read(self, files)
        for s in self.sections():
            if s == "main":
                main.validate(self.items(s))
            else:
                getProvider("tmp", self.get(s,'typ'), self.items(s))
        return r

    def reload_(self):
        for f in self.reloadList:
            f()

    def registerReload(self, func):
        self.reloadList.append(func)

class Option():
    def __init__(self, validate, long="", help="", must=False, default=None):
        self.validate = validate
        self.long=long
        self.help = help
        self.must = must
        self.default = default

class Config:
    def __init__(self, name):
        self.name = name
        self.options={
            "port":Option(partial(vInteger,minv=0),long="Port under that twisted is running",must=True),
            "dburl":Option(lambda x,y:x,long="Connection URL to database",must=True),
        }
        self.order = ["dburl","port"]
        self._init = True


    def _read(self, cfg, write=False):
        c = dict(cfg)

        for o in self.options:
            option = self.options[o]
            try:
                value = option.validate(c[o],o)
                if write:
                    self._init = False
                    setattr(self,o,value)
            except KeyError:
                if option.must:
                    raise NeededOption(self.name, o)
                elif write and option.default is not None:
                    setattr(self, o, option.default)

    def validate(self, cfg):
        self._read(cfg, False)

    def load(self, cfg):
        self._read(cfg, True)

    def same(self, other):
        for o in self.options:
            if getattr(self,o) != getattr(other,o):
                return False
        else:
            return True

    def sampleConf(self):
        ret=[]
        for o in self.order:
            opt=self.options[o]
            if opt.long:
                ret.append("# "+opt.long)
            if opt.must:
                s= "%s = "%o
                if opt.default is not None:
                    s += str(opt.default)
                ret.append(s)
            else:
                ret.append("# %s = %s"%(o,opt.default))
            ret.append("")

        return ["[%s]"%self.name,]+ret

def readConfig():
    log.msg("Reading configs.")
    configParser.read(confFiles)
    configParser.reload_()
    if main._init:
        main.load(configParser.items("main"))
    else:
        m = Config("main")
        m.load(configParser.items("main"))
        if not main.same(m):
            raise Exception("Main options can't be reloaded, please restart your Application.")

def init():
    configParser.read(confFiles)
    main.load(configParser.items("main"))

def registerSignal():
    '''register readConfig to SIGUSR2'''
    def rC(signal, frame):
        readConfig()

    signal.signal(signal.SIGUSR2,rC)

configParser = MyConfigParser()
confFiles=["iro.conf", "~/iro.conf","/etc/iro/iro.conf"]

main = Config("main")