import threading 
import sys
import queue
import traceback
from bsread import source, Source, PUB, SUB, PUSH, PULL, DEFAULT_DISPATCHER_URL
from cam_server.pipeline.configuration import PipelineConfig
from cam_server import CamClient, PipelineClient, ProxyClient, config
from cam_server.pipeline.types.processing import run as processing_pipeline
import  multiprocessing
import time
from importlib import reload 

class Namespace(object):
    def __init__(self, **kwds):
        self.__dict__.update(kwds)
    def __repr__(self):
        items = self.__dict__.items()
        temp = []
        for name, value in items:
            if not name.startswith('_'):
                temp.append('%s=%r' % (name, value))
        temp.sort()
        return 'Namespace(%s)' % str.join(', ', temp)

class MockBackgroundManager:
    def __init__(self):
        self.backgrounds = {}

    def get_background(self, background_name):
        if not background_name:
            return None
        if background_name not in self.backgrounds:
            raise ValueError("Requested background '%s' does not exist." % background_name)
        return self.backgrounds[background_name]

    def save_background(self, background_name, image, append_timestamp=True):
        if append_timestamp:
            background_name += datetime.now().strftime("_%Y%m%d_%H%M%S_%f")
        self.backgrounds[background_name] = image
        return background_name

    def get_latest_background_id(self, background_prefix):
        raise NotImplementedError("This cannot work in the mock.")

    def get_background_ids(self, background_prefix):
        raise NotImplementedError("This cannot work in the mock.")        


        
statistics=  Namespace()
pipeline_config = PipelineConfig("test_pipeline", parameters={"camera_name": "simulation", "function":"transparent"})
camera_client = CamClient("http://localhost:8888" )

def dont_exit(status):
    print ("System Exit status: ", status)
sys.exit = dont_exit
    

def run_pipeline(port, pipeline_config, parameter_queue, stop_event):
    print ("Startint pipeline on port: ", port)
    try:
        processing_pipeline(stop_event, statistics, parameter_queue, camera_client, pipeline_config, port, MockBackgroundManager())
    except:
        traceback.print_exc()  


def get_data(port):
    with source(host="127.0.0.1", port=port, mode=SUB, receive_timeout = 3000) as stream:
        data = stream.receive()
        if not data: 
            raise Exception("Received None message.")
        return data.data.data


for port in (5008, 5009):
    print ( "--------------------------------------")
    print ("Port: ", port)
    stop_event = threading.Event()
    parameter_queue = queue.Queue()
    thread = threading.Thread(target=run_pipeline, args=(port,pipeline_config, parameter_queue, stop_event))
    thread.start()
    #data = get_data(port)
    #print ("Received: ", data.keys())
    time.sleep(1.0)
    stop_event.set()
    thread.join(5.0)
    print ("Finished OK")
    time.sleep(2.0)
    from  cam_server.pipeline import utils

    reload(utils)

    




"""  
OUTPUT_PORT = 12008
stop_event = threading.Event()
parameter_queue = queue.Queue()
thread = threading.Thread(target=run_pipeline, args=(OUTPUT_PORT,pipeline_config, parameter_queue, stop_event))
thread.start()'
get_data(OUTPUT_PORT)
stop_event.set()
thread.join(5.0)
print ("Done")
"""