import time
from qbittorrent import Client

if __name__ == '__main__':
    qb = Client('http://127.0.0.1:8080/')

    torrents = qb.torrents()
    count = 0

    for t in torrents:
        t_trackers = qb.get_torrent_trackers(t['hash'])

        for tt in t_trackers:
            if tt['status'] == 'Not working':
                if 'This torrent does not exist' in tt['msg']:
                    print('AnimeBytes - ' + t['name'])
                    count += 1
                    break
                elif 'Unregistered torrent' in tt['msg']:
                    print('Other      - ' + t['name'])
                    count += 1
                    break

        time.sleep(
            .001)  # The script freezes if qBittorrent is queried too quickly

    if count > 0:
        print()

    print(str(count) + ' obsolete torrents found!')
class my_qBittorrent(object):
    def __init__(self,config):
        self.config = config
        username = self.config.get('global','webui_username')
        password = self.config.get('global','webui_password')
        webui_url = self.config.get('global','webui_url')
        self.torrentHash = []
        self.torrentData = []
        self.client = Client(webui_url)
        self.client.login(username, password)
        self.getTorrentInfo()
        self.getTorrentSeedTime()
    
    def getTorrentInfo(self):
        self.torrents = self.client.torrents(filter = 'completed')
        for torrent in self.torrents:
            self.torrentHash.append(torrent['hash'])
        return
        
    def getTorrentSeedTime(self):
        for torrentHash in self.torrentHash:
            torrentDict = {'hash':torrentHash,'info':self.client.get_torrent(torrentHash)}
            self.torrentData.append(torrentDict)
        return
    
    def deleteTorrentPerm(self,torrentHash):
        self.client.delete_permanently(torrentHash)
        return
    
    def getSingleTorrentInfo(self,torrentHash):
        torrentDict = {'hash':torrentHash,'info':self.client.get_torrent(torrentHash)}
        return torrentDict
    
    def seedTimeFilter(self,torrentHash,seedTime=1):
        seedTimeConv = seedTime*3600
        torrentInfo = self.getSingleTorrentInfo(torrentHash)
        seedingTime = torrentInfo['info']['seeding_time']
        if seedingTime > seedTimeConv:
            return True
        return False
    
    def trackerFilter(self,torrentHash,tracker = None):
        #add the tracker exception
        if tracker:
            rawInfo = self.client.get_torrent_trackers(torrentHash)
            torrentTracker = rawInfo[0]['url']
            if tracker in torrentTracker:
                return True
        return False
    
    def addedTimeFilter(self,torrentHash,addedTime = 1):
        #default day
        torrentInfo = self.getSingleTorrentInfo(torrentHash)
        addedTimeConv = addedTime*24*3600
        timeElapsed = torrentInfo['info']['time_elapsed']
        if timeElapsed > addedTimeConv:
            return True
        return False
    
    def integratedFilterAndExecute(self,torrentHash,tacker = None, lowerLimit = None):
        seed_time = self.config.getint('filter','seeding_time')
        if not lowerLimit:
            if not self.trackerFilter(torrentHash, tracker = tacker):
                if self.seedTimeFilter(torrentHash, seedTime = seed_time):
                    self.deleteTorrentPerm(torrentHash)
                    
        else:
            if not self.trackerFilter(torrentHash, tracker = tacker):
                if self.seedTimeFilter(torrentHash, seedTime = seed_time) and self.filterUploadSpeed(torrentHash, lowerLimit = lowerLimit):
                    self.deleteTorrentPerm(torrentHash)
    
    def Traversal(self):
        tracker = self.config.get('filter','exception_tracker')
        lowerLimit = self.config.get('filter','upload_speed')
        for torrentHash in self.torrentHash:
            self.integratedFilterAndExecute(torrentHash,tracker,lowerLimit = lowerLimit)

    def getUploadSpeed(self,torrentHash):
        torrentInfo = self.getSingleTorrentInfo(torrentHash)
        torrentUpSpeed = torrentInfo['up_speed']
        return torrentUpSpeed

    def filterUploadSpeed(self,torrentHash,lowerLimit = None):
        torrentUpSpeed = self.getUploadSpeed(torrentHash)
        if lowerLimit:
            if torrentUpSpeed < lowerLimit:
                return True
            else:
                return False
        return False