#!/usr/bin/env python3
import bfj

## SPLIT FILES FOR PARALLEL

## IMPORT LIBRARIES
import numpy as np

bfj.load_inputs(globals())

## PUT DATA INTO THE BIG ARRAY

## data 300*18*1681 (time*components*sensors^2)
## points - array with saved points (coordinates)  [0,8,16,24,32,40]
## length - time length - 300
## output - fDataX, fDataY - cubs 3*3 points for morfing, original morfing (target)

def get_array(data, points,length):
    t,l,p2 = data.shape
    t = int(t)
    l = int(l)
    p2 = int(p2)

    p = int(np.sqrt(p2))
    Yset = np.zeros(( l, t, p, p, 1))

    for elements in range(l):
        data_set = data[:,elements,:]
        data_set = np.reshape(data_set,(t,p,p))
        Yset[elements,:,:,:,0] = data_set

    sYset = np.reshape(Yset,(l, int(t/length), length, p, p, 1))
    sYset = np.reshape(sYset,(int(l*t/length), length, p, p, 1))

    wd = int(np.size(points)) - 2  # amount of windows in a row
    num_of_cubs = wd*wd
    wd_size = points[2] + 1    # size of a cell 17*17 or 13*13 or 15*15

    fDataX = np.zeros((int(l*t/length*wd*wd), length, 3, 3, 1))       # SET INPUT
    #fDataY = np.zeros((int(l*t/length*wd*wd), length, wd_size, wd_size, 1))     # SET TARGETS

    nX = np.zeros(( int(l*t/length), length, 3, 3, 1))
    #nY = np.zeros(( int(l*t/length), length, wd_size, wd_size, 1))

    for n in range(wd):
        for nn in range(wd):
            nX[:,:,0,0,:] = sYset[:, :, points[n], points[nn],:]
            nX[:,:,1,1,:] = sYset[:, :, points[n+1], points[nn+1],:]
            nX[:,:,2,2,:] = sYset[:, :, points[n+2], points[nn+2],:]
            nX[:,:,0,1,:] = sYset[:, :, points[n], points[nn+1],:]
            nX[:,:,0,2,:] = sYset[:, :, points[n], points[nn+2],:]
            nX[:,:,1,0,:] = sYset[:, :, points[n+1], points[nn],:]
            nX[:,:,1,2,:] = sYset[:, :, points[n+1], points[nn+2],:]
            nX[:,:,2,1,:] = sYset[:, :, points[n+2], points[nn+1],:]
            nX[:,:,2,0,:] = sYset[:, :, points[n+2], points[nn],:]

            #nY = sYset[:, :, points[n]:(points[n+2]+1), points[nn]:(points[nn+2]+1), :]

            fDataX[int((wd*n+nn)*l*t/length):int((wd*n+nn)*l*t/length + l*t/length), :, :, :, :] = nX
            #fDataY[int((wd*n+nn)*l*t/length):int((wd*n+nn)*l*t/length + l*t/length), :, :, :, :] = nY
    return fDataX, num_of_cubs  #fDataY


# In[3]:


## IMPORT DATA

#file1 = h5py.File('MphS2445.mat','r') ## BACHATA
#data = file1['MphS']

## TAKE SHIFTS ARRAY

#file2 = h5py.File('SH.hdf5','r')
#SH = file2['SH']

## TAKE FIXED SHIFTS ARRAY

#if os.path.isfile('FixSH.hdf5'):   ## check if we have fixed shifts and download
#    file3 = h5py.File('FixSH.hdf5','r')
#    SHf = np.asarray(file3['SH'], dtype=int)
#    SHf_ind = np.asarray(file3['ind'], dtype=int)

#if (Tru == 1) || (Tru ==3):   ## check if we have fixed shifts and download
#    file3 = h5py.File('FixSH.hdf5','r')
#    SHf = np.asarray(file3['SH'], dtype=int)
#    SHf_ind = np.asarray(file3['ind'], dtype=int)


##  EXSTRACT PARAMETERS

length_of_sig, componentsXnum_sensors, start_grid2 = data.shape
length_of_sig = int(length_of_sig)
componentsXnum_sensors = int(componentsXnum_sensors)
start_grid2 = int(start_grid2)
components = 18
num_sensors = int(componentsXnum_sensors/components)
start_grid = np.sqrt(start_grid2)

## GET CUBS

points = np.arange(0, start_grid,dtype=int)
dataX, num_of_cubs = get_array(data, points, length_of_sig)

dataX = np.reshape(dataX,(int(num_of_cubs*components) , num_sensors, length_of_sig, 3, 3))

## split SH and dataX into 886 for parallel
count = 10 # 9!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1

for i in range(886):  #!! num_sensors
        exec("bfj.save_package(label = '{}_{}', meta=dict(instance=instance, count = count, number_of_depth = number_of_depth, depth = depth, xpow = xpow, ypow = ypow, zpow = zpow, xcenter = xcenter, ycenter = ycenter, fd = fd, lmod = lmod, fmin = fmin, fmax = fmax, fbeg = fbeg, fend = fend, L = L, number_of_sensor = {}), data = dict(SH{} = SH[{},:,:,:], dataX{} = dataX[:,{},:,:,:], cr = cr, bin1 = bin1, MphS = MphS, domain_X = domain_X, domain_Y = domain_Y, domain_Z = domain_Z, field = field, field_mphs = field_mphs))".format(depth,i+1,i+1,i+1,i, i+1,i))
        #bfj.save_package(label = '1', meta=dict(instance=instance, count = count, number_of_depth = number_of_depth, depth = depth, xpow = xpow, ypow = ypow, zpow = zpow, xcenter = xcenter, ycenter = ycenter, fd = fd, lmod = lmod, fmin = fmin, fmax = fmax, fbeg = fbeg, fend = fend, L = L, number_of_sensor = {}), data = dict(SH = SH[i,:,:,:], dataX = dataX[:,i,:,:,:], cr = cr, bin1 = bin1, MphS = MphS, domain_X = domain_X, domain_Y = domain_Y, domain_Z = domain_Z, field = field, field_mphs = field_mphs))

#exec("bfj.save_package(meta=dict(instance=instance, number_of_sensor = {}), data = dict(SH{} = SH[{},:,:,:], dataX{} = dataX[:,{},:,:,:]))".format(i+1,i+1,i, i+1,i))


#for i in range(20):  #!! num_sensors
#    with h5py.File('SH'+str(i+1)+'.hdf5', 'w') as f:
#        f.create_dataset( name = 'SH', data=SH[i,:,:,:])

#    with h5py.File('dataX'+str(i+1)+'.hdf5', 'w') as f:
#        f.create_dataset( name = 'dataX', data=dataX[:,i,:,:,:])

#if os.path.isfile('FixSH.hdf5'):   ## only if we have fixed sensors
#if Tru:
#    n_fix_sen = len(SHf_ind)
#    for i in range(n_fix_sen):
#        ind = SHf_ind[i]
#        with h5py.File('SH'+str(ind+1)+'.hdf5', 'w') as f:
#            f.create_dataset( name = 'SH', data=SHf[i,:,:,:])