import os.path
import sgmllib
import model

class dorf1_parser(sgmllib.SGMLParser):
    from htmlentitydefs import entitydefs

    def __init__(self, data):
        self.nbuild = None
        self.storage_kind = None
        self.troop_kind = None

        self.name = '<undefined>'
        self.fields = {model.WOOD: {},
                       model.CLAY: {},
                       model.IRON: {},
                       model.CROP: {}}
        self.troops = {}
        self.production = model.Resources(speed=True)
        self.storage = model.Resources()
        self.capacity = model.Resources()
        
        sgmllib.SGMLParser.__init__(self)
        self.feed(data)

    def start_a(self, attr):
        attrs = dict(attr)
        href = attrs.get('href', None)
        if 'build.php?id=' in href:
            _, nbuild = href.split('id=')
            self.nbuild = int(nbuild)

    def end_a(self):
        self.nbuild = None

    def start_td(self, attrs):
        attrs = dict(attrs)
        id = attrs.get('id', None)
        if id in ('l1', 'l2', 'l3', 'l4'):
            kind = int(id[-1])
            self.production[kind] = int(attrs['title'])
            self.storage_kind = kind

    def end_td(self):
        self.storage_kind = None

    def start_img(self, attr):
        attrs = dict(attr)
        if self.nbuild is not None:
            self._parse_nbuild(attrs)
        # try to see if it's an troop image (only legionnaires so far)
        src = attrs.get('src', '')
        _, filename = os.path.split(src)
        if filename == '1.gif':
            self.troop_kind = model.LEGIONNAIRE
        else:
            self.troop_kind = None

    def _parse_nbuild(self, attrs):
        src = attrs['src']
        _, filename = os.path.split(src)
        assert filename.startswith('r')
        assert filename.endswith('.gif')
        filename = filename[1:-4]
        kind, level = map(int, filename.split('_'))
        self.fields[kind][self.nbuild] = level

    def handle_data(self, data):
        if self.storage_kind is not None:
            current, capacity = map(int, data.split('/'))
            self.storage[self.storage_kind] = current
            self.capacity[self.storage_kind] = capacity
        elif self.troop_kind is not None:
            try:
                num = int(data)
            except ValueError:
                return
            else:
                self.troops[self.troop_kind] = num
                self.troop_kind = None


class dorf2_parser(sgmllib.SGMLParser):
    from htmlentitydefs import entitydefs

    def __init__(self, data):
        self.builds = {} # id --> (kind, level)
        sgmllib.SGMLParser.__init__(self)
        self.feed(data)

    


class build_parser(sgmllib.SGMLParser):
    from htmlentitydefs import entitydefs

    def __init__(self, data):
        self.needed_kind = None
        self.current_kind = None
        self.needed_table = False
        self.production = [None] * 5 # the element with index 0 is simply ignored
        self.available = [None] * 5
        self.needed = [None] * 5
        sgmllib.SGMLParser.__init__(self)
        self.feed(data)

    def calc_maxtime(self, needed=None):
        if needed is None:
            needed = self.needed
        maxtime = 0
        for i in range(1, 5):
            missing = needed[i] - self.available[i]
            if missing > 0:
                time_needed = float(missing)/self.production[i]
                maxtime = max(maxtime, time_needed)
        return int(maxtime * 3600) # hours to seconds

    def start_td(self, attr):
        attrs = dict(attr)
        id = attrs.get('id', None)
        if id in ('l1', 'l2', 'l3', 'l4'):
            kind = int(id[-1])
            self.production[kind] = int(attrs['title'])
            self.current_kind = kind

    def end_td(self):
        self.current_kind = None

    def start_table(self, attr):
        attrs = dict(attr)
        if attrs.get('class', None) == 'f10':
            self.needed_table = True

    def end_table(self):
        self.needed_kind = None
        self.needed_table = False

    def start_img(self, attr):
        if not self.needed_table:
            return
        attrs = dict(attr)
        src = attrs['src']
        _, filename = os.path.split(src)
        assert filename.endswith('.gif')
        filename = filename[:-4]
        if filename in ('1', '2', '3', '4'):
            self.needed_kind = int(filename)

    def handle_data(self, data):
        if self.current_kind is not None:
            avail, maximum = map(int, data.split('/'))
            self.available[self.current_kind] = avail
        elif self.needed_kind is not None:
            data = data.replace('|', '').strip()
            self.needed[self.needed_kind] = int(data)
            self.needed_kind = None