""" item.py

@author Brent Newey
@created 2009.12.29 11:30:49
@modified 2010.01.23 08:56:50

<description>
"""
import locale
import operator

import dice
import common
import db

class Size():
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '' if self.name == 'medium' else self.name

class Item():
    def __init__(self, name, count, plural=None, prefix=None,
                 plural_prefix=None, str_bonus=None, unit=None,
                 size=Size('medium'), bonus=None, masterwork=False,
                 base_cost=0, display_cost=False, disparate_costs=(),
                 specials=None, parentheticals=None):
        self.name = name
        self.plural = plural or name
        self.count = count
        self.prefix = prefix
        self.plural_prefix = plural_prefix
        self.str_bonus = str_bonus
        self.unit = unit
        self.size = size
        self.bonus = bonus
        self.masterwork = masterwork
        self.base_cost = 0
        self.display_cost = display_cost
        self.disparate_costs = disparate_costs
        self.specials = specials or []
        self.parentheticals = parentheticals or []

    def __repr__(self):
        if self.count > 1:
            prefix = self.sizestr('plural_prefix') if self.plural_prefix else ''
            prefix = prefix.strip()
            strsum = locale.format('%d', self.count, 1)
            return '%s%s%s%s%s%s' % ('%s ' % strsum,
                                     self.unitstr(),
                                     common.joinordie('%s ', prefix),
                                     self.masterstr(),
                                     self.plural,
                                     self.strstr())
        else:
            prefix = self.sizestr() if self.prefix else ''
            prefix = prefix.strip()
            if prefix == 'an' and self.masterstr():
                prefix = 'a'
            return '%s%s%s%s%s' % (self.unitstr(),
                                   common.joinordie('%s ', prefix),
                                   self.masterstr(),
                                   self.name,
                                   self.strstr())

    def strstr(self):
        inparens = []
        if self.str_bonus:
            inparens += ['+%d Str bonus' % self.str_bonus]
        inparens += self.parentheticals
        if inparens:
            return ' (' + ', '.join(inparens) + ')'
        else:
            return ''

    def unitstr(self):
        return '%s of ' % self.unit if self.unit else ''

    def sizestr(self, type='prefix'):
        prefix = getattr(self, type)
        replacestr = self.size.__repr__()
        if prefix != '[size]' and replacestr != '':
            replacestr += ' '
        return prefix.replace('[size]', replacestr)

    def masterstr(self):
        if self.bonus:
            bstr = '+%d ' % self.bonus
            if self.specials:
                bstr += ' '.join(self.specials) + ' '
            return bstr
        elif self.masterwork:
            return 'masterwork '
        else:
            return ''

    @staticmethod
    def totalitem(count):
        item = count['item']
        totalcount = ((item['dice_number'] if 'dice_number' in item else 1) *
                      count['count'])
        if 'dice_sides' in item:
            count['total'] = dice.rolldice(item['dice_sides'], totalcount)
        else:
            count['total'] = totalcount

    @staticmethod
    def itemdie(item, die):
        item['item'][die] if die in item['item'] else None

    @staticmethod
    def converthashcount(h):
        size = Size((h['item']['size']['name']) if 'size' in h['item'] else
                    'medium')
        return Item(h['item']['name'], h['count'],
                    plural=h['item']['plural'],
                    prefix=h['item']['prefix'],
                    plural_prefix=h['item']['plural_prefix'],
                    str_bonus=Item.itemdie(h, 'str_bonus'),
                    unit=Item.itemdie(h, 'unit'), size=size,
                    bonus=Item.itemdie(h, 'bonus'),
                    masterwork=Item.itemdie(h, 'masterwork'))

    @classmethod
    def generatedefault(cls, name):
        return lambda c: [cls(name, c, plural=name + 's', prefix='a')]

    @staticmethod
    def generate(query):
        def generator(total):
            itemcounts = db.xraw(total, operator.itemgetter('id'), query())
            for i in itemcounts.values():
                Item.totalitem(i)
            return map(Item.converthashcount, itemcounts.values())
        return generator

    @classmethod
    def byrow(cls, itemrow):
        return cls(itemrow['name'], 1,
                   plural=itemrow['plural'],
                   prefix=itemrow['prefix'],
                   plural_prefix=itemrow['plural_prefix'])

    @staticmethod
    def mergeitems(itemiter):
        itemlist = tuple(itemiter)
        hashes = set(i.hashitem() for i in itemlist)
        hashcounts = dict((h, sum(i.count for i in itemlist if
                                  i.hashitem() == h)) for
                          h in hashes)
        newitemlist = []
        for k, v in hashcounts.iteritems():
            newitem = (i for i in itemlist if i.hashitem() == k).next()
            newitem.count = v
            newitemlist.append(newitem)
        return newitemlist

class Money(Item):
    def __init__(self, name, count):
        Item.__init__(self, name, count)

    @staticmethod
    def generate(name):
        return lambda c: [Money(name, c)]