# -*- coding: u8 -*-
################################################################################
#                                                                              #
# @link http://vk.com/... Персональная страница автора Вконтакте.      #
#                                                                              #
# @link https://github.com/err0x0/ Мои репозитории.                            #
#                                                                              #
# Copyright (c) 2014  <[email protected]>                        #
#                                                                              #
# Данная лицензия разрешает лицам, получившим копию данного программного       #
# обеспечения и сопутствующей документации (в дальнейшем именуемыми            #
# «Программное Обеспечение»), безвозмездно использовать Программное            #
# Обеспечение без ограничений, включая неограниченное право на использование,  #
# копирование, изменение, добавление, публикацию, распространение,             #
# сублицензирование и/или продажу копий Программного Обеспечения, также как и  #
# лицам, которым предоставляется данное Программное Обеспечение, при           #
# соблюдении следующих условий:                                                #
#                                                                              #
# Указанное выше уведомление об авторском праве и данные условия должны быть   #
# включены во все копии или значимые части данного Программного Обеспечения.   #
#                                                                              #
# ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО    #
# ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ  #
# ГАРАНТИЯМИ ТОВАРНОЙ ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ  #
# И ОТСУТСТВИЯ НАРУШЕНИЙ ПРАВ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ #
# НЕСУТ ОТВЕТСТВЕННОСТИ ПО ИСКАМ О ВОЗМЕЩЕНИИ УЩЕРБА, УБЫТКОВ ИЛИ ДРУГИХ       #
# ТРЕБОВАНИЙ ПО ДЕЙСТВУЮЩИМ КОНТРАКТАМ, ДЕЛИКТАМ ИЛИ ИНОМУ, ВОЗНИКШИМ ИЗ,      #
# ИМЕЮЩИМ ПРИЧИНОЙ ИЛИ СВЯЗАННЫМ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ ИЛИ ИСПОЛЬЗОВАНИЕМ #
# ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫМИ ДЕЙСТВИЯМИ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.    #
#                                                                              #
################################################################################
import sys
import os
import urllib
import time
import utils
import json
import re
import httplib
import keyword
import captcha

MATCH_PARAM = '_(' + '|'.join(keyword.kwlist) + ')$'

class VKError(Exception):
    pass

class VKValidationError(VKError):
    pass

class VKCaptchaError(VKError):
    pass

class VKAuthorizationError(VKError):
    def __init__(self, error_type, description):
        super(VKAuthorizationError, self).__init__('%s - %s' % (error_type, description))
        self.type = error_type

class VKApiCallError(VKError):
    def __init__(self, code, message):
        super(VKApiCallError, self).__init__('[%s] %s' % (code, message))
        self.code = code

class VKRobot(object):
    def __init__(self, username, password, api_version=5.23, lang=None,
                 delay_time=0, user_agent='VKRobot'):
        self.username = username
        self.password = password
        self.api_version = api_version
        self.lang = lang
        self.delay_time = delay_time
        self.user_agent = user_agent
        # пробуем авторизоваться
        p = {
            'username': username,
            'password': password,
            'client_id': 3140623,
            'client_secret': 'VeWdmVclDCtn6ihuP1nt',
            'grant_type': 'password',
            # 'test_redirect_uri': 1
        }
        while 1:
            u = 'https://oauth.vk.com/token?'  + self._encodeParams(p)
            # print u
            r = self.getJSON(u)
            if not 'error' in r:
                break
            if 'need_validation' == r['error']:
                self.validate(r['redirect_uri'])
            elif 'need_captcha' == r['error']:
                self._setCaptchaParams(p, r['captcha_img'], r['captcha_sid'])
            else:
                raise VKAuthorizationError(r['error'], r['error_description'])
        self.access_token = r['access_token']
        self.user_id = r['user_id']

    def call(self, _method, **params):
        u"""
        Вызывает метод API и в случае удачи возвращает response. Если имя
        параметра совпадает с ключевым словом, то к имени нужно добавить
        подчеркивание, например: _from, _global.
        """
        # print params
        params['access_token'] = self.access_token
        params['v'] = self.api_version
        params['lang'] = self.lang
        u = 'https://api.vk.com/method/' + _method
        for k, v in params.items():
            m = re.match(MATCH_PARAM, k)
            if m:
                params[m.group(1)] = params.pop(k)
        h = {'Content-Type': 'application/x-www-form-urlencoded'}
        while 1:
            d = self._encodeParams(params)
            # print u
            # print params
            r = self.getJSON(u, d, h)
            if 'response' in r:
                return r['response']
            r = r['error']
            if r['error_code'] == 14:
                self._setCaptchaParams(params, r['captcha_img'], r['captcha_sid'])
            elif r['error_code'] == 17:
                self.validate(r['redirect_uri'])
            else:
                raise VKApiCallError(r['error_code'], r['error_msg'])

    def get(self, url, data=None, headers={}):
        u"""
        Возвращает response, либо бросает исключение, если в ответе есть
        поле error.
        """
        r = self.getJSON(url, data, headers)
        if 'error' in r:
            raise VKError(r['error'])
        return r

    def delay(self, sec):
        time.sleep(sec)

    def getJSON(self, url, data=None, headers={}):
        u"""Возвращает результат парсинга JSON."""
        headers['User-Agent'] = self.user_agent
        if self.delay_time:
            self.delay(self.delay_time)
        j = utils.get_page(url, data, headers)
        try:
            j = json.loads(j)
        except:
            # некоторые методы API отдают данные в windows-1251, вместо UTF-8
            j = json.loads(j, '1251')
        return j

    def validate(self, u):
        u"""
        Осуществляет автоматическую валидацию пользователя при заходе из
        подозрительного места.
        """
        s = utils.get_page(u)
        m = re.search(r'/security_check\?[^"]+', s)
        if m:
            u = m.group(0)
            c = httplib.HTTPConnection('oauth.vk.com')
            c.request('GET', u)
            r = c.getresponse()
            h = dict(r.getheaders())
            if h['location'] == '/blank.html?success=1':
                print u'Валидация пройдена.'
                return
        raise VKValidationError('Validation failed.')

    def upload(self, u, files, fields={}):
        u"""Загружает файлы."""
        t, d = utils.encode_formdata(files)
        return self.get(u, d, {'Content-Type': t})

    def uploadPhoto(self, u, p):
        u"""Загружает фото."""
        return self.upload(u, {'photo': p})

    def uploadFile(self, u, p):
        return self.upload(u, {'file': p})

    def uploadFiles(self, u, L):
        u"""Загружает список файлов."""
        a = {}
        for i in range(len(L)):
            a['file%i' % (i + 1)] = L[i]
        return self.upload(u, a)

    def uploadPhotos(self, photo_list, album_id, group_id=None):
        u"""Грузим фотографии в альбом."""
        u = self.photos_getUploadServer(album_id, group_id)['upload_url']
        ret = []
        for i in range(0, len(photo_list), 5):
            photos = photo_list[i : i + 5]
            r = self.uploadFiles(u, photos)
            r['album_id'] = r.pop('aid')
            ret += self.photos_save(**r)
        return ret

    def uploadWallPhoto(self, filename, owner_id=0):
        u"""Грузим фото на стену."""
        group_id = abs(owner_id) if owner_id < 1 else None
        u = self.photos_getWallUploadServer(group_id)['upload_url']
        r = self.uploadPhoto(u, filename)
        if group_id:
            r['group_id'] = group_id
        elif owner_id:
            r['user_id'] = owner_id
        return self.photos_saveWallPhoto(**r)

    def uploadOwnerPhoto(self, filename, group_id=0):
        u"""Грузим фото на аву."""
        owner_id = None
        if group_id:
            owner_id = -group_id
        u = self.photos_getOwnerPhotoUploadServer(owner_id)['upload_url']
        r = self.uploadPhoto(u, filename)
        return self.photos_saveOwnerPhoto(**r)

    def uploadMessagePhoto(self, filename):
        u"""Грузим фото в личное сообщение."""
        u = self.photos_getMessagesUploadServer()['upload_url']
        r = self.uploadPhoto(u, filename)
        return self.photos_saveMessagesPhoto(**r)

    def uploadAudio(self, filename, title=None, artist=None):
        u"""Грузим аудио-запись."""
        u = self.audio_getUploadServer()['upload_url']
        r = self.uploadFile(u, filename)
        r['title'] = title
        r['artist'] = artist
        ret = self.audio_save(**r)

    def uploadDoc(self, filename, group_id=None):
        u"""Грузим документ в 'Документы'."""
        u = self.docs_getUploadServer(group_id)['upload_url']
        r = self.uploadFile(u, filename)
        return self.docs_save(**r)

    def uploadWallDoc(self, filename, group_id=None):
        u"""Грузим документ на стену."""
        u = self.docs_getWallUploadServer(group_id)['upload_url']
        r = self.uploadFile(u, filename)
        return self.docs_save(**r)

    def uploadVideo(self, filename, name=None, description=None,
                    is_private=None, wallpost=None, group_id=None,
                    album_id=None, repeat=None):
        u"""Загружает и сохраняет видеофайл."""
        r = self.video_save(name, description, is_private, wallpost,
                            link, group_id, album_id, repeat)
        u = r['upload_url']
        # содержит единственное поле 'size'
        r1 = self.upload(u, {'video_file': filename})
        r.update(r1)
        return r

    def importVideo(self, url, name=None, description=None,
                    is_private=None, wallpost=None, group_id=None,
                    album_id=None, repeat=None):
        u"""Импортуриует видео с популярных видеохостингов типа YouTube."""
        u = self.video_save(name, description, is_private, wallpost,
                            url, group_id, album_id, repeat)['upload_url']
        return self.get(u)

    def atach(self, o, t='', id_key='id'):
        p = t + '{owner_id}_{' + id_key + '}'
        return (','.join([p.format(**x) for x in o])\
                if type(o) == list\
                else p.format(**o)) + ','

    def getCaptchaKey(self, url):
        u"""Возвращает значение капчи."""
        return captcha.render_captcha(url, os.path.basename(sys.argv[0]))
        raise VKCaptchaError('Captcha needed.')

    def _setCaptchaParams(self, params, url, sid):
        u"""Добавляет парамерты капчи."""
        params['captcha_sid'] = sid
        params['captcha_key'] = self.getCaptchaKey(url)

    def _encodeParams(self, params):
        u"""Формирует строку параметров."""
        # params = dict(params)
        for k, v in params.items():
            if v == None:
                del params[k]
                continue
            # if type(v) == str:
            #     v = v.decode(sys.stdin.encoding)
            if type(v) == unicode:
                v = v.encode('u8')
            params[k] = v
        return urllib.urlencode(params)

    def _smartCall(self, method, params):
        del params['self']
        return self.call(method, **params)

#################### GENERATED CODE GOES AFTER THIS LINE #####################

    def users_get(self, user_ids=None, fields=None, name_case=None):
        """
        http://vk.com/dev/users.get
        Возвращает расширенную информацию о пользователях.
        Аргументы:
        user_ids
            перечисленные через запятую идентификаторы пользователей или их
            короткие имена (screen_name). По умолчанию — идентификатор
            текущего пользователя.
            список строк, разделенных через запятую, количество элементов
            должно составлять не более 1000
        fields
            список дополнительных полей, которые необходимо вернуть.
            Доступные значения: sex, bdate, city, country, photo_50,
            photo_100, photo_200_orig, photo_200, photo_400_orig, photo_max,
            photo_max_orig, online, online_mobile, lists, domain, has_mobile,
            contacts, connections, site, education, universities, schools,
            can_post, can_see_all_posts, can_see_audio,
            can_write_private_message, status, last_seen, common_count,
            relation, relatives, counters, screen_name, maiden_name, timezone,
            occupation
            список строк, разделенных через запятую
        name_case
            падеж для склонения имени и фамилии пользователя. Возможные
            значения: именительный – nom, родительный – gen, дательный – dat,
            винительный – acc, творительный – ins, предложный – abl. По
            умолчанию nom.
            строка
        После успешного выполнения возвращает массив объектов пользователей
        http://vk.com/dev/fields.
        """
        return self._smartCall('users.get', locals())

# ...