from .ui_auth import Ui_Auth
from PyQt5.QtCore import Qt, QUrl
from PyQt5.QtGui import QImage, QPixmap
from PyQt5.QtWebKitWidgets import QWebView
from PyQt5.QtWidgets import QDialog
import logging
import time
import urllib.parse


AUTH_URL = "https://oauth.vk.com"


class DirectAuth(QDialog):
    def __init__(self, client):
        super(QDialog, self).__init__()
        self.client = client
        self.logger = logging.getLogger('.'.join([
            __name__, self.__class__.__name__]))
        self.captcha_img = None
        self.captcha_sid = None
        self.ui = Ui_Auth()
        self.ui.setupUi(self)
        # self.setWindowModality(Qt.NonModal)
        self.hide_error()
        self.hide_captcha()
        self.connect_slots()

    def connect_slots(self):
        # Убираем пробелы у значений полей
        """self.ui.username_line.editingFinished.connect(
            lambda: self.ui.username_line.setText(
                self.ui.username_line.text().strip()))
        self.ui.password_line.editingFinished.connect(
            lambda: self.ui.password_line.setText(
                self.ui.password_line.text().strip()))
        self.ui.captcha_line.editingFinished.connect(
            lambda: self.ui.captcha_line.setText(
                self.ui.captcha_line.text().strip()))"""
        self.ui.refresh_captcha_button.clicked.connect(self.load_captcha)
        self.ui.login_button.clicked.connect(self.login)

    def login(self):
        username = self.ui.username_line.text()
        if not username:
            self.ui.username_line.setFocus()
            self.show_error('Username required')
            return
        password = self.ui.password_line.text()
        if not password:
            self.ui.password_line.setFocus()
            self.show_error('Password required')
            return
        params = {
            'username': username,
            'password': password,
            'grant_type': 'password',
            'v': self.client.api_version,
            'client_id': self.client.client_id,
            'client_secret': self.client.client_secret,
            'test_redirect_uri': 1,
        }
        if self.client.scope:
            params['scope'] = self.client.scope
        if self.ui.captcha_frame.isVisible():
            params['captcha_sid'] = self.captcha_sid
            params['captcha_key'] = self.ui.captcha_line.text()
        response = self.client.get(
            urllib.parse.urljoin(AUTH_URL, 'token'), params)
        if 'captcha_sid' in response:
            self.captcha_img = response.captcha_img
            self.captcha_sid = response.captcha_sid
            self.show_error('Captcha required')
            self.show_captcha()
            return
        if 'redirect_uri' in response:
            print(self.client.qapp)
            w = BrowserAuth(self.client, response.redirect_uri)
            # w.exec_()
            w.show()
            # self.client.qapp.exec_()
            """
            try:
                self.client.qapp.exec_()
            except AuthError:
                self.reject()
            if self.client.access_token:
                self.accept()
            self.reject()"""
            return
        if 'error' in response:
            self.logger.warning("Error response: %s", response)
            self.ui.password_line.clear()
            self.ui.username_line.setFocus()
            self.ui.username_line.selectAll()
            self.show_error(
                response.get('error_description') or response.error)
            self.hide_captcha()
            return
        self.client.access_token = response.access_token
        self.client.user_id = response.user_id
        self.client.secret_token = response.get('secret')
        self.client.token_expiry = response.expires_in
        if self.client.token_expiry:
            self.client.token_expiry += time.time()
        self.logger.info('Authentication successful')
        self.accept()

    def hide_error(self):
        self.ui.error_label.hide()

    def show_error(self, message):
        self.ui.error_label.setText(self.tr(message))
        self.ui.error_label.show()

    def hide_captcha(self):
        self.ui.captcha_frame.hide()

    def show_captcha(self):
        self.load_captcha()
        self.ui.captcha_frame.show()

    def load_captcha(self):
        data = self.client.http.get(self.captcha_img).content
        pix = QPixmap.fromImage(QImage.fromData(data))
        self.ui.captcha_image.setPixmap(pix)
        self.ui.captcha_line.clear()
        self.ui.captcha_line.setFocus()


class BrowserAuth(QWebView):
    def __init__(self, client, url, parent=None):
        self.client = client
        self.url = url
        super(QWebView, self).__init__(parent)
        self.setUrl(QUrl(url))
        self.setWindowModality(Qt.ApplicationModal)

    def titleChaged(self, title):
        self.setWindowTitle(title)

    def urlChanged(self, url):
        if not url.hasFragment():
            return
        result = dict(urllib.parse.parse_qsl(url.fragment))
        if 'error' in result:
            self.close()
            raise AuthError(result.get('error_description') or result.error)
        self.client.access_token = result['access_token']
        self.client.user_id = int(result['user_id'])
        self.client.secret_token = result.get('secret')
        self.client.token_expiry = int(result['expires_in'])
        if self.client.token_expiry:
            self.client.token_expiry += time.time()
        self.close()


class StandaloneAuth(BrowserAuth):
    def __init__(self, client, display=None, redirect_uri=None, parent=None):
        self.display = display
        self.redirect_uri = redirect_uri
        params = {
            'client_id': client.client_id,
            'redirect_uri': redirect_uri,
            'response_type': 'token',
            'v': client.api_version,
        }
        if client.scope:
            params['scope'] = client.scope
        if display:
            params['display'] = display
        url = urllib.parse.urljoin(AUTH_URL, 'authorize')
        url = "{}?{}".format(url, urllib.parse.urlencode(params))
        super(BrowserAuth, self).__init__(client, url, parent)


class AuthError(Exception):
    pass