########################################################################
# Copyright (c) 2013-2016. Сергей Снегирев <tz4678@gmail.com>.         #
# Авторские права защищены Законом.                                    #
#                                                                      #
# Вы можете распространять на безвозмездной основе данное ПО (далее по #
# тексту - программное обеспечение). Вы можете модицировать данное ПО  #
# для использования в личных целях без права распространения.          #
# Автор(-ы) не несёт(-ут) отвественности за прямой или косвенный вред, #
# причиненный данным ПО. ДАННОЕ ПО ВЫ ИСПОЛЬЗУЕТЕ НА СВОЙ СТРАХ И      #
# РИСК.                                                                #
########################################################################
from .api import (
    ApiClient,
    ApiError,
    ClientError,
    NetworkError,
    UploadError
)
from .progressdialog import ProgressDialog
from .ui.friends_delete_dialog import Ui_FriendsDeleteDialog
from .ui.friends_requests_cancel_dialog import Ui_FriendsRequestsCancelDialog
from PyQt5.QtCore import (
    pyqtProperty,
    pyqtSignal,
    pyqtSlot,
    QObject,
    QTimer
)
from PyQt5.QtWidgets import QDialog, QMessageBox
import logging
import time

log = logging.getLogger(__name__)


class Bot(ApiClient):
    authenticateCall = pyqtSignal()
    wallTestCall = pyqtSignal()
    wallDeleteCall = pyqtSignal()
    friendsDeleteCall = pyqtSignal()
    friendsRequestsSubmitCall = pyqtSignal()
    friendsRequestsCancelCall = pyqtSignal()
    followersAddCall = pyqtSignal()
    followersBlockCall = pyqtSignal()

    def __init__(self, *arg, **kw):
        super().__init__(*arg, **kw)
        self.authenticateCall.connect(self.authenticate)
        self.wallTestCall.connect(self.wallTest)
        self.wallDeleteCall.connect(self.wallDelete)
        self.friendsDeleteCall.connect(self.friendsDelete)
        self.friendsRequestsSubmitCall.connect(self.friendsRequestsSubmit)
        self.friendsRequestsCancelCall.connect(self.friendsRequestsCancel)
        self.followersAddCall.connect(self.followersAdd)
        self.followersBlockCall.connect(self.followersBlock)

    @pyqtProperty(bool, constant=True)
    def isAuthed(self):
        return bool(self.token and self.token.access)

    def wallTest(self):
        for i in range(1, 21):
            self.api.wall.post(
                message="Тестовое сообщение #{}. Timestamp: {}".format(
                    i, time.time()))

    # VkBot.wallDeleteCall()
    def wallDelete(self):
        answer = QMessageBox.question(
            None,
            self.tr("Удалить записи со стены?"),
            self.tr("Вы действительно хотите удалить записи со стены?")
        )
        if answer != QMessageBox.Yes:
            return
        log.debug("Начали удалять записи со стены")
        task = WallDeleteTask(self)
        task.run()

    def friendsDelete(self):
        dialog = FriendsDeleteDialog()
        if not dialog.exec_():
            return
        flags = 0
        if dialog.deletedCheck.checkState() == 2:
            flags |= FRIEND_DELETED
        if dialog.bannedCheck.checkState() == 2:
            flags |= FRIEND_BANNED
        if dialog.inactiveCheck.checkState() == 2:
            flags |= FRIEND_INACTIVE
        task = FriendsDeleteTask(self, flags)
        task.run()

    def friendsRequestsSubmit(self):
        FriendsRequestsSubmitTask(self).run()

    def friendsRequestsCancel(self):
        d = FriendsRequestsCancelDialog()
        if not d.exec_():
            return
        addBlackList = d.addBlackListCheck.checkState() == 2
        FriendsRequestsCancelTask(self, addBlackList).run()

    def followersAdd(self):
        FollowersAddTask(self).run()

    def followersBlock(self):
        answer = QMessageBox.question(
            None,
            self.tr("Заблокировать подписчиков?"),
            self.tr("Вы действительно хотите заблокировать подписчиков?")
        )
        if answer != QMessageBox.Yes:
            return
        FollowersBlockTask(self).run()

    @pyqtSlot(str)
    def say(self, what):
        log.info("VkBot say: {}".format(what))


class Task(QObject):
    def __init__(self, bot, title, text):
        super().__init__(bot)
        self.bot = bot
        self.dialog = ProgressDialog()
        self.dialog.setWindowTitle(self.tr(title))
        self.dialog.text.setText(self.tr(text))
        self.dialog.cancel.clicked.connect(self.stop)
        self.dialog.progress.setValue(0)
        self.running = True

    def run(self):
        self.dialog.show()
        self.handle()

    def handle(self):
        # while self.running:
        #     do smth
        pass

    def stop(self):
        self.running = False
        self.dialog.close()


class WallDeleteTask(Task):
    def __init__(self, bot):
        super().__init__(
            bot,
            "Удаление записей со стены",
            "Получаем список записей"
        )

    def handle(self):
        # https://vk.com/dev/wall.get
        offset = 0
        count = 100
        post_ids = []
        while self.running:
            wall = self.bot.api.wall.get(offset=offset, count=count)
            post_ids += [post.id for post in wall['items']]
            offset += count
            if offset >= wall.count:
                break
        self.dialog.progress.setMaximum(len(post_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Удаляем записи"))
        for post_id in post_ids:
            if not self.running:
                return
            self.bot.api.wall.delete(post_id=post_id)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


FRIEND_BANNED = 0b001
FRIEND_DELETED = 0b010
FRIEND_INACTIVE = 0b100
HUNDRED_DAYS = 100 * 24 * 60 * 60


class FriendsDeleteTask(Task):
    def __init__(self, bot, flags=0):
        super().__init__(
            bot,
            "Удаление друзей",
            "Получаем список друзей"
        )
        self.flags = flags

    def handle(self):
        offset = 0
        count = 5000
        if self.flags == 0:
            user_ids = []
            while self.running:
                friends = self.bot.api.friends.get(offset=offset, count=count)
                user_ids += friends['items']
                offset += count
                if offset >= friends.count:
                    break
        else:
            user_ids = []
            ts = time.time() - HUNDRED_DAYS
            while self.running:
                friends = self.bot.api.friends.get(
                    offset=offset,
                    count=count,
                    # Все равно какое, но поле задать нужно
                    fields='last_seen'
                )
                for friend in friends['items']:
                    if self.flags & FRIEND_BANNED:
                        if friend.get('deactivated') == 'banned':
                            user_ids.append(friend.id)
                    if self.flags & FRIEND_DELETED:
                        if friend.get('deactivated') == 'deleted':
                            user_ids.append(friend.id)
                    if self.flags & FRIEND_INACTIVE:
                        # print(friend)
                        if ('last_seen' in friend and
                                friend.last_seen.time < ts):
                            # Более 100 дней назад заходил(а)
                            user_ids.append(friend.id)
                offset += count
                if offset >= friends.count:
                    break
        self.dialog.progress.setMaximum(len(user_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Удаляем друзей"))
        for uid in user_ids:
            if not self.running:
                return
            self.bot.api.friends.delete(user_id=uid)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


class FriendsRequestsSubmitTask(Task):
    def __init__(self, bot):
        super().__init__(
            bot,
            "Подтверждение заявок",
            "Получаем список заявок в друзья"
        )

    def handle(self):
        offset = 0
        count = 1000
        user_ids = []
        while self.running:
            friends = self.bot.api.friends.getRequests(
                offset=offset,
                count=count
            )
            user_ids += friends['items']
            offset += count
            if offset >= friends.count:
                break
        self.dialog.progress.setMaximum(len(user_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Добавляем в друзья"))
        for uid in user_ids:
            if not self.running:
                return
            self.bot.api.friends.add(user_id=uid)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


class FriendsRequestsCancelTask(Task):
    def __init__(self, bot, addBlackList=False):
        super().__init__(
            bot,
            "Отмена заявок",
            "Получаем список исходящих заявок в друзья"
        )
        self.addBlackList = addBlackList

    def handle(self):
        offset = 0
        count = 1000
        user_ids = []
        while self.running:
            friends = self.bot.api.friends.getRequests(
                offset=offset,
                count=count,
                out=1,
            )
            user_ids += friends['items']
            offset += count
            if offset >= friends.count:
                break
        self.dialog.progress.setMaximum(len(user_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Отменяем заявки"))
        for uid in user_ids:
            if not self.running:
                return
            self.bot.api.friends.delete(user_id=uid)
            if self.addBlackList:
                self.bot.api.account.banUser(user_id=uid)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


class FollowersAddTask(Task):
    def __init__(self, bot):
        super().__init__(
            bot,
            "Добавление подписчиков",
            "Получаем список подписчиков"
        )

    def handle(self):
        offset = 0
        count = 1000
        user_ids = []
        while self.running:
            users = self.bot.api.users.getFollowers(
                offset=offset,
                count=count
            )
            user_ids += users['items']
            offset += count
            if offset >= users.count:
                break
        self.dialog.progress.setMaximum(len(user_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Добавляем в друзья"))
        for uid in user_ids:
            if not self.running:
                return
            self.bot.api.friends.add(user_id=uid)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


class FollowersBlockTask(Task):
    def __init__(self, bot):
        super().__init__(
            bot,
            "Блокировка подписчиков",
            "Получаем список подписчиков"
        )

    def handle(self):
        offset = 0
        count = 1000
        user_ids = []
        while self.running:
            users = self.bot.api.users.getFollowers(
                offset=offset,
                count=count
            )
            user_ids += users['items']
            offset += count
            if offset >= users.count:
                break
        self.dialog.progress.setMaximum(len(user_ids))
        counter = 0
        self.dialog.text.setText(self.tr("Блокируем"))
        for uid in user_ids:
            if not self.running:
                return
            self.bot.api.account.banUser(user_id=uid)
            counter += 1
            self.dialog.progress.setValue(counter)
        self.dialog.close()


class FriendsDeleteDialog(QDialog, Ui_FriendsDeleteDialog):
    def __init__(self, parent=None):
        super(QDialog, self).__init__(parent)
        self.setupUi(self)


class FriendsRequestsCancelDialog(QDialog, Ui_FriendsRequestsCancelDialog):
    def __init__(self, parent=None):
        super(QDialog, self).__init__(parent)
        self.setupUi(self)