import matplotlib.pyplot as plt
import numpy as np
import json
import os
from IPython.display import Markdown, display, HTML
from matplotlib.pyplot import *
import pandas as pd
import seaborn as sb
import math
from scipy import stats
from matplotlib.font_manager import FontProperties

np.seterr(divide='ignore', invalid='ignore')

def mean(meanArray):
    avg=sum(meanArray)/len(meanArray)
    return avg

def variance(varArray):
    var=np.var(varArray)
    return var

def stdDev(devArray):
    dev=np.std(devArray)
    return dev

def set_graph_params(*args):

    # parsing parametrů
    if len(args)==4:
        return {
            "x" : args[0],
            "y" : args[1],
            "title" : args[2],
            "colors": args[3]
    }

    if len(args)==5:
        return {
            "x" : args[0],
            "y" : args[1],
            "title" : args[2],
            "colors": args[3],
            "bins": args[4],
        }

    if len(args)==6:
        return {
            "x" : args[0],
            "y" : args[1],
            "title" : args[2],
            "colors": args[3],
            "n": args[4],
            "color": args[5],
        }

    if len(args) == 7:
        return {
            "x": args[0],
            "y": args[1],
            "title": args[2],
            "colors": args[3],
            "n": args[4],
            "color": args[5],
            "rotation":args[6]
        }

def load_data(n,final_dir):

    # proměnné a inicializace
    file_count = n
    l=0
    bytes_out = []
    bytes_in = []
    packets_out = []
    packets_in = []
    flow_time = []
    avg_byte_dist = []
    byte_seq = []
    time_seq = []
    dir_seq = []
    splt_p = []
    splt_t = []
    splt_d = []
    srlt_p = []
    srlt_t = []
    srlt_d = []
    labels = []
    for i in range(0, 256):
        avg_byte_dist.append(0)

    # načtení dat
    for i in range(1,n+1):
        with open (final_dir+'\\'+str(i)+'.json') as json_file:
            records = json_file.readlines()
        try:
            data = json.loads(records[1])
        except IndexError:
            data = json.loads(records[0])
        # základní data
        bytes_out.append(data['bytes_out'])
        bytes_in.append(data['bytes_in'])
        packets_out.append(data['num_pkts_out'])
        packets_in.append(data['num_pkts_in'])
        flow_time.append(data['time_end'] - data['time_start'])
        loaded_dist = data['byte_dist']
        for k in loaded_dist[0:255]:
            avg_byte_dist[l] += k
            l += 1
        l = 0

        # načtení SPLT dat
        splt=data['packets']
        for record in splt:
            try:
                byte_seq.append(record['b'])
                time_seq.append(record['ipt'])
                dir_seq.append(record['dir'])
            except KeyError:
                pass
        splt_p.append(byte_seq[:])
        splt_t.append(time_seq[:])
        splt_d.append(dir_seq[:])
        byte_seq.clear()
        time_seq.clear()
        dir_seq.clear()

        # načtení SRLT dat, pokud jsou přítomna
        if ('tls' in data):
            if ('srlt' in data['tls']):
                labels.append(n)
                srlt=data['tls']['srlt']
                for record in srlt:
                    try:
                        byte_seq.append(record['b'])
                        time_seq.append(record['ipt'])
                        dir_seq.append(record['dir'])
                    except KeyError:
                        pass
                srlt_p.append(byte_seq[:])
                srlt_t.append(time_seq[:])
                srlt_d.append(dir_seq[:])
                byte_seq.clear()
                time_seq.clear()
                dir_seq.clear()

    # zprůměrování distribuce bajtů
    for i in range(0, len(avg_byte_dist)):
        avg_byte_dist[i] = avg_byte_dist[i] / file_count

    # uložení načtených dat do dict a jeho vrácení
    loaded = {
        "bytes_in" : bytes_in,
        "bytes_out" : bytes_out,
        "packets_in" : packets_in,
        "packets_out" : packets_out,
        "flow_time" : flow_time,
        "avg_byte_dist" : avg_byte_dist,
        "splt_t" : splt_t,
        "splt_p" : splt_p,
        "splt_d" : splt_d,
        "labels" : labels,
        "srlt_t": srlt_t,
        "srlt_p": srlt_p,
        "srlt_d": srlt_d,
        "file_count" : file_count,
    }
    return loaded

def bytes_in_out(loaded,params):

    # získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    bytes_in = loaded.get("bytes_in")
    bytes_out = loaded.get("bytes_out")
    plt.rcParams['figure.dpi'] = 150
    plt.subplots()
    bins = params.get("bins")
    opacity = 0.5

    # zobrazení grafu, pokud není nastavena velikost bins:
    if (bins == None):
        bins1 = max(bytes_in) - min(bytes_in)
        bins2 = max(bytes_out) - min(bytes_out)
        plt.hist(bytes_in, round(bins1), density=True, stacked=True,facecolor=colors[0], alpha=opacity,label='in',edgecolor=colors[0], linewidth=1)
        plt.hist(bytes_out, round(bins2), density=True, stacked=True, facecolor=colors[1], alpha=opacity, label='out',edgecolor=colors[1], linewidth=1)
        sb.kdeplot(bytes_in,color=colors[0],linewidth=0.5,linestyle=':')
        sb.kdeplot(bytes_out,color=colors[1],linewidth=0.5,linestyle=':')

    # zobrazení grafu, pokud je nastavena velikost bins:
    else:
        plt.hist(bytes_in, bins,density=True, stacked=True, facecolor=colors[0], alpha=opacity,label='in', edgecolor=colors[0],linewidth=1)
        plt.hist(bytes_out, bins, density=True, stacked=True,facecolor=colors[1], alpha=opacity, label='out', edgecolor=colors[1], linewidth=1)
        sb.kdeplot(bytes_in,color=colors[0],linewidth=0.5,linestyle=':')
        sb.kdeplot(bytes_out,color=colors[1],linewidth=0.5,linestyle=':')

    # nastavení legendy a popisků
    custom_lines = [Line2D([0], [0], alpha=opacity, color=colors[0], lw=4),
                    Line2D([0], [0], alpha=opacity, color=colors[1], lw=4)]
    plt.legend(custom_lines, ['in', 'out'])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.legend()
    plt.xlim(0,None)
    plt.title(title)

def bytes_stats(loaded, params):

    # získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    bytes_in = loaded.get("bytes_in")
    bytes_out = loaded.get("bytes_out")
    n = loaded.get("file_count")
    pole=[]
    for i in range(n):
        pole.append(i)

    # výpočet průměrů a směrodatných odchylek ze získaných dat
    mean_out=mean(bytes_out)
    mean_in= mean(bytes_in)
    std_out=stdDev(bytes_out)
    std_in=stdDev(bytes_in)

    # vykreslení průmeru a směrodatných odchylek
    plt.subplot()
    plt.hlines(mean_in, -1, n , colors=colors[0])
    plt.hlines(mean_out, -1, n, colors=colors[1])
    plt.hlines(mean_in+std_in, -1, n , colors=colors[0],linestyles=':',linewidth=0.7)
    # pokud by byla linka umístěna na hodnotě y nižší než 0, nebude zobrazena
    if (mean_in - std_in > 0):
        plt.hlines(mean_in-std_in, -1, n , colors=colors[0], linestyles=':',linewidth=0.7)
    plt.hlines(mean_out + std_out, -1, n , colors=colors[1], linestyles=':',linewidth=0.7)
    if (mean_out - std_out > 0):
        plt.hlines(mean_out - std_out, -1, n, colors=colors[1], linestyles=':',linewidth=0.7)

    # vykreslení grafů samotných
    plt.bar(pole, bytes_in, alpha=0.5, color=colors[0], label='in',edgecolor=colors[0], linewidth=1)
    plt.bar(pole, bytes_out, alpha=0.5, color=colors[1],label='out',edgecolor=colors[1], linewidth=1)

    # nastavení legendy a popisků
    plt.legend()
    plt.xticks([], [])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.title(title)
    plt.show()

    # nastavení zarovnání a zobrazení všech výstupů
    display(HTML("""
    <style>
    .output {
        display: flex;
        align-items: center;
        text-align: center;
    }
    </style>
    """))

    # zobrazení informací o průměrech a odchylkách v tabulce
    heading_properties = [('font-size', '18px'),('border-style', 'solid'), ('border-width', '1px'),('text-align','center'),('background-color','lightgrey')]
    cell_properties = [('font-size', '16px'),('border-style', 'solid'), ('border-width', '1px'),('text-align','center')]
    df_style = [dict(selector="th", props=heading_properties),
               dict(selector="td", props=cell_properties),]
    results=[["průměr",str(round(mean_in,2)),str(round(mean_out,2))],["rozptyl",str(round(variance(bytes_in),2)),str(round(variance(bytes_out),2))],["odchylka",str(round(std_in,2)),str(round(std_out,2))]]
    df = pd.DataFrame(results,columns=["data\směr","in","out"])
    display(df.style.hide_index().set_table_styles(df_style))

def packets_in_out(loaded,params):

    # získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    packets_in = loaded.get("packets_in")
    packets_out = loaded.get("packets_out")
    plt.rcParams['figure.dpi'] = 150
    plt.subplots()
    opacity = 0.5
    bins = params.get("bins")

    # zobrazení grafu, pokud není nastavena velikost bins:
    if (bins == None):
        bins1 = max(packets_in) - min(packets_in)
        bins2 = max(packets_out) - min(packets_out)
        plt.hist(packets_in, round(bins1), density=True, stacked=True,facecolor=colors[0], alpha=opacity,label='in',edgecolor=colors[0], linewidth=1)
        plt.hist(packets_out, round(bins2), density=True, stacked=True, facecolor=colors[1], alpha=opacity, label='out',edgecolor=colors[1], linewidth=1)
        sb.kdeplot(packets_in,color=colors[0],linewidth=0.5,linestyle=':')
        sb.kdeplot(packets_out,color=colors[1],linewidth=0.5,linestyle=':')
    # zobrazení grafu, pokud je nastavena velikost bins:
    else:
        plt.hist(packets_in, bins,density=True, stacked=True, facecolor=colors[0], alpha=opacity,label='in',edgecolor=colors[0], linewidth=1 )
        plt.hist(packets_out, bins, density=True, stacked=True,facecolor=colors[1], alpha=opacity, label='out',edgecolor=colors[1], linewidth=1)
        sb.kdeplot(packets_in,color=colors[0],linewidth=0.5,linestyle=':')
        sb.kdeplot(packets_out,color=colors[1],linewidth=0.5,linestyle=':')

    # nastavení legendy a popisků
    custom_lines = [Line2D([0], [0], alpha=opacity, color=colors[0], lw=4),
                    Line2D([0], [0], alpha=opacity, color=colors[1], lw=4)]
    plt.legend(custom_lines, ['in', 'out'])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.xlim(0,None)
    plt.legend()
    plt.title(title)

def packets_stats(loaded, params):

    #získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    packets_in = loaded.get("packets_in")
    packets_out = loaded.get("packets_out")
    n = loaded.get("file_count")
    pole = []
    for i in range(n):
        pole.append(i)

    # výpočet průměrů a směrodatných odchylek ze získaných dat
    mean_out = mean(packets_out)
    mean_in = mean(packets_in)
    std_out = stdDev(packets_out)
    std_in = stdDev(packets_in)

    # vykreslení průmeru a směrodatných odchylek
    plt.subplot()
    plt.hlines(mean_in, -1, n, colors=colors[0])
    plt.hlines(mean_out, -1, n, colors=colors[1])
    plt.hlines(mean_in + std_in, -1, n, colors=colors[0], linestyles=':', linewidth=0.7)
    # pokud by byla linka umístěna na hodnotě y nižší než 0, nebude zobrazena
    if (mean_in - std_in > 0):
        plt.hlines(mean_in - std_in, -1, n, colors=colors[0], linestyles=':', linewidth=0.7)
    plt.hlines(mean_out + std_out, -1, n, colors=colors[1], linestyles=':', linewidth=0.7)
    if (mean_out - std_out > 0):
        plt.hlines(mean_out - std_out, -1, n, colors=colors[1], linestyles=':', linewidth=0.7)

    # vykreslení grafů samotných
    plt.bar(pole, packets_in, alpha=0.5, color=colors[0], label='in',edgecolor=colors[0], linewidth=1)
    plt.bar(pole, packets_out, alpha=0.5, color=colors[1], label='out',edgecolor=colors[1], linewidth=1)

    # nastavení legendy a popisků
    plt.legend()
    plt.xticks([], [])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.title(title)
    plt.show()

    # nastavení zarovnání a zobrazení všech výstupů
    display(HTML("""
    <style>
    .output {
        display: flex;
        align-items: center;
        text-align: center;
    }
    </style>
    """))

    # zobrazení informací o průměrech a odchylkách v tabulce
    heading_properties = [('font-size', '18px'), ('border-style', 'solid'), ('border-width', '1px'),
                          ('text-align', 'center'), ('background-color', 'lightgrey')]
    cell_properties = [('font-size', '16px'), ('border-style', 'solid'), ('border-width', '1px'),
                       ('text-align', 'center')]
    df_style = [dict(selector="th", props=heading_properties),
                dict(selector="td", props=cell_properties), ]
    results = [["průměr", str(round(mean_in, 2)), str(round(mean_out, 2))],
               ["rozptyl", str(round(variance(packets_in), 2)), str(round(variance(packets_out), 2))],
               ["odchylka", str(round(std_in, 2)), str(round(std_out, 2))]]
    df = pd.DataFrame(results, columns=["data\směr", "in", "out"])
    display(df.style.hide_index().set_table_styles(df_style))

def flow_duration(loaded,params):

    # získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    flow_time = loaded.get("flow_time")
    plt.rcParams['figure.dpi'] = 150
    plt.subplots()
    flow_ms=[]
    opacity = 0.5
    bins = params.get("bins")

    # převod na milisekundy
    for i in range(len(flow_time)):
        flow_ms.append(flow_time[i] * 1000)

    # zobrazení grafu, pokud není nastavena velikost bins:
    if (bins == None):
        bins = max(flow_ms) - min(flow_ms)
        plt.hist(flow_ms, int(bins), density=True, stacked=True,facecolor=colors[0], label='trvání flow',alpha=opacity,edgecolor=colors[0], linewidth=1)
        sb.kdeplot(flow_ms,color=colors[0],linewidth=0.5,linestyle=':')
    # zobrazení grafu, pokud je nastavena velikost bins:
    else:
        plt.hist(flow_ms, bins,density=True, stacked=True, facecolor=colors[0], label='trvání flow', alpha=opacity,edgecolor=colors[0], linewidth=1 )
        sb.kdeplot(flow_ms,color=colors[0],linewidth=0.5,linestyle=':')

    # nastavení legendy a popisků
    plt.legend()
    plt.xlim(0,None)
    plt.xlabel(x)
    plt.ylabel(y)
    plt.legend()
    plt.title(title)

def flow_stats(loaded, params):

    #získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    flow_time = loaded.get("flow_time")
    n = loaded.get("file_count")
    pole = []
    for i in range(n):
        pole.append(i)

    # výpočet průměru a směrodatné odchylky ze získaných dat
    means = mean(flow_time)
    std = stdDev(flow_time)

    # vykreslení průmeru a směrodatné odchylky
    plt.subplot()
    plt.hlines(means, -1, n, colors=colors[0])
    plt.hlines(means + std, -1, n, colors=colors[0], linestyles=':', linewidth=0.7)
    # pokud by byla linka umístěna na hodnotě y nižší než 0, nebude zobrazena
    if (means - std > 0):
        plt.hlines(means - std, -1, n, colors=colors[0], linestyles=':', linewidth=0.7)

    # vykreslení hlavního grafu
    plt.bar(pole, flow_time, alpha=0.5, color=colors[0], label='délka toku',edgecolor=colors[0], linewidth=1)

    # nastavení legendy a popisků
    plt.legend()
    plt.xticks([], [])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.title(title)
    plt.show()

    # nastavení zarovnání a zobrazení všech výstupů
    display(HTML("""
    <style>
    .output {
        display: flex;
        align-items: center;
        text-align: center;
    }
    </style>
    """))

    # zobrazení informací o průměrech a odchylkách v tabulce
    heading_properties = [('font-size', '18px'), ('border-style', 'solid'), ('border-width', '1px'),
                          ('text-align', 'center'), ('background-color', 'lightgrey')]
    cell_properties = [('font-size', '16px'), ('border-style', 'solid'), ('border-width', '1px'),
                       ('text-align', 'center')]
    df_style = [dict(selector="th", props=heading_properties),
                dict(selector="td", props=cell_properties), ]
    results = [["průměr", str(round(means, 3))],
               ["rozptyl", str(round(variance(flow_time),3))],
               ["odchylka", str(round(std,3))]]
    df = pd.DataFrame(results, columns=["data", "trvání toku"])
    display(df.style.hide_index().set_table_styles(df_style))

def normalize(norm_array):

    #normalizace pole - převod na pravděpodobnost výskytu hodnoty 0-1
    total = 0
    result = []
    for i in range(0, len(norm_array)):
        total = total + norm_array[i]
        result.append(0)
    for i in range(0, len(norm_array)):
        result[i] = (norm_array[i] / total) #*100 pokud jsou třeba procenta
    return result

def byte_dist_avg(loaded,params):

    #získání parametrů
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    avg_byte_dist = loaded.get("avg_byte_dist")
    pole = []
    for i in range(0, 256):
        pole.append(i)

    #normalizace pole
    avg_byte_dist = normalize(avg_byte_dist)

    # vykreslení grafu a nastavení popisků
    bar(pole, avg_byte_dist, color=colors[0])
    plt.xlabel(x)
    plt.ylabel(y)
    plt.title(title)
    plt.show()

def splt_packets(loaded, params):

    # získání parametrů a proměnných
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    n_packets = params.get("n")
    prop_color = params.get("color")
    splt_p=loaded.get("splt_p")
    labels = []
    pole = []
    n_packet_values = []
    values = []
    lengths = []

    # kontrola zadaného počtu paketů k zobrazení, pokud je vyšší než maximální počet,
    # je tento počet považován za zadanou hodnotu
    max_len=len(max(splt_p,key=len))
    if n_packets > max_len:
        n_packets = max_len

    # získání pole s popisky a inicializace pole na scaling osy x
    for i in range(n_packets):
        labels.append(str(i + 1)+'.')
        pole.append(i)

    # získání hodnot velikostí paketů SPLT
    for j in range(n_packets):
        for i in range(len(splt_p)):
            try:
                n_packet_values.append(splt_p[i][j])
            except IndexError:
                pass
        values.append(n_packet_values[:])
        n_packet_values.clear()

    # získání hodnot pro graf na pozadí - počet paketů, ze kterého byly údaje vypočítány
    for i in values:
        lengths.append(len(i))

    # základní boxplot
    fig,ax1=plt.subplots()
    sb.boxplot(data=values,color=prop_color,showmeans=True, showcaps=True, linewidth=0.7,
               meanline=True,meanprops={"color":colors[0],"linestyle":"--",'linewidth':'1'},
               medianprops={'color':colors[1],'linewidth':'1',"linestyle":"-"},
               flierprops={'marker':'o','markerfacecolor':prop_color,'markeredgecolor':'gray','markeredgewidth':'0.5','markersize':5},
               whiskerprops={'linestyle':':','linewidth':'0.8'},
               )
    ax1.set_xlabel(x)
    ax1.set_ylabel(y)

    # nový graf se stejnou osou x
    ax = ax1.twinx()
    ax.set_ylabel('Počet toků obsahujících n. paket',color='grey',alpha=0.8)
    ax.bar(pole, lengths, color='lightgrey', alpha=0.35, width=0.2)

    #nastavení popisků a legendy
    plt.xticks(pole, labels)
    plt.title(title)
    custom_lines = [Line2D([0], [0], color=colors[0], lw=1.2,linestyle='--'),
                    Line2D([0], [0], color=colors[1], lw=1.2,linestyle='-'),
                    Line2D([0], [0], marker='o',color='w',mfc=prop_color,markeredgecolor='gray',markeredgewidth=0.5,markersize=5)
                    ]
    ax1.legend(custom_lines, ['průměr', 'medián', 'outlier'])

    # nastavení pořadí vykreslených grafů a zprůhlednění pozadí
    ax1.set_zorder(ax.get_zorder() + 1)
    ax1.patch.set_visible(False)
    fig.tight_layout()
    plt.show()

def splt_ipt(loaded,params):

    # získání parametrů a proměnných
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    n_ipt = params.get("n")
    prop_color = params.get("color")
    labels = []
    pole = []
    lengths = []
    splt_t=loaded.get("splt_t")
    n_packet_values = []
    values = []

    # kontrola zadaného počtu mezer k zobrazení, pokud je vyšší než maximální počet,
    # je tento počet považován za zadanou hodnotu
    max_len=len(max(splt_t,key=len))
    if n_ipt > max_len:
        n_ipt = max_len

    # získání pole s popisky a inicializace pole na scaling osy x
    for i in range(n_ipt):
        labels.append(str(i)+'-'+str(i+1)+'')
        pole.append(i)

    # získání hodnot velikostí mezipaketových mezer SPLT
    for j in range(n_ipt):
        for i in range(len(splt_t)):
            try:
                n_packet_values.append(splt_t[i][j])
            except IndexError:
                pass
        values.append(n_packet_values[:])
        n_packet_values.clear()

    # získání hodnot pro graf na pozadí - počet paketů, ze kterého byly údaje vypočítány
    for i in values:
        lengths.append(len(i))

    # základní boxplot
    fig, ax1 = plt.subplots()
    sb.boxplot(data=values,color=prop_color,showmeans=True, showcaps=True,linewidth=0.7,
               meanline=True,meanprops={"color":colors[0],"linestyle":"--",'linewidth':'1'},
               medianprops={'color':colors[1],'linewidth':'1',"linestyle":"-"},
               flierprops={'marker':'o','markerfacecolor':prop_color,'markeredgecolor':'gray','markeredgewidth':'0.5','markersize':5},
               whiskerprops={'linestyle':':','linewidth':'0.8'},
               )
    ax1.set_xlabel(x)
    ax1.set_ylabel(y)

    # nový graf se stejnou osou x
    ax = ax1.twinx()
    ax.set_ylabel('Počet toků obsahujících n. mezeru',color='grey',alpha=0.8)
    ax.bar(pole, lengths, color='lightgrey', alpha=0.35, width=0.2)

    # nastavení popisků a legendy
    if (params.get("rotation")==True):
        plt.xticks(pole, labels)
        ax1.xaxis.set_tick_params(rotation=90)
    else:
        plt.xticks(pole, labels)
    plt.title(title)

    custom_lines = [Line2D([0], [0], color=colors[0], lw=1.2,linestyle='--'),
                    Line2D([0], [0], color=colors[1], lw=1.2,linestyle='-'),
                    Line2D([0], [0], marker='o',color='w',mfc=prop_color,markeredgecolor='gray',markeredgewidth=0.5,markersize=5)
                    ]
    ax1.legend(custom_lines, ['průměr', 'medián', 'outlier'])

    # nastavení pořadí vykreslených grafů a zprůhlednění pozadí
    ax1.set_zorder(ax.get_zorder() + 1)
    ax1.patch.set_visible(False)
    fig.tight_layout()
    plt.show()

def srlt_packets(loaded,params):

    # získání parametrů a proměnných
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    n_packets = params.get("n")
    prop_color = params.get("color")
    labels = []
    pole = []
    lengths = []
    srlt_p = loaded.get("srlt_p")
    n_packet_values = []
    values = []

    if len(srlt_p)!=0:
        # kontrola zadaného počtu paketů k zobrazení, pokud je vyšší než maximální počet,
        # je tento počet považován za zadanou hodnotu
        max_len=len(max(srlt_p,key=len))
        if n_packets > max_len:
            n_packets = max_len

        # získání pole s popisky a inicializace pole na scaling osy x
        for i in range(n_packets):
            labels.append(str(i + 1)+'.')
            pole.append(i)

        # získání hodnot velikostí paketů SRLT
        for j in range(n_packets):
            for i in range(len(srlt_p)):
                try:
                    n_packet_values.append(srlt_p[i][j])
                except IndexError:
                    pass
            values.append(n_packet_values[:])
            n_packet_values.clear()
        for i in values:
            lengths.append(len(i))

        # základní boxplot
        fig, ax1 = plt.subplots()
        sb.boxplot(data=values,color=prop_color,showmeans=True, showcaps=True,linewidth=0.7,
                   meanline=True,meanprops={"color":colors[0],"linestyle":"--",'linewidth':'1'},
                   medianprops={'color':colors[1],'linewidth':'1',"linestyle":"-"},
                   flierprops={'marker':'o','markerfacecolor':prop_color,'markeredgecolor':'gray','markeredgewidth':'0.5','markersize':5},
                   whiskerprops={'linestyle':':','linewidth':'0.8'},
                   )
        ax1.set_xlabel(x)
        ax1.set_ylabel(y)

        # nový graf se stejnou osou x
        ax = ax1.twinx()
        ax.set_ylabel('Počet toků obsahujících n. záznam',color='grey',alpha=0.8)
        ax.bar(pole, lengths, color='lightgrey', alpha=0.35, width=0.2)

        # nastavení popisků a legendy
        plt.title(title)
        plt.xticks(pole, labels)
        custom_lines = [Line2D([0], [0], color=colors[0], lw=1.2,linestyle='--'),
                        Line2D([0], [0], color=colors[1], lw=1.2,linestyle='-'),
                        Line2D([0], [0], marker='o',color='w',mfc=prop_color,markeredgecolor='gray',markeredgewidth=0.5,markersize=5)
                        ]
        ax1.legend(custom_lines, ['průměr', 'medián', 'outlier'])

        # nastavení pořadí vykreslených grafů a zprůhlednění pozadí
        ax1.set_zorder(ax.get_zorder() + 1)
        ax1.patch.set_visible(False)
        fig.tight_layout()
        plt.show()
    else:
        display(Markdown('<h3>Nejsou vybrány žádné toky obsahující SRLT záznamy.</h3>'))

def srlt_ipt(loaded,params):

    # získání parametrů a proměnných
    x = params.get("x")
    y = params.get("y")
    title = params.get("title")
    colors = params.get("colors")
    n_ipt = params.get("n")
    prop_color = params.get("color")
    labels = []
    pole = []
    lengths = []
    srlt_t = loaded.get("srlt_t")
    n_packet_values = []
    values = []

    if len(srlt_t) != 0:
        # kontrola zadaného počtu mezer k zobrazení, pokud je vyšší než maximální počet,
        # je tento počet považován za zadanou hodnotu
        max_len=len(max(srlt_t,key=len))
        if n_ipt > max_len:
            n_ipt = max_len

        # získání pole s popisky a inicializace pole na scaling osy x
        for i in range(n_ipt):
            labels.append(str(i)+'-'+str(i+1)+'')
            pole.append(i)

        # získání hodnot velikostí mezipaketových mezer SRLT
        for j in range(n_ipt):
            for i in range(len(srlt_t)):
                try:
                    n_packet_values.append(srlt_t[i][j])
                except IndexError:
                    pass
            values.append(n_packet_values[:])
            n_packet_values.clear()
        for i in values:
            lengths.append(len(i))

        # základní boxplot
        fig, ax1 = plt.subplots()
        sb.boxplot(data=values,color=prop_color,showmeans=True, showcaps=True,linewidth=0.3,
                   meanline=True,meanprops={"color":colors[0],"linestyle":"--",'linewidth':'1'},
                   medianprops={'color':colors[1],'linewidth':'1',"linestyle":"-"},
                   flierprops={'marker':'o','markerfacecolor':prop_color,'markeredgecolor':'gray','markeredgewidth':'0.5','markersize':5},
                   whiskerprops={'linestyle':':','linewidth':'0.8'},
                   )
        ax1.set_xlabel(x)
        ax1.set_ylabel(y)

        # nový graf se stejnou osou x
        ax = ax1.twinx()
        ax.set_ylabel('Počet toků obsahujících n. mezeru',color='grey',alpha=0.8)
        ax.bar(pole, lengths, color='lightgrey', alpha=0.35, width=0.2)

        # nastavení popisků a legendy
        custom_lines = [Line2D([0], [0], color=colors[0], lw=1.2,linestyle='--'),
                        Line2D([0], [0], color=colors[1], lw=1.2,linestyle='-'),
                        Line2D([0], [0], marker='o',color='w',mfc=prop_color,markeredgecolor='gray',markeredgewidth=0.5,markersize=5)
                        ]
        ax1.legend(custom_lines, ['průměr', 'medián', 'outlier'])
        print(params.get("rotation"))
        if (params.get("rotation")==True):
            plt.xticks(pole, labels)
            ax1.xaxis.set_tick_params(rotation=90)
        else:
            plt.xticks(pole, labels)
        plt.title(title)

        # nastavení pořadí vykreslených grafů a zprůhlednění pozadí
        ax1.set_zorder(ax.get_zorder() + 1)
        ax1.patch.set_visible(False)
        plt.show()
    else:
        display(Markdown('<h3>Nejsou vybrány žádné toky obsahující SRLT záznamy.</h3>'))