from __future__ import print_function
from lbrynet.core import log_support

import argparse
import collections
import logging
import os
import random
import shutil
import sys
import tempfile

from twisted.internet import defer
from twisted.internet import reactor

from lbrynet import analytics
from lbrynet import conf
from lbrynet.core import Wallet
from lbrynet.core import BlobAvailability
from lbrynet.core import Session
from lbrynet.core import utils

import common
import name
import pool
import track


log = logging.getLogger()


def main(args=None):
    conf.initialize_settings()
    parser = argparse.ArgumentParser()
    parser.add_argument('--limit', type=int)
    parser.add_argument('--download', action='store_true',
                        help='Set flag to also download each sd_blob and report on success')
    args = parser.parse_args(args)

    log_support.configure_console()
    log_support.configure_twisted()

    # make a fresh dir or else we will include blobs that we've
    # already downloaded but might not otherwise be available.
    db_dir = tempfile.mkdtemp()
    try:
        blob_dir = os.path.join(db_dir, 'blobfiles')
        os.makedirs(blob_dir)
        storage = Wallet.InMemoryStorage()
        wallet = Wallet.LBRYumWallet(storage)
        session = Session.Session(
            0,
            db_dir=db_dir,
            lbryid=utils.generate_id(),
            blob_dir=blob_dir,
            dht_node_port=4444,
            known_dht_nodes=conf.settings['known_dht_nodes'],
            peer_port=3333,
            use_upnp=False,
            wallet=wallet
        )
        api = analytics.Api.new_instance(conf.settings['share_usage_data'])
        run(args, session, api)
        reactor.run()
    finally:
        shutil.rmtree(db_dir)


@defer.inlineCallbacks
def run(args, session, api):
    try:
        yield session.setup()
        names = yield common.getNames(session.wallet)
        if args.limit and len(names) > args.limit:
            names = random.sample(list(names), args.limit)
        names = [Name(n) for n in names]
        blob_tracker = BlobAvailability.BlobAvailabilityTracker(
            session.blob_manager, session.peer_finder, session.dht_node)

        tracker = yield Tracker(session, names, blob_tracker)
        yield tracker.processNameClaims(args.download)
        event = makeEvent(tracker.stats)
        if args.download and not args.limit:
            api.track(event)
        else:
            # don't send event to analytics if it doesn't contain the full info
            print(event)
    except Exception:
        log.exception('Something bad happened')
    finally:
        reactor.stop()


class Tracker(track.Tracker):
    def __init__(self, session, names, blob_tracker):
        track.Tracker.__init__(self, session, names)
        self.blob_tracker = blob_tracker

    @defer.inlineCallbacks
    def processNameClaims(self, download=False):
        try:
            yield self._getSdHashes()
            yield self._filterNames('sd_hash')
            yield self._checkAvailability()
            yield self._filterNames('is_available')
            yield self.print_attempts_counter()
            if download:
                yield self._downloadAllBlobs()
                yield self._filterNames('sd_blob')
        except Exception:
            log.exception('Something bad happened')

    def print_attempts_counter(self):
        print(self.attempts_counter)

    def attempts_counter(self):
        return collections.Counter([n.availability_attempts for n in self.names])

    def _checkAvailability(self):
        return pool.DeferredPool(
            (n.check_availability(self.blob_tracker) for n in self.names),
            10
        )


class Name(name.Name):
    # From experience, very few sd_blobs get found after the third attempt
    MAX_ATTEMPTS = 6
    def __init__(self, my_name):
        name.Name.__init__(self, my_name)
        self.is_available = None
        self.availability_attempts = 0

    @defer.inlineCallbacks
    def _check_availability(self, blob_tracker):
        b = yield blob_tracker.get_blob_availability(self.sd_hash)
        peer_count = b[self.sd_hash]
        self._setAvailable(peer_count)

    @defer.inlineCallbacks
    def check_availability(self, blob_tracker):
        while not self.is_available and self.availability_attempts < self.MAX_ATTEMPTS:
            self.availability_attempts += 1
            log.info('Attempt %s to find %s', self.availability_attempts, self.name)
            yield self._check_availability(blob_tracker)

    def _setAvailable(self, peer_count):
        self.is_available = peer_count > 0


def makeEvent(stats):
    return {
        'userId': 'lbry',
        'event': 'Content Availability',
        'properties': {
            'total_published': stats['sd_hash'],
            'sd_blob_available_on_dht': stats['is_available'],
            'sd_blob_available_for_download': stats['sd_blob'],
        },
        'context': {
            'app': {
                'name': 'Availability Tracker',
                'version': 1,
            },
            'library': {
                'name': 'lbrynet-analytics',
                'version': '1.0.0'
            },
        },
        'timestamp': utils.isonow()
    }

if __name__ == '__main__':
    sys.exit(main())