import items
import db
import dice

class Armor(items.Item):

    def hashitem(self):
        prefix = ''
        if self.bonus:
            bstr = '+%d ' % self.bonus
            if self.specials:
                bstr += ' '.join(self.specials) + ' '
            prefix += bstr
        elif self.masterwork:
            prefix += 'masterwork '
        return prefix + self.size.name + ' ' + self.name

    @staticmethod
    def mundanesubtable(sizerows, masterwork, shield=False, stype=None):
        def generator(a):
            if shield:
                shieldrows = db.typeqry('%s_shields' % stype)
                shieldroll = dice.tableroll(shieldrows)
                armor_id = shieldroll['armor_id']
            else:
                armor_id = a['item']['lookup_id']
            armor = Armor.byid(armor_id)
            armor.size = items.Size(dice.tableroll(sizerows)['name'])
            armor.masterwork = masterwork
            return armor
        return generator

    @staticmethod
    def byid(armorid):
        return Armor.byrow(db.armorqry(armorid))

    @staticmethod
    def minorsubtable(sizerows):
        lookups = {'armor': 'armor', 'shields': 'shield',
                   'specific_armor': 'specific armor',
                   'specific_shields': 'specific shield',
                   'special': 'special ability armor'}
        def generator(a, specials=0):
            if a['item']['lookup_type'] in ('armor', 'shields'):
                types = db.typeqry('random_%s' % a['item']['lookup_type'])
                armorid = dice.tableroll(types)['armor_id']
                armor = Armor.byid(armorid)
                armor.size = items.Size(dice.tableroll(sizerows)['name'])
                armor.bonus = a['item']['bonus']
                speciallist = []
                for _ in range(specials):
                    l = lookups[a['item']['lookup_type']]
                    roll = dice.tableroll(db.typeqry(l + '_special_abilities',
                                                     filter="power = 'minor'"))
                    #roll again
                    speciallist.append(roll['name'])
                #merge types
                armor.specials = speciallist

                return armor
            elif a['item']['lookup_type'] in ('specific_armor',
                                              'specific_shields'):
                roll = dice.tableroll(db.typeqry(a['item']['lookup_type'],
                                                 filter="power = 'minor'"))
                armor = Armor.byrow(roll)
                if roll['name'] == "caster's shield":
                    if dice.d100() <= 50:
                        if dice.d100() <= 80:
                            #scroll
                            armor.parentheticals.append('medium divine spell')
                        else:
                            #scroll
                            armor.parentheticals.append('medium arcane spell')
                    else:
                        armor.parentheticals.append('blank')
                return armor
                    
            else:
                armor = db.xtypes('magic_armor', 1, filter="power = 'minor'")
                return generator(armor.values()[0], specials + 1)
        return generator

    @staticmethod
    def mundane():
        def generator(count):
            sizerows = db.typeqry('armor_sizes')
            armor = db.xtypes('mundane_armor', count)

            params = {'armor': (sizerows, False),
                      'masterwork armor': (sizerows, True),
                      'darkwood shield': (sizerows, False, True, 'darkwood'),
                      'masterwork shield': (sizerows, True, True,
                                            'masterwork')}

            subarmors = dict((k, Armor.mundanesubtable(*v)) for k, v in
                             params.iteritems())
            armorlist = (subarmors[v['item']['lookup_type']](v) for
                         v in armor.values() for _ in range(v['count']))
            return items.Item.mergeitems(armorlist)
        return generator

    @staticmethod
    def minor():
        def generator(count):
            sizerows = db.typeqry('armor_sizes')
            armor = db.xtypes('magic_armor', count, filter="power = 'minor'")
            armorlist = (Armor.minorsubtable(sizerows)(v) for
                         v in armor.values() for _ in range(v['count']))
            return items.Item.mergeitems(armorlist)
        return generator