"""
* ufw.io.server
* ufw library
provides:
    classmodule io.server
"""

import os
import time
from select import select
from ufw.errors import *
from ufw.io.stream import *
from ufw.core.object import *

__all__ = ["server"]

class server (object):
    max_children = 50
    fork = True
    async = True
    def __init__(self, path=None, h=None):
        super(server, self).__init__()
        self.fork = self.fork and fork
        if not h: h = self.handler
        if not path: path = getattr(self, "address", None)
        if not path: raise ValueError ("default address not set")
        self.hcls = h
        self.workers = []
        self.running = True
        self.io = stream(path)
        assert self.io.flags["server"]
        self.set_signals("connected", "start")
        self.start.connect(self.run)
        self.connected.connect(self.hcls)
    def run(self, pint=0.5, *oa, **ok):
        fork = ok.pop("fork", self.fork)
        async = ok.pop("async", self.async)
        ok["server"] = True
        self.io.open(*oa, **ok)
        while self.running:
            try:
                conn, addr = self.io.listen(pint)
                if not conn: continue
                io = stream("sock:").open(conn)
            except KeyboardInterrupt:
                break
            if fork:
                while len(self.workers) > self.max_children:
                    time.sleep(0.1)
            self.connected(
                self, io, addr,
                async=async, daemon=True, fork=fork
            )
        self.shutdown()
    def shutdown(self):
        if not self.running or self.fork: return
        self.running = False
        while self.workers:
            h = self.workers.pop(0)
            h.shutdown()
        self.io.close()
    class handler (object):
        def __init__(self, server, io, addr, daemon=True):
            object.__init__(self)
            self.server = server
            self.server.workers.append(self)
            self.stream = io
            self.client = addr
            self.handle()
            self.shutdown()
        def handle(self): pass
        def shutdown(self):
            if self in self.server.workers:
                self.server.workers.remove(self)
            try: self.stream.close()
            except io_closed: pass