from django.conf import settings

import traceback
import base64
import io

from transmission_rpc import Client
from transmission_rpc.error import TransmissionError

# from app.utils import send_sync_channel_message
from .models import Torrent, File
from user.models import User


class Transmission:
    trpc_args = [
        "id", "percentDone", "uploadRatio", "rateUpload", "rateDownload", "hashString", "status", "sizeWhenDone",
        "leftUntilDone", "name", "eta", "totalSize", "uploadedEver"
    ]

    def __init__(self):
        self.client = Client(**settings.TRANSMISSION)

    def add_torrent(self, file, file_mode="file_object"):
        match file_mode:
            case "file_object":
                return self.client.add_torrent(file)
            case "base64":
                file_content = base64.b64decode(file)
                file_obj = io.BytesIO(file_content)
                return self.client.add_torrent(file_obj)
        return None

    def get_data(self, hash_string):
        data = self.client.get_torrent(hash_string, self.trpc_args)

        return {
            "progress": data.progress,
            **data.fields
        }

    def get_all_data(self, hash_strings=None):
        return {
            data.hashString: {"progress": data.progress, **data.fields}
            for data in self.client.get_torrents(hash_strings, self.trpc_args)
        }

    def get_files(self, hash_string):
        return self.client.get_torrent(hash_string).get_files()

    def delete(self, hash_string):
        return self.client.remove_torrent(hash_string, delete_data=True)


transmission_handler = Transmission()


def torrent_proceed(user, file, file_mode="file_object"):
    r = {
        "torrent": None,
        "status": "error",
        "message": "Unexpected error"
    }

    user: User
    if user.size_used > user.max_size:
        r["message"] = "Size exceed"
        return r

    try:
        torrent_uploaded = transmission_handler.add_torrent(file, file_mode=file_mode)
    except TransmissionError:
        print(traceback.format_exc())
        r["message"] = "Transmission Error"
        return r
    except:
        print(traceback.format_exc())
        return r
    else:
        r["status"] = "warn"
        qs = Torrent.objects.filter(pk=torrent_uploaded.hashString)
        if qs.exists():
            torrent = qs.get()
            if torrent.user == user:
                r["message"] = "Already exist"
                return r
            elif torrent.shared_users.filter(id=user.id).exists():
                r["message"] = "Already shared"
                return r
            else:
                torrent.shared_users.add(user)
                r["status"] = "success"
                r["message"] = "Torrent downloaded by an other user, added to your list"
                return r
        else:
            data = transmission_handler.get_data(torrent_uploaded.hashString)
            torrent = Torrent.objects.create(
                id=data["hashString"],
                name=data["name"],
                user=user,
                size=data["totalSize"],
                transmission_data=data
            )
            File.objects.bulk_create([
                File(
                    torrent=torrent,
                    rel_name=file.name,
                    size=file.size,
                )
                for file in transmission_handler.get_files(torrent.id)
            ])

            r["torrent"] = torrent
            r["status"] = "success"
            r["message"] = "Torrent added"
            return r


def torrent_share(torrent, current_user, target_user_id):
    from .models import Torrent, SharedUser

    torrent: Torrent

    if (torrent.user_id != target_user_id and
            any([torrent.user == current_user, torrent.shared_users.filter(id=current_user.id)]) and
            not SharedUser.objects.filter(torrent_id=torrent.id, user_id=target_user_id).exists()):
        torrent.shared_users.add(target_user_id)
        return True
    return False