# Copyright 2017-present Open Networking Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import loxi.of13 as ofp
import socket
import sys
import time

from loxi.connection import Connection
from ofagent.utils import pp


class Agent(object):

    def __init__(self, controller, datapath_id,
                 store, backend, retry_interval=1):
        self.ip = controller.split(':')[0]
        self.port = int(controller.split(':')[1])
        self.datapath_id = datapath_id
        self.store = store
        self.backend = backend
        self.exiting = False
        self.retry_interval = retry_interval
        self.cxn = None
        self.soc = None

    def run(self):
        self.connect()

    def connect(self):
        """
        Connect to a controller
        """
        while not self.exiting:
            self.cxn = None
            self.soc = soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            try:
                soc.connect((self.ip, self.port))
            except socket.error, e:
                logging.info(
                    "Cannot connect to controller (errno=%d), "
                    "retrying in %s secs" %
                    (e.errno, self.retry_interval))
            else:
                logging.info("Connected to controller")
                soc.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True)
                self.cxn = cxn = Connection(self.soc)
                cxn.daemon = False
                cxn.start()
                try:
                    self.handle_protocol()
                except Exception, e:
                    logging.info(
                        "Connection was lost (%s), will retry in %s secs" %
                        (e, self.retry_interval))
            time.sleep(self.retry_interval)

    def stop(self):
        if self.cxn is not None:
            self.cxn.stop()
        if self.soc is not None:
            self.soc.close()

    def signal_flow_mod_error(self, code, data):
        msg = ofp.message.flow_mod_failed_error_msg(code=code, data=data)
        self.cxn.send(msg)

    def signal_group_mod_error(self, code, data):
        msg = ofp.message.group_mod_failed_error_msg(code=code, data=data)
        self.cxn.send(msg)

    def signal_flow_removal(self, flow):
        assert isinstance(flow, ofp.common.flow_stats_entry)
        msg = ofp.message.flow_removed(
            cookie=flow.cookie,
            priority=flow.priority,
            reason=None, # TODO
            table_id=flow.table_id,
            duration_sec=flow.duration_sec,
            duration_nsec=flow.duration_nsec,
            idle_timeout=flow.idle_timeout,
            hard_timeout=flow.hard_timeout,
            packet_count=flow.packet_count,
            byte_count=flow.byte_count,
            match=flow.match)
        self.cxn.send(msg)

    def send_packet_in(self, data, in_port):
        match = ofp.match()
        match.oxm_list.append(ofp.oxm.in_port(in_port))
        msg = ofp.message.packet_in(
            reason=ofp.OFPR_ACTION,
            match=match,
            data=data)
        self.cxn.send(msg)

    def handle_protocol(self):

        cxn = self.cxn

        # Send initial hello
        cxn.send(ofp.message.hello())

        if not cxn.recv(lambda msg: msg.type == ofp.OFPT_HELLO):
            raise Exception("Did not receive initial HELLO")

        while True:

            try:
                req = cxn.recv(lambda msg: True)
            except AssertionError, e:
                raise Exception("Connection is no longer alive")

            print(pp(req))

            if req is None:
                # this simply means we timed out
                # later we can use this to do other stuff
                # for now we simply ignore this and loop back
                pass

            elif req.type == ofp.OFPT_FEATURES_REQUEST:
                msg = ofp.message.features_reply(
                    xid=req.xid,
                    datapath_id=self.datapath_id,
                    n_buffers=256,
                    n_tables=2,
                    capabilities= (
                          ofp.OFPC_FLOW_STATS
                        | ofp.OFPC_TABLE_STATS
                        | ofp.OFPC_PORT_STATS
                        | ofp.OFPC_GROUP_STATS
                    )
                )
                cxn.send(msg)

            elif req.type == ofp.OFPT_STATS_REQUEST:

                if req.stats_type == ofp.OFPST_PORT_DESC:
                    # port stats request
                    msg = ofp.message.port_desc_stats_reply(
                        xid=req.xid,
                        #flags=None,
                        entries=self.store.port_list())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_DESC:
                    # device description
                    msg = ofp.message.desc_stats_reply(
                        xid=req.xid,
                        flags=None,
                        mfr_desc=self.backend.mfr_desc,
                        hw_desc=self.backend.hw_desc,
                        sw_desc="pyofagent",
                        serial_num=self.backend.get_serial_num(),
                        dp_desc=self.backend.get_dp_desc())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_FLOW:
                    # flow stats requested
                    msg = ofp.message.flow_stats_reply(
                        xid=req.xid, entries=self.store.flow_list())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_TABLE:
                    # table stats requested
                    msg = ofp.message.table_stats_reply(
                        xid=req.xid, entries=self.store.table_stats())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_PORT:
                    # port list
                    msg = ofp.message.port_stats_reply(
                        xid=req.xid, entries=self.store.port_stats())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_GROUP:
                    msg = ofp.message.group_stats_reply(
                        xid=req.xid, entries=self.store.group_stats())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_GROUP_DESC:
                    msg = ofp.message.group_desc_stats_reply(
                        xid=req.xid, entries=self.store.group_list())
                    cxn.send(msg)

                elif req.stats_type == ofp.OFPST_METER:
                    msg = ofp.message.meter_stats_reply(
                        xid=req.xid, entries=[])
                    cxn.send(msg)

                else:
                    logging.error("Unhandled stats type: %d in request:"
                                  % req.stats_type)
                    logging.error(pp(req))

            elif req.type == ofp.OFPT_SET_CONFIG:
                # TODO ignored for now
                pass

            elif req.type == ofp.OFPT_BARRIER_REQUEST:
                # TODO this will be the place to commit all changes before
                # replying
                # but now we send a reply right away
                msg = ofp.message.barrier_reply(xid=req.xid)
                cxn.send(msg)

            elif req.type == ofp.OFPT_GET_CONFIG_REQUEST:
                # send back configuration reply
                msg = ofp.message.get_config_reply(
                    xid=req.xid, miss_send_len=ofp.OFPCML_NO_BUFFER)
                cxn.send(msg)

            elif req.type == ofp.OFPT_ROLE_REQUEST:
                # TODO this is where we shall manage which connection is active
                # now we simply verify that the role request is for active and
                # reply
                if req.role != ofp.OFPCR_ROLE_MASTER:
                    self.stop()
                    sys.exit(1)
                msg = ofp.message.role_reply(
                    xid=req.xid, role=req.role,
                    generation_id=req.generation_id)
                cxn.send(msg)

            elif req.type == ofp.OFPT_PACKET_OUT:
                in_port = req.in_port
                data = req.data
                for action in req.actions:
                    if action.type == ofp.OFPAT_OUTPUT:
                        port = action.port
                        self.backend.packet_out(in_port, port, data)
                    else:
                        logging.warn("Unhandled packet out action type %s"
                                     % action.type)

            elif req.type == ofp.OFPT_FLOW_MOD:

                command = req._command

                if command == ofp.OFPFC_ADD:
                    self.store.flow_add(req)

                elif command == ofp.OFPFC_DELETE:
                    self.store.flow_delete(req)

                elif command == ofp.OFPFC_DELETE_STRICT:
                    self.store.flow_delete_strict(req)

                elif command == ofp.OFPFC_MODIFY:
                    self.store.flow_modify(req)

                elif command == ofp.OFPFC_MODIFY_STRICT:
                    self.store.flow_modify_strict(req)

                else:
                    logging.warn("Unhandled flow mod command %s in message:"
                                 % command)
                    logging.warn(pp(req))

            elif req.type == ofp.OFPT_GROUP_MOD:

                command = req.command

                if command == ofp.OFPGC_DELETE:
                    self.store.group_delete(req)

                elif command == ofp.OFPGC_ADD:
                    self.store.group_add(req)

                elif command == ofp.OFPGC_MODIFY:
                    self.store.group_modify(req)

                else:
                    logging.warn("Unhandled group command %s in message:"
                                 % command)
                    logging.warn(pp(req))

            else:
                logging.warn("Unhandled message from controller:")
                logging.warn(pp(req))