streetmobster - fonts 1

from __future__ import unicode_literals

import json
import sys
from random import randint
from requests import Session
from bs4 import BeautifulSoup
import logging

from .Inventory import Item
from .Map import MapAction, MapStreet


if sys.version_info >= (3, 0):
    from urllib.parse import urljoin
    ustr = str
else:
    from urlparse import urljoin
    ustr = unicode


class LoginError(Exception):
    pass


class StreetMobster(object):
    def __init__(self, login, pw='', proxies=None, useragent=None):
        logger = logging.getLogger('StreetMobster.{}'.format(login))
        self.logger = logger

        self.login = login
        self.__pw = pw
        self.load_page_hooks = []

        sess = Session()
        if proxies is not None:
            sess.proxies = proxies
        if useragent is not None:
            sess.headers.update({'User-agent': useragent})

        login_page = sess.get('http://streetmobster.com')
        dom_login_page = BeautifulSoup(login_page.text, "html.parser")
        form_el = dom_login_page.find('form')
        form = dict([(lambda i: (i['name'], i['value']))(x) for x in form_el.find_all('input')])
        form['login[usr]'] = login
        form['login[pwd]'] = pw
        after_login_page = sess.post(urljoin('http://streetmobster.com', form_el['action']), form)
        dom_after_login_page = BeautifulSoup(after_login_page.text, "html.parser")
        if dom_after_login_page.find(class_="mm-street") is None:
            merr = dom_after_login_page.find(class_="merr")
            if merr is None:
                raise LoginError()
            else:
                raise LoginError(merr.text)
        self.sess = sess
        self.last_dom = dom_after_login_page
        self.last_url = 'http://streetmobster.com/auth/login'

        def log_messages_hook(sm, pg):
            log = sm.logger.getChild('Messages')
            for i in pg(class_=['minfo', 'zinfo']):
                log.info(i.text)
            for i in pg(class_='merr'):
                log.error(i.text)

        self.register_page_load_hook(log_messages_hook)
        self.load_page('map?_lng=en')

    def register_page_load_hook(self, hook):
        assert callable(hook)
        self.load_page_hooks.append(hook)

    def unregister_page_load_hook(self, hook):
        if hook in self.load_page_hooks:
            self.load_page_hooks.remove(hook)
            return True
        else:
            return False

    def logout(self):
        self.load_page('auth/exit')

    @property
    def req_pair(self):
        return ustr(self.last_dom).split("req_pair: 'z=")[1].split("'")[0]

    def load_page(self, addr, post=False):
        addr = urljoin('http://streetmobster.com', addr)
        self.sess.cookies['clickcoords'] = ustr(randint(0, 1200)*10000 + randint(0, 1600))
        if isinstance(post, dict):
            pdata = {'z': self.req_pair}
            pdata.update(post)
            data = self.sess.post(addr, pdata, headers={'Referer': self.last_url}).text
        else:
            data = self.sess.get(addr + ('&' if '?' in addr else '?') + 'z={}'.format(self.req_pair), headers={'Referer': self.last_url}).text
        pg = BeautifulSoup(data, "html.parser")
        self.last_dom = pg
        self.last_url = addr
        for i in self.load_page_hooks:
            i(self, pg)
        return pg

    @property
    def level(self):
        return int(self.last_dom.find(class_='exp-level').text)

    @property
    def risk(self):
        return int(self.last_dom.find(class_='p-risk').parent.text)

    @property
    def stamina(self):
        return int(self.last_dom.find(class_='p-stamina').parent.text)

    @property
    def money(self):
        return int(self.last_dom.find(class_='ucash').findChild().text.replace(u'\xa0', ''))

    @property
    def in_jail(self):
        user_cls = self.last_dom.find(class_='user-box')['class']
        return 'u-jl' in user_cls or 'fu-jl' in user_cls

    @property
    def in_riot(self):
        if not self.in_jail:
            return False
        pg = self.load_page('jail')
        return pg.find(class_="jail_riot_1") is not None

    def find_bar(self, item, price):
        pass

    def go_bar(self):
        # url = self.last_dom.find(class_='p-stamina').parent['href'].split('?')[0]
        # if 'top10' in url:
            # url = self.load_page(url).find(class_='body')('td')[1].next['href'].split('?')[0]
            # url = 'http://streetmobster.com/bar//78672'
        url = '/bar//734/'
        self.load_page(url)

    # 505 = whiskey
    def use_in_bar(self, type_id):
        type_id = ustr(type_id)

        def find(x):
            try:
                return json.loads(x)['type_id'] == type_id
            except (ValueError, TypeError):
                return False

        item = self.last_dom.find(rel=find).parent
        assert item
        pg = self.load_page(item['href'].split('?')[0])
        assert pg.find(class_='minfo') is not None

    def need_stamina(self, stamina, load_back=True):
        if self.stamina <= stamina:
            back = self.last_url
            self.go_bar()
            while self.stamina <= stamina:
                self.use_in_bar(505)
            if load_back:
                self.load_page(back)
        return True

    def do_map_action(self, action):
        assert isinstance(action, MapAction)
        assert action.stamina <= self.stamina
        pg = self.load_page(action.url)
        assert pg.find(class_='zinfo') is not None

    @property
    def riot_required(self):
        pg = self.load_page('jail/chat')
        return int(list(pg.find(class_='layout').findChild().children)[4].findChild().text) if len(list(pg.find(class_='layout').findChild().children)) == 5 else -1

    def join_riot(self):
        if not self.in_jail or self.in_riot:
            return False
        pg = self.load_page('jail')
        pg = self.load_page(pg.find(class_="jail_riot_0")['href'].split('?')[0])

        if pg.find(class_='merr', text=lambda x: "You are too late." == x):
            return self.join_riot()

        return bool(pg.find(class_='minfo', text=lambda x: "You're in!" == x) or pg.find(class_='minfo', text=lambda x: "rebel" in ustr(x)))

    def go_jail(self):
        actions = (("sign3", "kick"), ("bmw", "sell"), ("dealer", "rob"), ("robbery", "kick"), ("ambulance", "rob"),
                   ("phone", "crash"), ("dealer", "beat"), ("bmw", "crash2"), ("pimp", "rob"), ("ambulance", "crash"),
                   ("robbery", "rob"), ("family", "thief"), ("bmw", "crash"), ("bicyclist", "rob"))

        def bribe_hook(sm, pg):
            if pg.find(class_="escape") is not None:
                sm.load_page('cop/bribe', {"cop[escape]": sm.last_dom.find(class_="escape")['value']})

        self.register_page_load_hook(bribe_hook)

        for a in actions:
            if 'city' not in self.last_url:
                self.load_page('city')
            if self.in_jail:
                break
            map_ = MapStreet.from_dom(self.last_dom)
            spot = map_.get_spot(a[0])
            if spot is None:
                continue
            action = spot.get_action(a[1])
            if action is None:
                continue
            self.need_stamina(action.stamina + 10)
            self.do_map_action(action)

        self.unregister_page_load_hook(bribe_hook)

    def go_riot(self):
        if not self.in_jail:
            self.go_jail()
        return self.join_riot()