"""
script to do a basic holistic test of the cowmesh network,
testing internet connection speed using iperf,
between all nodes in the mesh
"""
import datetime
import os
import re
import time
import asyncio, asyncssh, sys
import paramiko
import subprocess
import json

PROJECT_PATH = os.path.abspath(os.path.dirname(__file__))
SECRETS_PATH = os.path.join(PROJECT_PATH, "secrets.json")
with open(SECRETS_PATH, 'r') as f:
    SECRETS = json.loads(f.read())

nodes = [
    "jaaga",
    "redcottage",
    "new-gazebo2",
    "kotemanetp",
    "guard"
]

host_to_ip = {
    "jaaga": "10.56.121.19",
    "redcottage": "10.56.58.194",
    "redcottage2": "10.56.114.42",
    "new-gazebo2": "10.56.114.42",
    "new-gazebo": "10.56.113.2",
    "guard": "10.56.121.73",
    "kotemanetp": "10.56.40.113"
}

results = {}


class CowmeshRouterIperfTester:

    def __init__(self, log=None, debug=False, seconds=10):
        if log:
            self.log = log
        self.debug = debug
        self.time = seconds

    async def log(self, msg):
        print(msg)

    async def debug_log(self, msg):
        if self.debug:
            await self.log(msg)

    async def test_between_two_nodes(self, node_a, node_b):
        await self.log("++ running test from {} to {}".format(node_a, node_b))
        u_name = 'root'
        pswd = SECRETS["ROUTER_PASSWORD"]

        myconn = paramiko.SSHClient()
        myconn.set_missing_host_key_policy(paramiko.AutoAddPolicy())

        myconn.connect(node_a, username =u_name, password=pswd)

        ip = host_to_ip[node_b]

        remote_cmd = 'iperf -c {ip} -p 5001 -t {seconds}'.format(ip=ip, seconds=self.time)
        (stdin, stdout, stderr) = myconn.exec_command(remote_cmd)
        output = str(stdout.read())
        await self.debug_log("output: {}".format(output))
        await self.debug_log("errors: {}".format(stderr.read()))
        myconn.close()

        match = re.search("(\S+) Mbits", output)
        if match:
            to_return = match.group(1)
        else:
            to_return = None

        return to_return

    async def start_iperf_servers(self):
        for node in nodes:
            print("++ starting iperf server on {}".format(node))
            u_name = 'root'
            pswd = SECRETS["ROUTER_PASSWORD"]

            myconn = paramiko.SSHClient()
            myconn.set_missing_host_key_policy(paramiko.AutoAddPolicy())

            myconn.connect(node, username=u_name, password=pswd)

            remote_cmd = 'iperf -s &'
            (stdin, stdout, stderr) = myconn.exec_command(remote_cmd)
            await self.debug_log("{}".format(stdout.read()))
            await self.debug_log("{}".format(type(myconn)))
            await self.debug_log("Options available to deal with the connections are many like\n{}".format(dir(myconn)))
            myconn.close()

    async def run_test(self):

        await self.start_iperf_servers()

        for node_a in nodes:
            for node_b in nodes:
                if node_a == node_b:
                    await self.debug_log("skip self")
                    continue

                r = await self.test_between_two_nodes(node_a, node_b)
                result_key = "{} -> {}".format(node_a, node_b)
                results[result_key] = r

    async def output_results(self):
        results_str = ""
        now = datetime.datetime.now()
        date = now.date()
        time = now.time()
        results_str += "**** iperf results on {date:%m-%d-%Y} at {time:%H:%M}:\n\n".format(date=date, time=time)
        for test_name, result in results.items():
            results_str += "{}: {} mbps\n".format(test_name, result)
        await self.log(results_str)


if __name__ == "__main__":
    try:
        tester = CowmeshRouterIperfTester()

        async def main_fun():
            await tester.run_test()
            await tester.output_results()

        asyncio.get_event_loop().run_until_complete(main_fun())


    except (OSError, asyncssh.Error) as exc:
        sys.exit('SSH connection failed: ' + str(exc))