#
# Copyright 2017 the original author or authors.
#
# 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.
#
from scapy.automaton import ATMT
import structlog
from voltha.adapters.microsemi_olt.BaseOltAutomaton import BaseOltAutomaton
from voltha.adapters.microsemi_olt.PAS5211 import PAS5211MsgGetProtocolVersion, PAS5211MsgGetOltVersion, \
    PAS5211MsgGetOltVersionResponse, PAS5211MsgGetProtocolVersionResponse, \
    SnrBurstDelay, RngBurstDelay, GeneralOpticsParams, ResetValues, ResetTimingCtrl, PreambleParams, \
    PAS5211MsgSetOltOpticsResponse, CHANNELS, PAS5211MsgSetOpticsIoControlResponse, PAS5211MsgGetGeneralParamResponse, \
    PAS5211MsgAddOltChannel, \
    PAS5211MsgAddOltChannelResponse, PAS5211MsgSetAlarmConfigResponse, PAS5211MsgGetDbaMode, \
    PAS5211MsgGetDbaModeResponse, PAS5211MsgStartDbaAlgorithm, \
    PAS5211MsgStartDbaAlgorithmResponse, PAS5211MsgSetOltChannelActivationPeriod, \
    PAS5211MsgSetOltChannelActivationPeriodResponse, PAS5211MsgHeader, PAS5211Event, PAS5211EventAlarmNotification
from voltha.adapters.microsemi_olt.PAS5211_constants import PON_OPTICS_VOLTAGE_IF_LVPECL, PON_ENABLE, \
    PON_POLARITY_ACTIVE_HIGH, PASCOMM_RETRIES, \
    PON_SD_SOURCE_LASER_SD, PON_RESET_TYPE_DELAY_BASED, PON_DISABLE, PON_RESET_TYPE_NORMAL_START_BURST_BASED, \
    PON_TX_ENABLE_DEFAULT, PON_ALARM_LOS, PON_DBA_MODE_LOADED_NOT_RUNNING, PON_DBA_MODE_RUNNING
from voltha.adapters.microsemi_olt.PAS5211_utils import general_param, olt_optics_pkt, burst_timing, io_ctrl_optics, \
    alarm_config
from voltha.extensions.omci.omci_frame import OmciFrame
import structlog

from voltha.protos.common_pb2 import ConnectStatus

log = structlog.get_logger()


class OltStateMachine(BaseOltAutomaton):
    send_state = []
    dba_needs_start = False
    retry = 10

    def check_channel_state(self):
        for i in CHANNELS:
            if not self.send_state[i]:
                return False
        self.send_state = []
        return True

    def master_filter(self, pkt):

        if not super(OltStateMachine, self).master_filter(pkt):
            return False

        if OmciFrame in pkt:
            log.debug("OMCI-message-type: {}".format(pkt[OmciFrame].message_type))
            return False
        
        if PAS5211Event in pkt:
            return False

        if PAS5211EventAlarmNotification in pkt:
            return False

        return True

    """
    States
    """

    @ATMT.state(initial=1)
    def disconnected(self):
        pass

    @ATMT.state()
    def wait_for_proto_version(self):
        pass

    @ATMT.state()
    def got_proto_version(self):
        pass

    @ATMT.state()
    def wait_for_olt_version(self):
        pass

    @ATMT.state()
    def got_olt_version(self):
        pass

    @ATMT.state()
    def wait_olt_optics(self):
        pass

    @ATMT.state()
    def got_olt_optics(self):
        pass

    @ATMT.state()
    def wait_olt_io_optics(self):
        pass

    @ATMT.state()
    def got_olt_io_optics(self):
        pass

    @ATMT.state()
    def wait_query_response(self):
        pass

    @ATMT.state()
    def got_query_response(self):
        pass

    @ATMT.state()
    def wait_olt_add(self):
        pass

    @ATMT.state()
    def got_olt_add(self):
        pass

    @ATMT.state()
    def wait_alarm_set(self):
        pass

    @ATMT.state()
    def got_alarm_set(self):
        pass

    @ATMT.state()
    def wait_dba_mode(self):
        pass

    @ATMT.state()
    def got_dba_mode(self):
        pass

    @ATMT.state()
    def wait_dba_start(self):
        pass

    @ATMT.state()
    def got_dba_start(self):
        pass

    @ATMT.state()
    def wait_activation(self):
        pass

    @ATMT.state(final=1)
    def end(self):
        log.debug('OLT state machine ended')
    #
    # @ATMT.state()
    # def wait_keepalive(self):
    #     pass

    @ATMT.state(error=1)
    def error(self):
        raise self.end()
        # pass

    """
    Transitions
    """

    # Transitions from disconnected state
    @ATMT.condition(disconnected)
    def send_proto_request(self):
        self.send(self.p(PAS5211MsgGetProtocolVersion()))
        raise self.wait_for_proto_version()

    # Transitions from wait_for_proto_version
    @ATMT.timeout(wait_for_proto_version, 3)
    def timeout_proto(self):
        log.debug("Timed out waiting for proto version")
        self.retry -= 1
        if self.retry < 0:
            log.error("Too many retries, aborting.")
            raise self.error()
        raise self.disconnected()

    @ATMT.receive_condition(wait_for_proto_version)
    def receive_proto_version(self, pkt):
        log.debug("Received proto version {}".format(type(pkt)))
        if PAS5211MsgGetProtocolVersionResponse in pkt:
            raise self.got_proto_version()
        else:
            log.error("Got garbage packet: {}".format(pkt.summary()))
            self.retry -= 1
            if self.retry < 0:
                log.error("Too many retries, aborting.")
                raise self.error()
            else:
                raise self.wait_for_proto_version()

    # Transitions from got_proto_version
    @ATMT.condition(got_proto_version)
    def send_olt_version(self):
        self.send(self.p(PAS5211MsgGetOltVersion()))
        log.debug("[SENT] PAS5211MsgGetOltVersion")
        raise self.wait_for_olt_version()

    # Transitions from waiting for olt version
    @ATMT.timeout(wait_for_olt_version, 3)
    def timeout_olt(self):
        log.debug("Timed out waiting for olt version")
        self.retry -= 1
        if self.retry < 0:
            log.error("Too many retries, aborting.")
            raise self.error()
        raise self.disconnected()

    @ATMT.receive_condition(wait_for_olt_version)
    def receive_olt_version(self, pkt):
        log.debug("Received proto version")
        if PAS5211MsgGetOltVersionResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgGetOltVersion")
            self.device.update_device_info_from_pkt(pkt)
            raise self.got_olt_version()
        else:
            log.error("Got garbage packet {}".format(pkt))
            raise self.error()

    # Transitions from got_olt_version
    @ATMT.condition(got_olt_version)
    def send_olt_optics(self):
        snr_burst_delay = SnrBurstDelay(timer_delay=8, preamble_delay=32,
                                        delimiter_delay=128, burst_delay=128)
        rng_burst_delay = RngBurstDelay(timer_delay=8, preamble_delay=32,
                                        delimiter_delay=128)

        general_optics_param = GeneralOpticsParams(laser_reset_polarity=PON_POLARITY_ACTIVE_HIGH,
                                                   laser_sd_polarity=PON_POLARITY_ACTIVE_HIGH,
                                                   sd_source=PON_SD_SOURCE_LASER_SD, sd_hold_snr_ranging=PON_DISABLE,
                                                   sd_hold_normal=PON_DISABLE,
                                                   reset_type_snr_ranging=PON_RESET_TYPE_DELAY_BASED,
                                                   reset_type_normal=PON_RESET_TYPE_NORMAL_START_BURST_BASED,
                                                   laser_reset_enable=PON_ENABLE)

        reset = ResetTimingCtrl(reset_data_burst=ResetValues(bcdr_reset_d2=1,
                                                             bcdr_reset_d1=11,
                                                             laser_reset_d2=2,
                                                             laser_reset_d1=5),
                                reset_snr_burst=ResetValues(bcdr_reset_d2=2,
                                                            bcdr_reset_d1=9,
                                                            laser_reset_d2=2,
                                                            laser_reset_d1=1),
                                reset_rng_burst=ResetValues(bcdr_reset_d2=2,
                                                            bcdr_reset_d1=9,
                                                            laser_reset_d2=2,
                                                            laser_reset_d1=1),
                                single_reset=ResetValues(bcdr_reset_d2=1,
                                                         bcdr_reset_d1=1,
                                                         laser_reset_d2=1,
                                                         laser_reset_d1=1),
                                double_reset=ResetValues(bcdr_reset_d2=1,
                                                         bcdr_reset_d1=1,
                                                         laser_reset_d2=1,
                                                         laser_reset_d1=1))

        preamble = PreambleParams(correlation_preamble_length=8, preamble_length_snr_rng=119,
                                  guard_time_data_mode=32, type1_size_data=0,
                                  type2_size_data=0, type3_size_data=5,
                                  type3_pattern=170, delimiter_size=20,
                                  delimiter_byte1=171, delimiter_byte2=89,
                                  delimiter_byte3=131)

        olt_optics = olt_optics_pkt(PON_OPTICS_VOLTAGE_IF_LVPECL, burst=burst_timing(1, 1,
                                                                                     snr_burst=snr_burst_delay,
                                                                                     rng_burst=rng_burst_delay),
                                    general=general_optics_param,
                                    reset=reset,
                                    preamble=preamble)

        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(olt_optics, channel_id=id))
            log.debug("[SENT] PAS5211MsgSetOltOptics")

        raise self.wait_olt_optics()

    # Transitions from wait_olt_optics
    @ATMT.timeout(wait_olt_optics, 3)
    def olt_optics_timeout(self):
        log.error("Setting olt optics failed; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_olt_optics)
    def receive_set_optics_response(self, pkt):
        if PAS5211MsgSetOltOpticsResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgSetOltOptics")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                raise self.got_olt_optics()
            raise self.wait_olt_optics()

    # Transitions from got_olt_optics
    @ATMT.condition(got_olt_optics)
    def send_olt_io_optics(self):

        pkt = io_ctrl_optics(1, 0, 6, 14)
        self.send_state.append(False)
        self.send(self.p(pkt, channel_id=0))
        log.debug("[SENT] PAS5211MsgSetOpticsIoControl")

        pkt = io_ctrl_optics(3, 2, 7, 15)
        self.send_state.append(False)
        self.send(self.p(pkt, channel_id=1))
        log.debug("[SENT] PAS5211MsgSetOpticsIoControl")

        pkt = io_ctrl_optics(11, 10, 8, 16)
        self.send_state.append(False)
        self.send(self.p(pkt, channel_id=2))
        log.debug("[SENT] PAS5211MsgSetOpticsIoControl")

        pkt = io_ctrl_optics(13, 12, 9, 17)
        self.send_state.append(False)
        self.send(self.p(pkt, channel_id=3))
        log.debug("[SENT] PAS5211MsgSetOpticsIoControl")

        raise self.wait_olt_io_optics()

    # Transitions from wait olt io optics
    @ATMT.timeout(wait_olt_io_optics, 3)
    def olt_io_optics_timeout(self):
        log.error("Setting olt io optics failed; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_olt_io_optics)
    def receive_io_optics_response(self, pkt):
        if PAS5211MsgSetOpticsIoControlResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgSetOpticsIoControl")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                raise self.got_olt_io_optics()
            raise self.wait_olt_io_optics()

    # Transitions got olt io optics
    @ATMT.condition(got_olt_io_optics)
    def check_downstream_pon_tx(self):
        query = general_param(PON_TX_ENABLE_DEFAULT)
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(query, channel_id=id))
            log.debug("[SENT] PAS5211MsgGetGeneralParam")

        raise self.wait_query_response()

    # Transitions from wait query response
    @ATMT.timeout(wait_query_response, 3)
    def query_timeout(self):
        log.error("Our queries have gone unanswered; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_query_response)
    def check_pon_tx_state(self, pkt):
        if PAS5211MsgGetGeneralParamResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgGetGeneralParam")
            self.send_state[pkt.channel_id] = True
            if pkt.value == PON_ENABLE:
                # TODO: we may want to do something here.
                if self.check_channel_state():
                    raise self.got_query_response()
                else:
                    raise self.wait_query_response()
            else:
                log.error("TX downstream is not enabled")
                raise self.error()

    # Transitions from got_query_response
    @ATMT.condition(wait_query_response)
    def send_add_olt(self):
        olt_add = PAS5211MsgAddOltChannel()
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(olt_add, channel_id=id))
            log.debug("[SENT] PAS5211MsgAddOltChannel")
        raise self.wait_olt_add()

    # Transitions from wait_olt_add
    @ATMT.timeout(wait_olt_add, 3)
    def olt_add_timeout(self):
        log.error("Cannot add olts; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_olt_add)
    def wait_for_olt_add(self, pkt):
        if PAS5211MsgAddOltChannelResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgAddOltChannel")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                raise self.got_olt_add()
            raise self.wait_olt_add()

    # Transitions from got_olt_add
    @ATMT.condition(got_olt_add)
    def send_alarm_config(self):
        alarm_msg = alarm_config(PON_ALARM_LOS, PON_ENABLE)
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(alarm_msg, channel_id=id))
            log.debug("[SENT] PAS5211MsgSetAlarmConfig")
        raise self.wait_alarm_set()

    # Transitions for wait_alarm_set
    @ATMT.timeout(wait_alarm_set, 3)
    def alarm_timeout(self):
        log.error("Couldn't set alarms; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_alarm_set)
    def wait_for_alarm_set(self, pkt):
        if PAS5211MsgSetAlarmConfigResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgSetAlarmConfig")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                raise self.got_alarm_set()
            raise self.wait_alarm_set()

    # Transitions from got_alarm_set
    @ATMT.condition(got_alarm_set)
    def send_dba_mode(self):
        get_dba_mode = PAS5211MsgGetDbaMode()
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(get_dba_mode, channel_id=id))
            log.debug("[SENT] PAS5211MsgGetDbaMode")

        raise self.wait_dba_mode()

    # Transitions from wait_dba_mode
    @ATMT.timeout(wait_dba_mode, 3)
    def dba_timeout(self):
        log.error("No DBA information returned; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_dba_mode)
    def wait_for_dba_mode(self, pkt):

        if PAS5211MsgGetDbaModeResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgGetDbaMode")
            # TODO: What do we do in case the DBA is not loaded.
            if pkt.dba_mode == PON_DBA_MODE_LOADED_NOT_RUNNING:
                self.send_state[pkt.channel_id] = True
                self.dba_needs_start = True
            elif pkt.dba_mode == PON_DBA_MODE_RUNNING:
                self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                if self.dba_needs_start:
                    raise self.got_dba_mode()
                else:
                    raise self.got_dba_start()
        raise self.wait_dba_mode()

    # Transition from got_dba_mode
    @ATMT.condition(got_dba_mode)
    def send_start_dba(self):
        dba_start = PAS5211MsgStartDbaAlgorithm(
            size=0, initialization_data=None)
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(dba_start, channel_id=id))
            log.debug("[SENT] PAS5211MsgStartDbaAlgorithm")
        raise self.wait_dba_start()

    # Transitions from wait_dba_start
    @ATMT.timeout(wait_dba_start, 3)
    def dba_start_timeout(self):
        log.error("DBA has not started; disconnecting")
        raise self.error()

    @ATMT.receive_condition(wait_dba_start)
    def wait_for_dba_start(self, pkt):
        if PAS5211MsgStartDbaAlgorithmResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgStartDbaAlgorithm")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                raise self.got_dba_start()
        raise self.wait_dba_start()

    # Transitions from got_dba_start
    @ATMT.condition(got_dba_start)
    def send_activation_period(self):
        activation = PAS5211MsgSetOltChannelActivationPeriod(
            activation_period=1000)
        for id in CHANNELS:
            self.send_state.append(False)
            self.send(self.p(activation, channel_id=id))
            log.debug("[SENT] PAS5211MsgSetOltChannelActivationPeriod")

        raise self.wait_activation()

    # Transitions for wait_for_activation
    @ATMT.timeout(wait_activation, 3)
    def timeout_activation(self):
        log.error("No activation; disconnect")
        raise self.error()

    @ATMT.receive_condition(wait_activation)
    def wait_for_activation(self, pkt):
        if PAS5211MsgSetOltChannelActivationPeriodResponse in pkt:
            log.debug("[RESPONSE] PAS5211MsgSetOltChannelActivationPeriod")
            self.send_state[pkt.channel_id] = True
            if self.check_channel_state():
                log.info("Ruby OLT at {} initialised".format(self.target))
                # self.device.create_logical_device()
                self.device.activate()
                # self.device.add_upstream_port(129)
                # self.device.add_logical_upstream_port(129)
                # keep_alive = KeepAlive(
                #     iface=self.interface, comm=self.comm, target=self.target, device=self.device)
                # keep_alive.run()
                raise self.end()
        raise self.wait_activation()


class KeepAlive(BaseOltAutomaton):
    """
        Master filter: Only allow PAS5211MsgGetOltVersionResponse
    """

    def master_filter(self, pkt):
        if not super(KeepAlive, self).master_filter(pkt):
            return False

        if PAS5211MsgGetOltVersionResponse in pkt:
            return True

        return False

    """
        States
    """

    @ATMT.state(initial=1)
    def init_keepalive(self):
        log.debug('init-keepalive')

    @ATMT.state()
    def wait_keepalive(self):
        pass

    @ATMT.state(error=1)
    def error(self):
        raise self.end()
    
    @ATMT.state(final=1)
    def end(self):
        log.debug('init-keepalive-end')

    """
        Transitions
    """

    # Send Keep Alive
    @ATMT.condition(init_keepalive)
    def send_keepalive(self):
        self.send(self.p(PAS5211MsgGetOltVersion()))
        raise self.got_keepalive()

    # Timeout
    @ATMT.timeout(wait_keepalive, 1)
    def timeout_keepalive(self):
        log.error("OLT not responding to keep alive; disconnecting")
        raise self.error()

    # Received Keep Alive
    @ATMT.receive_condition(wait_keepalive)
    def got_keepalive(self, pkt):
        log.debug('keepalive-received')
        raise self.send_keepalive()