import numpy as np
import random

import sfctss
from sfctss.scheduler.examples import LoadUnawareRoundRobinScheduler

rand = random.Random()
rand.seed(42) # seed the experiment

sim = sfctss.simulator.Sim(seed=rand.randint(0,1000000))


# create a link latency distribution that is used to connect between SFFs-SFIs
LATENCY_SFF_SFI = 1
sfctss.model.SFF.setup_latency_distribution(sim=sim, 
                                            id=LATENCY_SFF_SFI, 
                                            values=np.random.poisson(500, 5000)) # 3000µs

# create a link latency distribution that is used to connect between SFFs-SFFs
LATENCY_SFF_SFF = 2
sfctss.model.SFF.setup_latency_distribution(sim=sim, 
                                            id=LATENCY_SFF_SFF,
                                            values=np.random.poisson(3000, 5000)) # 3000µs

# initialize data structures, configure number of sf types
sfctss.model.SFI.init_data_structure(sim=sim, 
                                     number_of_sf_types=1, 
                                     latency_provider_sff_sfi=LATENCY_SFF_SFI)

# at least one SFF with a scheduler instance
scheduler_a = LoadUnawareRoundRobinScheduler(sim=sim,
                                             incremental=True, # schedule one step of a chain per scheduling attempt
                                             oracle=True) # scheduler has a global view (all sites)
sff_a = sfctss.model.SFF(sim=sim, 
                         scheduler=scheduler_a)

# at least one Server with a SFI that is connected to the SFF
server = sfctss.model.Server(sim=sim, 
                             processing_cap=120, 
                             cpu_policy=sfctss.model.ServerCpuPolicy.one_at_a_time)
server.add_sfi(of_type=1, 
               with_sff_id=sff_a.id)

# do the same for ssf_b ...
scheduler_b = None # ...
sff_b = None # ...

# configure connections between SFFs
sfctss.model.SFF.setup_connection(sim=sim, 
                                  source_id=sff_a.id, 
                                  destination_id=sff_b.id,
                                  bw_cap=100000,
                                  latency_provider=LATENCY_SFF_SFF,
                                  bidirectional=True)           

# configure processing speed of sf types
# the rate gives the number of packets a sfi of this sf type can process in 1 s when using 1 cpu share
sfctss.model.SFI.setup_sf_processing_rate_per_1s(sim=sim, 
                                                 of_type=1, 
                                                 with_mu=100)

# create at least one packet generator (which could also replay a pcap)
wl_config = sfctss.workload.SyntheticWorkloadGenerator.get_default_config()
wl_gen = sfctss.workload.SyntheticWorkloadGenerator(sim=sim,
                                                    workload_rand=rand,
                                                    config=wl_config)
sim.register_packet_generator(packet_generator=wl_gen,
                              fetch_all=False)

# finally, start simulation
sim.run_sim(show_progress=True, # print progress on bash
            interactive=False, # no interactive mode
            max_sim_time=1500000, # we stop after 1.5s
            ui=False, # do not show bash ui
            stop_simulation_when_workload_is_over=True) # stop when max_sim_time is done or when workload is done