import signal 
signal.signal = lambda *args: None
################################################################################################### 
#import matplotlib
#matplotlib.use('Qt5Agg') 
import traceback


from bluesky import RunEngine
from bluesky.callbacks.best_effort import BestEffortCallback
from bluesky.utils import install_kicker

from bluesky.utils import ProgressBarManager
from ophyd.sim import det1, det2, det3, det4, det, motor, motor1, motor2, motor3,img, sig, direct_img, pseudo1x3
from ophyd import Signal
from ophyd.signal import EpicsSignal
from bluesky.plans import count, scan, rel_scan, list_scan, grid_scan, list_grid_scan
from bluesky.simulators import summarize_plan
import bluesky.plan_stubs as bps
from bluesky.plan_stubs import mv
import bluesky.preprocessors as bpp
from bluesky.preprocessors import SupplementalData
import databroker
#import suitcase
#import suitcase.csv
#from databroker import Broker


RE = RunEngine({})
bec = BestEffortCallback()
bec.disable_plots()
RE.subscribe(bec)
#db = Broker.named('temp')
#RE.subscribe(db.insert)
#RE.waiting_hook = ProgressBarManager()
dets = [det1, det2]


RE(count(dets, num=5))
RE(scan(dets, motor, -1, 1, 10))
dir (motor)

vel=motor.velocity.get()
motor.velocity.set(vel+1)
RE(scan(dets, motor, -1, 1, 10))
det.read()
det.get()
dets=[det]

RE(rel_scan(dets, motor, -1, 1, 10))

points = [1, 1, 2, 3, 5, 8, 13]
RE(list_scan(dets, motor, points))

dets=[det4]
RE(scan(dets,motor1, -1.5, 1.5,    motor2, -0.1, 0.1,  11)) 
RE(list_scan(dets, motor1, [1, 1, 3, 5, 8], motor2, [25, 16, 9, 4, 1]))
RE(grid_scan(dets, motor1, -1.5, 1.5, 3,      motor2, -0.1, 0.1, 5,  motor3, 10, -10, 5)) 

RE(grid_scan(dets, motor1, -1.5, 1.5, 3,    motor2, -0.1, 0.1, 5))
RE(grid_scan(dets,  motor1, -1.5, 1.5, 3,   motor2, -0.1, 0.1, 5,     motor3, 10, -10, 5)) 

RE(list_grid_scan(dets,  motor1, [1, 1, 2, 3, 5],   motor2, [25, 16, 9]))


db[-1].table()



def coarse_and_fine(detectors, motor, start, stop):
    yield from scan(detectors, motor, start, stop, 10)
    yield from scan(detectors, motor, start, stop, 100)
    RE(coarse_and_fine(dets, motor, -1, 1))

# Move motor1 to 1 and motor2 to 10, simultaneously. Wait for both to arrive.
RE(mv(motor1, 1, motor2, 10))
print (motor1.get().readback, motor2.get().readback) 

# Move motor1 to 1 and motor2 to 10, simultaneously. Wait for both to arrive.
print (motor1.get(), motor2.get()) 
def move_then_count():
    yield from mv(motor1, 1, motor2, 10)
    yield from count(dets)
RE(move_then_count())


sd = SupplementalData()
RE.preprocessors.append(sd)
sd.baseline = [det1, det2, det3, motor1, motor2]
RE(scan([det], motor, -1, 1, 5))
print(db[-1].table("baseline"))
print(db[-1].table("primary"))


"""
docs = db[-1].documents(fill=True)
try:
   suitcase.csv.export(docs, "~/data/bluesky")
except:
    print (sys.exc_info()[1])
"""

motor.delay = 1.1  # simulate slow motor movement
sd.monitors=[motor]
RE(scan(dets, motor, -1, 1, 10))
print(db[-1].table("baseline"))
print(db[-1].table("monitor"))


#RE.resume()
#RE.abort()
#RE.stop() 


RE(scan([det], motor, 1, 10, 10), user="alex")
for x in db(user="alex"):
    print (x.table())

    
summarize_plan(count([det], 3))
summarize_plan(scan(dets, motor, -1, 1, 10))
summarize_plan(grid_scan(dets,    motor1, -1.5, 1.5, 3,  motor2, -0.1, 0.1, 5))


def one_run_one_event(detectors):

    md = {
        # Human-friendly names of detector Devices (useful for searching)
        'detectors': [det.name for det in detectors],

        # The Python 'repr's each argument to the plan
        'plan_args': {'detectors': list(map(repr, detectors))},

        # The name of this plan
        'plan_name': 'one_run_one_event',
    }
    @bpp.stage_decorator(detectors)
    @bpp.run_decorator(md=md)
    def inner():
        yield from bps.trigger_and_read(detectors)

    return (yield from inner())
    
dets = [det1,det2]     
RE(one_run_one_event(dets))


def conditional_break(threshold):
    """Set, trigger, read until the detector reads intensity < threshold"""

    @bpp.stage_decorator([det, motor])
    @bpp.run_decorator()
    def inner():
        i = 0
        while True:
            yield from bps.mv(motor, i)
            readings = yield from bps.trigger_and_read([det])
            if readings['det']['value'] < threshold:
                break
            i += 1
    return (yield from inner())
    
RE(conditional_break(0.2))

#catalog = databroker.catalog()

dets=[pseudo1x3]
RE(scan(dets, motor, -1, 1, 10))

es = EpicsSignal("TESTIOC:TESTSINUS:SinCalc")
print (es.read())


try:
    plot(direct_img.read()['img']['value'].data)

except:
    traceback.print_exc()