# -*- coding: utf-8 -*-
import os
import re
import sys
import json
import time
import uuid
import urllib
import urllib2
import mimetypes
from CaptchaDialog import CaptchaDialog

class VKError(Exception):
    pass

class VKValidationError(VKError):
    pass

class VKCaptchaError(VKError):
    pass

class VKAuthError(VKError):
    def __init__(self, t, d):
        super(VKAuthError, self).__init__("%s: %s" % (t, d))
        self.type=t

class VKApiError(VKError):
    def __init__(self, c, d):
        super(VKApiError, self).__init__("[%s] %s" % (c, d))
        self.code=c

DEFAULT_USER_AGENT='VKClient +https://github.com/...'

class VKClient(object):
    def __init__(self, access_token=None, user_id=None,
        expires=None, api_version=5.25, lang=None, default_delay=0,
        user_agent=DEFAULT_USER_AGENT):
        self.access_token=access_token
        self.user_id=user_id
        self.expires=expires
        self.api_version=api_version
        self.lang=lang
        self.default_delay=default_delay
        self.user_agent=user_agent

    def login(self, username, password, client_id=3140623,
        client_secret='VeWdmVclDCtn6ihuP1nt', scope=None):
        u"Прямая авторизация."
        params={
            'username': username,
            'password': password,
            'client_id': client_id,
            'client_secret': client_secret,
            'scope': scope,
            'grant_type': 'password',
            # 'test_redirect_uri': 1,
        }
        self.auth('token', params)

    def api(self, method, params={}, delay=None):
        u"""Вызывает метод API Вконтакте."""
        params=dict(params)
        if not 'access_token' in params and self.access_token:
            params['access_token']=self.access_token
        if not 'lang' in params and self.lang:
            params['lang']=self.lang
        if not 'v' in params:
            params['v']=self.api_version
        return self.raw_api(method, params, delay)

    def auth(self, action, params):
        url='https://oauth.vk.com/' + action
        r=self.post(url, params)
        if 'error' in r:
            if 'need_validation' == r['error']:
                self.validate(r['redirect_uri'])
            elif 'need_captcha' == r['error']:
                self.captcha_params(params, r['captcha_img'], r['captcha_sid'])
            else:
                raise VKAuthError(r['error'], r['error_description'])
            return self.auth(action, params)
        self.access_token = r['access_token']
        self.user_id = r.get('user_id')
        if r['expires_in']:
            self.expires = r['expires_in'] + time.time()

    def raw_api(self, method, params={}, delay=None):
        if delay != None and self.default_delay > 0:
            time.sleep(delay)
        url='https://api.vk.com/method/' + method
        r=self.post(url, params)
        if 'response' in r:
            return r['response']
        error=r['error']
        if error['error_code'] == 14:
            self.captcha_params(params, error['captcha_img'], error['captcha_sid'])
        elif error['error_code'] == 17:
            self.validate(error['redirect_uri'])
        else:
            raise VKApiError(error['error_code'], error['error_msg'])
        self.raw_api(method, params)

    def post(self, url, params):
        params=self.build_params(params)
        headers={'Content-Type': 'application/x-www-form-urlencoded'}
        return self.get_json(url, params, headers)

    def upload(self, url, files):
        u"""Загружает файлы."""
        lines=[]
        boundary=uuid.uuid4().hex
        content_type='application/octet-stream'
        for k, v in files.items():
            if re.match('(?i)https?://', v, re.I):
                r=self.fetch(v)
                content_type=r.headers.get('content-type', content_type)
                data=r.read()
            else:
                f=open(v, 'rb')
                data=f.read()
                f.close()
                ending=os.path.splitext(v)[1]
                content_type=mimetypes.types_map.get(ending, content_type)
                v=v.encode(sys.getfilesystemencoding())
            lines.extend([
                '--' + boundary,
                'Content-Disposition: form-data; name="' + k +\
                '"; filename="' + os.path.basename(v) + '"',
                'Content-Type: ' + content_type,
                '',
                data
            ])
        lines.extend([
            '--' + boundary + '--',
            ''
        ])
        data='\r\n'.join(lines)
        headers={'Content-Type': 'multipart/form-data; boundary=' + boundary}
        return self.exec_url(url, data, headers)

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

    def upload_file(self, url, filename):
        return self.upload(url, {'file': filename})

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

    def upload_photos(self, photo_list, album_id, group_id=None, delay=None):
        u"""Грузим фотографии в альбом."""
        u=self.api('photos.getUploadServer', dict(
            album_id=album_id,
            group_id=group_id
        ), delay)['upload_url']
        ret=[]
        for i in range(0, len(photo_list), 5):
            L=photo_list[i:i + 5]
            r=self.upload_files(u, L)
            # недоработка у разработчиков API
            r['album_id']=r.pop('aid')
            ret += self.api('photos.save', r, delay)
        return ret

    # 0 - себе на стену
    def upload_wall_photo(self, filename, owner_id=0, delay=None):
        u"""Грузим фото на стену."""
        gid=abs(owner_id) if owner_id < 1 else None
        u=self.api('photos.getWallUploadServer', {
            'group_id': gid
        }, delay)['upload_url']
        r=self.upload_photo(u, filename)
        if gid:
            r['group_id']=gid
        elif owner_id:
            r['user_id']=owner_id
        return self.api('photos.saveWallPhoto', r, delay)

    def upload_owner_photo(self, filename, group_id=0, delay=None):
        u"""Грузим фото на аву."""
        owner_id=None
        if group_id:
            owner_id=-group_id
        u=self.api('photos.getOwnerPhotoUploadServer', {
            'owner_id': owner_id
        }, delay)['upload_url']
        r=self.upload_photo(u, filename)
        return self.api('photos.saveOwnerPhoto', r)

    def upload_message_photo(self, filename, delay=None):
        u"""Грузим фото в личное сообщение."""
        u=self.api('photos.getMessagesUploadServer', {}, delay)\
          ['upload_url']
        r=self.upload_photo(u, filename)
        return self.api('photos.saveMessagesPhoto', r, delay)

    def upload_audio(self, filename, title=None, artist=None,\
        delay=None):
        u"""Грузим аудиозапись."""
        u=self.api('audio.getUploadServer', {}, delay)['upload_url']
        r=self.upload_file(u, filename)
        r['title']=title
        r['artist']=artist
        return self.api('audio.save', r, delay)

    def upload_doc(self, filename, group_id=None, delay=None):
        u"""Грузим документ в "Документы"."""
        u=self.api('docs.getUploadServer', {'group_id': group_id}, delay)\
          ['upload_url']
        r=self.upload_file(u, filename)
        return self.api('docs.save', r, delay)

    def upload_wall_doc(self, filename, group_id=None,\
        delay=None):
        u"""Грузим документ на стену."""
        u=self.api('docs.getWallUploadServer', {
            'group_id': group_id
        }, delay)['upload_url']
        r=self.upload_file(u, filename)
        return self.api('docs.save', r, delay)

    def upload_video(self, filename, name=None, description=None,
        is_private=None, wallpost=None, group_id=None, album_id=None,
        repeat=None, delay=None):
        u"""Загружает и сохраняет видеофайл."""
        ret={}
        res=self.api('video.save', dict(
            name=name,
            description=description,
            is_private=is_private,
            wallpost=wallpost,
            group_id=group_id,
            album_id=album_id,
            repeat=repeat
        ), delay)
        ret['video_id']=res['video_id']
        ret['owner_id']=res['owner_id']
        # содержит единственное поле 'size'
        ret['size']=self.upload(res['upload_url'], {
            'video_file': filename
        })['size']
        return ret

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

    def fetch(self, url, data=None, headers={}):
        url=str(url) # bugfix
        _headers={'User-Agent': self.user_agent}
        _headers.update(headers)
        r=urllib2.Request(url, data, _headers)
        try:
            r=urllib2.urlopen(r)
        except urllib2.HTTPError as r:
            pass
        return r

    def get_content(self, url, headers={}):
        return self.fetch(url, None, headers).read()

    def get_json(self, url, data=None, headers={}):
        j=self.fetch(url, data, headers).read()
        try:
            j=json.loads(j)
        except:
            # некоторые методы отдают данные в windows-1251 вместо utf-8
            j=json.loads(j, 'windows-1251')
        return j

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

    def build_params(self, params):
        q={}
        for k, v in params.items():
            if v is None:
                continue
            q[k]=v.encode('utf-8') if type(v) == unicode else v
        return urllib.urlencode(q)

    def get_captcha_key(self, url):
        u"Возвращает значение капчи."
        app=CaptchaDialog(url)
        app.run()
        return app.captcha_code

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

    def validate(self, url):
        u"""
        Осуществляет автоматическую валидацию пользователя при заходе из
        подозрительного места.
        """
        s=self.get_content(url)
        m=re.search(r'/security_check\?[^"]+', s)
        if m:
            u='https://oauth.vk.com' + m.group(0)
            r=self.fetch(u)
            if r.geturl() == 'https://oauth.vk.com/blank.html?success=1':
                return
        raise VKValidationError('Validation failed.')