from chutney.Testing import *
from chutney.TorNet import *

from twisted.internet import reactor

from stem.control import EventType

def hs_fail_test(network, failures=1):
    hs_nodes = network.get("h")

    initial_nodes = network.get("a") + network.get("r") + network.get("c") + hs_nodes[:1]

    if not all([ n.getController().start() for n in initial_nodes ]):
        return False

    logging.info("All initial nodes running")

    thread.start_new_thread(reactor.run, (), {"installSignalHandlers": 0})

    nodes_by_fingerprint = get_node_fingerprints(network.get("a") + network.get("r"))

    track_introduction_points(hs_nodes[0])

    node_0_published_descriptor = threading.Event()

    def hs_node_0_listener(logevent):
        if "Successfully uploaded v2 rend descriptors" in logevent.message:
            node_0_published_descriptor.set()


    hs_nodes[0].getStemController().add_event_listener(hs_node_0_listener, EventType.INFO)

    node_0_published_descriptor.wait()

    hs_nodes[0].getStemController().remove_event_listener(hs_node_0_listener)

    # list to cope with scope problems
    node_counter = [len(hs_nodes) - 1]
    node_counter_lock = threading.RLock()

    nodes_published_descriptors = threading.Event()

    def hs_node_listener(logevent):
        if "Successfully uploaded v2 rend descriptors" in logevent.message:
            with node_counter_lock:
                node_counter[0] -= 1

                if node_counter[0] == 0:
                    nodes_published_descriptors.set()

    for node in hs_nodes[1:]:
        node.getController().start()
        track_introduction_points(node)

        node.getStemController().add_event_listener(hs_node_listener, EventType.INFO)

    nodes_published_descriptors.wait()

    for node in hs_nodes[1:]:
        node.getStemController().remove_event_listener(hs_node_listener)

    # Now begin testing

    connection_test(network.get("c"), len(hs_nodes))

    time.sleep(5)

    logging.info("About to stop %d introduction points" % failures)

    fingerprints = set()

    while len(fingerprints) != failures:
        # Select a random node that is being used as an introduction point
        nodenum = random.choice(node_intro_circuits.keys())
        fingerprint = random.choice(node_intro_circuits[nodenum].values())

        fingerprints.add(fingerprint)

    for fingerprint in fingerprints:
        node = nodes_by_fingerprint[fingerprint]

        logging.info("stopping " + node._env["nick"] + " (" + fingerprint + ")")

        node.getStemController().close()
        node.getController().stop()

    logging.info("begining to watch for the establishment of new introduction points")

    changed = [False for n in hs_nodes]

    intro_points_before = [set(node_intro_circuits[n._env["nodenum"]].values()) for n in hs_nodes]

    time.sleep(60)

    intro_points_after = [set(node_intro_circuits[n._env["nodenum"]].values()) for n in hs_nodes]

    for i, node in enumerate(hs_nodes):
        before = intro_points_before[i]
        after = intro_points_after[i]

        if before != after:
            changed[i] = True

    if all(changed):
        logging.info("All changed")
    else:
        logging.info("All did not change")

    check_same_intro_points()

    connection_test(network.get("c"), len(hs_nodes))

    reactor.stop()