#!/usr/bin/env python
import argparse
import models.executor
from iexceptions import ExecuteException
from const import START, STOP, STATUS, DEFAULT_NETWORK_RATE
from libs.unit import to_ms
"""
"""


class NetworkExecutor(models.executor.Executor):
    """as network"""

    def __init__(self):
        self._tc = "tc"
        self._iptables = "iptables"

    def common_runner(self, action, operation, postfix, **kwargs):
        interface = kwargs["interface"] if "interface" in kwargs and kwargs[
            "interface"] else "lo"
        src = kwargs["src"] if "src" in kwargs and kwargs["src"] else None
        rate = kwargs["rate"] if "rate" in kwargs and kwargs["rate"] \
            else DEFAULT_NETWORK_RATE
        if rate == "None":
            rate = DEFAULT_NETWORK_RATE
        if operation == START:
            cmd = "{tc} qdisc replace dev {interface} root netem {action} "\
            "{rate}{postfix}"\
            .format(
                tc=self._tc,
                interface=interface,
                rate=rate,
                action=action,
                postfix=postfix)
        elif operation == STOP:
            cmd = "{tc} qdisc replace dev {interface} root netem {action} "\
            "0{postfix}"\
            .format(
                tc=self._tc,
                interface=interface,
                action=action,
                postfix=postfix)
        # self._clear_related_cmd(cmd)
        try:
            self._execute_or_revert_cmd(cmd)
        except ExecuteException as e:
            raise e
        return True

    def fail(self, operation, **kwargs):
        return self.common_runner("corrupt", operation, "%", **kwargs)

    def delay(self, operation, **kwargs):
        if operation == START:
            kwargs["rate"] = to_ms(kwargs["rate"])
        return self.common_runner("delay", operation, "ms", **kwargs)

    def loss(self, operation, **kwargs):
        return self.common_runner("loss", operation, "%", **kwargs)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description='Network Injection Simulation')
    parser.add_argument('operation', metavar='start/stop',
                        help='operations')
    parser.add_argument('-a', '--action', dest='action',
                        metavar='fail/loss/delay/limit',
                        help='which action to take ')
    parser.add_argument('-i', '--interface', dest='interface',
                        help='which interface to operation ')
    parser.add_argument('--container_id', dest='container_id', 
                        help="which container id to operation")
    parser.add_argument('-r', '--rate', dest='rate',
                        help='how much rate to operation ')
    parser.add_argument('-s', '--src', dest='src',
                        help='which ip ')

    args = parser.parse_args()
    executor = NetworkExecutor()
    interface = args.interface
    if args.container_id:
        from models.docker import docker
        interface = docker.get_netdev_for_container_id(args.container_id)
    try:
        getattr(executor, args.action)(args.operation,
                                       interface=interface,
                                       rate=args.rate,
                                       src=args.src)
    except ExecuteException as e:
        print e._msg
        exit(1)