#!/usr/bin/env python

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
#

# A single router log file may contain data from multiple instances of
# that router booting and running. Thus there may be several different
# connections labeled [0] and these connections may be to different
# routers on each run.
#
# The 'router' class defined here represents a single boot-and-run
# instance from the log file.
#

from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
from __future__ import print_function

import sys
import traceback
import datetime

import amqp_detail
import common
import text

class RestartRecord():
    def __init__(self, _router, _line, _lineno):
        self.router = _router
        self.line = _line
        self.lineno = _lineno
        try:
            self.datetime = datetime.datetime.strptime(self.line[:26], '%Y-%m-%d %H:%M:%S.%f')
        except:
            self.datetime = datetime.datetime(1970, 1, 1)

    def __repr__(self):
        return "%d instance %d start %s #%d" % (self.router.log_index, self.router.instance,
                                                self.datetime, self.lineno)

class Router():
    '''A single dispatch boot-and-run instance from a log file'''

    def __init__(self, _fn, _log_index, _instance):
        self.fn = _fn                 # log file name
        self.log_index = _log_index   # 0=A, 1=B, ...
        self.instance = _instance     # log file instance of router
        self.iletter = common.log_letter_of(self.log_index)  # A
        self.iname = self.iletter + str(self.instance)       # A0

        # discovered Container Name
        self.container_name = None

        # discovered Version
        self.version = None

        # discovered mode
        self.mode = None

        # restart_rec - when this router was identified in log file
        self.restart_rec = None

        # lines - the log lines as ParsedLogLine objects
        self.lines = []

        # conn_list - List of connections discovered in log lines
        # Sorted in ascending order and not necessarily in packed sequence.
        self.conn_list = []

        # conn_log_lines - count of log lines per connection
        self.conn_log_lines = {}

        # conn_transfer_bytes - count of bytes transfered over this connection
        self.conn_xfer_bytes = {}

        # connection_to_frame_map
        self.conn_to_frame_map = {}

        # conn_peer - peer container long name
        #   key= connection id '1', '2'
        #   val= original peer container name
        self.conn_peer = {}

        # conn_peer_display - peer container display name
        #   key= connection id '1', '2'
        #   val= display name
        # Peer display name shortened with popup if necessary
        self.conn_peer_display = {}

        # conn_peer_connid - display value for peer's connection id
        #   key= connection id '1', '2'
        #   val= peer's connid 'A.0_3', 'D.3_18'
        self.conn_peer_connid = {}

        # conn_dir - arrow indicating connection origin direction
        #   key= connection id '1', '2'
        #   val= '<-' peer created conn, '->' router created conn
        self.conn_dir = {}

        # router_ls - link state 'ROUTER_LS (info)' lines
        self.router_ls = []

        # open and close times
        self.conn_open_time = {}   # first log line with [N] seen
        self.conn_close_time = {}  # last close log line seen

        # details: for each connection, for each session, for each link, whaaa?
        self.details = None


    def discover_connection_facts(self, comn):
        '''
        Discover all the connections in this router-instance log
        For each connection:
         * determine connection direction
         * discover name of peer container
         * generate html to use to display the peer nickname
         * count log lines
         * count transfer bytes
        :param comn:
        :return:
        '''
        for item in self.lines:
            if item.data.is_scraper:
                # scraper lines are pass-through
                continue
            conn_num = int(item.data.conn_num)
            id = item.data.conn_id           # full name A0_3
            if conn_num not in self.conn_list:
                cdir = ""
                if item.data.direction != "":
                    cdir = item.data.direction
                else:
                    if "Connecting" in item.data.web_show_str:
                        cdir = text.direction_out()
                    elif "Accepting" in item.data.web_show_str:
                        cdir = text.direction_in()
                self.conn_list.append(conn_num)
                self.conn_to_frame_map[id] = []
                self.conn_dir[id] = cdir
                self.conn_log_lines[id] = 0   # line counter
                self.conn_xfer_bytes[id] = 0  # byte counter
                self.conn_open_time[id] = item
            self.conn_to_frame_map[id].append(item)
            # inbound open handling
            if item.data.name == "open" and item.data.direction == text.direction_in():
                if item.data.conn_id in self.conn_peer:
                    sys.exit('ERROR: file: %s connection %s has multiple connection peers' % (
                    self.fn, id))
                self.conn_peer[id] = item.data.conn_peer
                self.conn_peer_display[id] = comn.shorteners.short_peer_names.translate(
                    item.data.conn_peer, True)
            # close monitor
            if item.data.name == "close":
                self.conn_close_time[id] = item
            # connection log-line count
            self.conn_log_lines[id] += 1
            # transfer byte count
            if item.data.name == "transfer":
                self.conn_xfer_bytes[id] += int(item.data.transfer_size)
        self.conn_list = sorted(self.conn_list)
        self.details = amqp_detail.AllDetails(self, comn)

    def conn_id(self, conn_num):
        '''
        Given this router's connection number return the global connection id
        :param conn_num: connection number
        :return: conn_id in the for A0_3
        '''
        return self.iname + "_" + str(conn_num)

    def is_interior(self):
        return self.mode == "interior"


def which_router_tod(router_list, at_time):
    '''
    Find a router in a list based on time of day
    :param router_list: a list of Router objects
    :param at_time: the datetime record identifying the router
    :return: tuple: (a router from the list or None, router index)
    '''
    if len(router_list) == 0:
        return (None, 0)
    if len(router_list) == 1:
        return (router_list[0], 0)
    for i in range(1, len(router_list)):
        if at_time < router_list[i].restart_rec.datetime:
            return (router_list[i-1], i-1)
    return (router_list[-1], len(router_list)-1)

def which_router_id_tod(routers, id, at_time):
    '''
    Find a router by container_name and time of day
    :param routers: a list of router instance lists
    :param id: the container name
    :param at_time: datetime of interest
    :return: the router that had that container name at that time; None if not found
    '''
    for routerlist in routers:
        if routerlist[0].container_name == id:
            return which_router_tod(routerlist, at_time)
    return (None, 0)


if __name__ == "__main__":
    try:
        pass
    except:
        traceback.print_exc(file=sys.stdout)
        pass