import Queue
import stem.control
import logging

from twisted.web import server, resource
from twisted.internet import reactor

from chutney.TorNet import *

# Introduction Point Tracking

node_intro_circuits = {}

node_intro_events = {}

# node_events

introduction_point_circuits = {}

nodes_by_fingerprint = {}

next_intro_points = {}

def get_node_fingerprints(nodes):

    for n in nodes:
        fingerprint = n.getStemController().get_info("fingerprint")
        nodes_by_fingerprint[fingerprint] = n

    return nodes_by_fingerprint

def get_next_intro_points():
    return next_intro_points

def track_introduction_points(node):
    nodenum = node._env["nodenum"]
    nodenick = node._env["nick"]

    node_intro_circuits[nodenum] = {}

    node_intro_events[nodenum] = Queue.Queue()

    def listener(logevent):
        prefix = "rend_service_intro_has_opened(): Established circuit "
        if logevent.message.startswith(prefix):
            circuit = logevent.message[len(prefix):].split(" ")[0]
            fingerprint = logevent.message[len(prefix):].split(" ")[1][1:]

            node_intro_circuits[nodenum][circuit] = fingerprint

            added_intro_node = nodes_by_fingerprint[fingerprint]

            logging.info("%s: added %s (%s)" % (nodenick, added_intro_node._env["nick"], fingerprint))

            node_intro_events[nodenum].put(("added", fingerprint))

        prefix = "rend_services_introduce(): Circuit to "
        if logevent.message.startswith(prefix) and "disapeared" in logevent.message:
            fingerprint = logevent.message[len(prefix):].split(" ")[0][1:41]

            for_deletion = []

            for circuit, fp in node_intro_circuits[nodenum].iteritems():
                #log("circuit " + str(circuit) + " fp " + str(fp))
                if fingerprint == fp:
                    for_deletion.append(circuit)

            for circuit in for_deletion:
                fingerprint = node_intro_circuits[nodenum][circuit]

                removed_intro_node = nodes_by_fingerprint[fingerprint]

                logging.info("%s: removed %s (%s)" % (nodenick, removed_intro_node._env["nick"], fingerprint))

                node_intro_events[nodenum].put(("removed", fingerprint))
                del node_intro_circuits[nodenum][circuit]

        prefix = "rend_services_introduce(): next intro "
        if logevent.message.startswith(prefix):
            fingerprint = logevent.message[len(prefix):].split(" ")[0][1:41]

            logging.info("%s: next intro %s" % (nodenick, fingerprint))

            if nodenum in next_intro_points:
                next_intro_points[nodenum].append(fingerprint)
            else:
                next_intro_points[nodenum] = [fingerprint]

        logging.debug(nodenick + ": " + logevent.message)


    node.getStemController().add_event_listener(listener, stem.control.EventType.INFO)
    logging.info("Tracking introduction points for " + node._env["nick"])

def track_introduction_point(node):
    nodenum = node._env["nodenum"]
    nodenick = node._env["nick"]

    introduction_point_circuits[node] = {}

    def listener(logevent):
        prefix = " "
        if logevent.message.startswith(prefix):
            circuit = logevent.message[len(prefix):].split(" ")[0]
            fingerprint = logevent.message[len(prefix):].split(" ")[1][1:]

            node_intro_circuits[nodenum][circuit] = fingerprint

            added_intro_node = nodes_by_fingerprint[fingerprint]

            logging.info("%s: added %s (%s)" % (nodenick, added_intro_node._env["nick"], fingerprint))

            node_intro_events[nodenum].put(("added", fingerprint))

        prefix = "rend_services_introduce(): Giving up on "
        if logevent.message.startswith(prefix) or "Giving up on" in logevent.message:
            logging.info(logevent.message)
            fingerprint = logevent.message[len(prefix):].split(" ")[0][1:41]

            for_deletion = []

            for circuit, fp in node_intro_circuits[nodenum].iteritems():
                #log("circuit " + str(circuit) + " fp " + str(fp))
                if fingerprint == fp:
                    for_deletion.append(circuit)

            if len(for_deletion) == 0:
                logging.info("got log message " + logevent.message + " but not deleting an introduction point")

            for circuit in for_deletion:
                fingerprint = node_intro_circuits[nodenum][circuit]

                removed_intro_node = nodes_by_fingerprint[fingerprint]

                logging.info("%s: removed %s (%s)" % (nodenick, removed_intro_node._env["nick"], fingerprint))

                node_intro_events[nodenum].put(("removed", fingerprint))
                del node_intro_circuits[nodenum][circuit]


    node.getStemController().add_event_listener(listener, stem.control.EventType.INFO)
    logging.info("Tracking introduction points for " + node._env["nick"])


def determine_max_load(service_url, clients):
    request_queue = Queue.Queue(1000)
    singlelock = threading.Lock()

    responses = []

    running = True

    class worker(threading.Thread):
        def __init__ (self, client):
            super(worker, self).__init__()
            self.client = client

        def run(self):
            while running:
                try:
                    request = request_queue.get(True, 1)

                    print("making request")
                    result = self.client.query("http://2oiifbe3wne4iaqb.onion/");

                    singlelock.acquire()
                    responses.append((result, time.time()))
                    print("result " + str(result))
                    singlelock.release()

                    # Let the queue know the job is finished.
                    request_queue.task_done()
                except:
                    pass

    # Create worker threads
    for client in clients:
        worker(client).start()

    # Add elements to eueue at rate current_load
    # Check size of queue, if above limit, return current_load

    while True:
        # Determine Average Load
        time_barrier = time.time() - 10.0

        last_responses = []

        singlelock.acquire()
        for response, response_time in reversed(responses):
            if response_time < time_barrier:
                break
            last_responses.append(response)
        singlelock.release()

        current_average_load = len(last_responses) / 10.0
        print("current average load %f" % current_average_load)

        new_load = int(current_average_load) + 1

        time_per_item = 1.0 / new_load

        for i in range(new_load):
            print("putting in item")
            request_queue.put(1)
            time.sleep(time_per_item)

def check_same_intro_points():
    intro_sets = []
    for introduction_points in node_intro_circuits.values():
        intro_sets.append(set(introduction_points.values()))

    if len(intro_sets) == 1:
        logging.info("Only one node, so trivially the same introduction points")
        return True

    for i in range(len(intro_sets) - 1):
        if not (intro_sets[i].issubset(intro_sets[i + 1]) and
                intro_sets[i + 1].issubset(intro_sets[i])):
            logging.info("Not the same introduction points")
            for num, circuits in node_intro_circuits.items():
                logging.info("node %i" % num)
                for fingerprint in sorted(circuits.values()):
                    node = nodes_by_fingerprint[fingerprint]
                    logging.info(" - " + node._env["nick"] + "(" + fingerprint + ")")
            return False

    logging.info("Same introduction points")
    for fingerprint in node_intro_circuits.values()[0].values():
        node = nodes_by_fingerprint[fingerprint]
        logging.info(" - " + node._env["nick"] + "(" + fingerprint + ")")
    return True

def create_hidden_service(nodes):
    hs_nodes = []
    hs_servers = []

    # Use twisted to create web servers in this script
    class Site(resource.Resource):
        isLeaf = True
        numberRequests = 0

        def __init__(self, siteNum):
            self.siteNum = siteNum

        def render_GET(self, request):
            self.numberRequests += 1
            request.setHeader("content-type", "text/plain")
            return str(self.siteNum)

    base_port = 10080
    for i in range(nodes):

        port = base_port + i

        node = Node(
            tag="h",
            hiddenservice=1,
            torrc="hidden-service.tmpl",
            hiddenservicetarget="127.0.0.1:%i" % port
        )
        hs_nodes.append(node)

        site = server.Site(Site(i))

        s = reactor.listenTCP(port, site)
        hs_servers.append(s)

        port += 1

    return hs_nodes, hs_servers

def connection_test(client_nodes, expected_nodes):
    logging.info("Connecting to clients")

    responses = {str(i): 0 for i in range(expected_nodes)}

    for c in client_nodes:
        result = c.query("http://2oiifbe3wne4iaqb.onion/");

        if result in responses:
            responses[result] += 1
        else:
            logging.info("Unknown response: " + str(result))

    test_pass = True

    for node, responses in sorted(responses.items()):
        logging.info(node + ": " + str(responses))

        if responses == 0:
            test_pass = False

    if test_pass:
        logging.info("Test PASS")
    else:
        logging.info("Test FAIL")