from ijutils import *
from ch.psi.pshell.imaging.Overlays import *
from ch.psi.pshell.imaging.Utils import *
import ch.psi.pshell.imaging.Pen as Pen
import java.awt.Rectangle as Rectangle
import ch.psi.pshell.imaging.Data as Data
import ch.psi.pshell.device.Camera.DataType as DataType
import ch.psi.utils.Chrono as Chrono
import subprocess
import java.util.Arrays  as Arrays

#GRAB_MIN_TIME = 1000
CONTINOUS_MODE_MIN_TIME = 4000
###############################################################################
# ROI Integration
###############################################################################


def start_eiger_ioc():
    print "IOC started"
    
    

def stop_eiger_ioc():
    print "IOC stopped"   


def integrate_roi(source, x,y, w, h):
    if source.data is None:
        source.update()
    rect = Rectangle(x,y, w, h)
    roi = source.data.getRoi(rect)

    outliers_mask = get_outliers_mask()
    if outliers_mask is not None:
        mask = outliers_mask.getRoi(rect)
        roi.mult(mask)
            
    outliers_threshold = get_outliers_threshold()
    if outliers_threshold>0:
        roi.threshold(outliers_threshold, False, 0.0)    

    return roi.integrate(False)


class RoiIntensitySourceListener (ImageListener):
    def __init__(self, parent):
        self.parent = parent
    def onImage(self, origin, image, data):
        self.parent.update()
    def onError(self, origin, ex):
        pass
        

class RoiIntensity(ReadonlyRegisterBase):
    def __init__(self, name, source, x,y, w, h):
        ReadonlyRegisterBase.__init__(self, name)
        self.source=source
        self.roi = x,y, w, h
        self.source_listener = RoiIntensitySourceListener(self)
        
    def doRead(self):
        x,y, w, h = self.roi
        
        ret= integrate_roi(self.source, x,y, w, h)
        print "Read " + self.name + " -> " + str(ret)
        return ret

    def doSetMonitored(self, value):
        if value:
            self.source.addListener(self.source_listener)
        else:
            self.source.removeListener(self.source_listener)

    def doClose(self):
         self.source.removeListener(self.source_listener)

def create_roi_devices(roi_list, add = True):  
    rois = []
    for r in roi_list:
        roi = RoiIntensity(r, image, roi_list[r][0], roi_list[r][1], roi_list[r][2], roi_list[r][3])
        if add:
            add_device(roi, True)
        rois.append(roi)
    return rois
    
###############################################################################
# Frame integration
###############################################################################
#chrono_grab= Chrono()
def grab_frame(source, roi=None, wait_next=False, outliers_threshold=None, outliers_mask=None, retries=None, timeout=None):  
    global eiger_averaging_number_of_samples #, chrono_grab
    
    #chrono_grab.waitTimeout(GRAB_MIN_TIME)
    if outliers_threshold is None:
         outliers_threshold = get_outliers_threshold()
    if outliers_mask is None:
         outliers_mask = get_outliers_mask()
    if wait_next:
        if retries is None:
            retries = 3
        if timeout is None:
            timeout=10.0
        exposures = 1 if (eiger_averaging_number_of_samples is None) else eiger_averaging_number_of_samples
        retries=max(retries,1)    
        timeout = 5000
        for try_count  in range(retries):                                 
            try:
                start =time.time()
                id = image.take()
                print "Waiting next " 
                source.waitNext(timeout)
                #det.update()
                #time.sleep(1)
                print "Waiting done ", str(time.time()-start), "  ", str(id), "->", str(image.take())
                break
            except java.util.concurrent.TimeoutException:
                if try_count == (retries-1):
                    raise
                msg =  "Eiger timeout - retrying #" + str(try_count)
                print msg
                log(msg)
                
    #ret = load_image(Utils.grayscale(source.output, Rectangle(roi[0], roi[1], roi[2], roi[3]) if (roi is not None) else None))
    time.sleep(0.01)
    data=source.data
    if roi is not None:
        data = data.getRoi(Rectangle(roi[0], roi[1], roi[2], roi[3]))
    #ret = load_image(img)
    if outliers_mask is not None:
        data.mult(outliers_mask)
    if outliers_threshold>0:
        data.threshold(outliers_threshold, False, None)
    #chrono_grab = Chrono()
    return data
    
def grab_frames(source, samples, roi=None, wait_next=False, sleep=0, outliers_threshold=None, outliers_mask=None, retries=None, timeout=None):
    frames = []            
    for i in range(samples):
        if (i>0) and (sleep>0):
            time.sleep(sleep)
        aux = grab_frame(source, roi, wait_next, outliers_threshold, outliers_mask, retries, timeout)        
        frames.append(aux)        
    return frames
    
def integrate_frames(frames):
    if frames is None or (len(frames)==0):
        return None
    ret = frames[0].copy()
    for data in frames[1:]:
        ret.sum(data)
    return ret

f,f1,f2=None, None, None
def average_frames(frames):  
    global f,f1,f2
    f1,f2 = frames
    ret = integrate_frames(frames)
    if ret is not None:
        ret.div(len(frames))    
    f=ret    
    return ret 


def _timestamp(prec=0):
    t = time.time()
    s = time.strftime("%y/%m/%d %H:%M:%S", time.localtime(t))
    if prec > 0:
        s += ("%.9f" % (t % 1,))[1:2+prec]
    return s

def _save_as_tiff(data, filename, check=False, show = False, metadata={}):
    if type(data) == Data:
        ip = load_array(data.matrix)
    else:
        ip = data
    #info = "Timestamp: " + _timestamp(3)
    #for key,val in metadata.items():
    #    info = info + "\n" + str(key) + ": " + str(val)
    #print "Info:" ,info
    #ip.setProperty("Info", info)
    metadata["Timestamp"] = time.strftime("%y/%m/%d %H:%M:%S",time.localtime())
    if not os.path.exists(os.path.dirname(filename)):
        os.makedirs(os.path.dirname(filename))    
    save_image(ip, filename,"tiff", metadata)    

    #finfo = open(filename + ".info", "w")
    #for k, v in metadata.items():
    #    finfo.write(str(k) + ': '+ str(v) + '\n')
    #info.close()    
    
    if check:        
        data = get_ip_array(ip)
        
        ip=open_image(filename)
        read = get_ip_array(ip)        
        if not Arrays.deepEquals(read, data):
            print  "Error checking array"  
    
def save_as_tiff(data, filename, check=False, show = False, parallel=True, metadata={}):
    if parallel:
        return fork((_save_as_tiff,(data, filename, check, show, metadata)),)
    else:
        _save_as_tiff(data, filename, check, show, metadata)

def trigger_eiger(wait=True):
    if wait:
        image.waitNext(20000)

def get_eiger_exposure_readback():
    return 1.0
            
def set_exposure_time(value, check = True, retries=5):
    pass
    
def get_eiger_number_of_frames():
    return 1

def set_eiger_number_of_frames(value, check = True):
    pass
        
    #Wait for channel to chenge

def stop_eiger():
    pass

chrono_eiger = Chrono()

def init_eiger(exposure=None, check=True, retries=2):
    """
    Set Eiger scan mode
    """
    pass
                
def restore_eiger(check=True, retries=2, exposure_time = 0.2):
    """
    Set Eiger default mode
    """
    pass

def is_averaging_detector():
    return False

eiger_averaging_number_of_samples=None

def apply_averaging_detector(value):
    pass
        
    
def average_eiger_frames(samples, roi=None, wait_next=False, sleep=0, outliers_threshold=None, outliers_mask=None, retries=None, timeout=None):
    global eiger_averaging_number_of_samples #, chrono_eiger
    sample = int(samples)
    ret = grab_frames(image, samples, roi, wait_next, sleep, outliers_threshold, outliers_mask, retries, timeout)
    #print "Averaging frames " + str(len(ret)) + " " + str(ret[0].integrate(False)) + " " + str(ret[1].integrate(False)) + " " + str(ret[0].equals(ret[1])) 
    print "Averaging frames " 
              
    av = average_frames(ret) if samples > 1 else ret[0]
    """
    for name,r in ROI.items():
          s, s1, s2 =0.0, 0.0, 0.0
          for i in range(r[2]):
            for j in range(r[3]):
                #s = s + d[r[0]+i][r[1]+j]
                s = s + av.getElement(r[0]+i, r[1]+j, False)
                s1 = s1 + ret[0].getElement(r[0]+i, r[1]+j, False)
                s2 = s2 + ret[1].getElement(r[0]+i, r[1]+j, False)
          
          print "- ", name, s, s1,s2
    """      
    return av


_outliers_mask_timestamp = 0
_outliers_mask = None

def get_outliers_mask(data_type='f'):
    global _outliers_mask_timestamp, _outliers_mask
    
    if get_exec_pars().start == _outliers_mask_timestamp:
        return _outliers_mask
    _outliers_mask_timestamp = get_exec_pars().start 
    try:        
        _outliers_mask = None
        filename = get_outliers_mask_file()
        if filename:
            ip=open_image(filename)
            
            #TRANSPOSE - ImageJ stores the data transposed
            ip.getProcessor().rotate(-90)
            ip.getProcessor().flipVertical()

            array = get_ip_array(ip)
            array = Convert.toPrimitiveArray(array, ScriptUtils.getType(data_type))
            _outliers_mask = Data(array)
            print "Generated outliers mask"
    except:
        pass
    return _outliers_mask


    

if False:  
    integrate_roi(image, 10, 5, 20, 10)
            
    add_device(RoiIntensity("Region1", image, 10, 5, 20, 10), True)
    add_device(RoiIntensity("Region2", image, 10, 5, 40, 20), True)
    
    
    import ch.psi.pshell.data.ProviderCSV as ProviderCSV 
    ProviderCSV.setDefaultItemSeparator(" ")
    tscan((Region1, Region2), 10, 0.1, layout="table", provider = "csv")
    
    ret = grab_frames(image, 10, sleep=0.1)
    av = integrate_frames(ret)
    save_as_tiff(av,"{images}/data.tif", True)


    print "Success"