#!/usr/bin/env python3
import scanpy as sc
import sys
import struct
import argparse
import scipy

def write_header(f,o, sparse = 0):
    f.write(b'tidx')
    rows = o.var.index.values # row genes
    cols = o.obs.index.values # col cells
    rl = len(rows)
    cl = len(cols)
    byte_rl = rl.to_bytes(8,"little")
    byte_cl = cl.to_bytes(8,"little")
    f.write(byte_rl)
    f.write(byte_cl)
    # TODO if Sparse ...
    if sparse == 0:
        f.write(b'\x04')  # float type test should 04
    else:
        f.write(b'\x04')

    if sparse == 0:
        f.write(b'\x00')
    elif sparse == 4:
        f.write(b'\x04')
    elif sparse == 8:
        f.write(b'\x08')
    else:
        f.write(b'\x00')
    f.write(b'\x01') # row query enable
    f.write(b'\x00') # col query not available
    f.write(b'\x10') # float resolution 16
    f.write(b'\x00\x00\x00') # reserved
    rnames = " ".join(rows)
    cnames = " ".join(cols)
    rnames_l = len(rnames)
    cnames_l = len(cnames)
    f.write(rnames_l.to_bytes(8,"little"))
    f.write(cnames_l.to_bytes(8,"little"))
    f.write(bytearray(rnames.encode()))
    f.write(bytearray(cnames.encode()))

def write_dense_tidx(f,o):
    write_header(f,o,0)
    f.write(o.X.T.tobytes())

def write_sparse_tidx(f,o):
    write_header(f,o,4)
    X = o.X.T
    l=0
    print(X)
    r=len(X)
    c=len(X[0])
    rcounts = [0 for i in range(0,r)]
    for i in range(0,r):
        for j in range(0,c):
            if (X[i][j] > 0):
                rcounts[i]+=1
                l+=1
    print(l)
    for v in rcounts:
        b=v.to_bytes(4,"little")
        f.write(b)
    indexes = [0 for i in range(l)]
    values = [0.0 for i in range(l)]
    i0=0
    for i in range(0,r):
        for j in range(0,c):
            if (X[i][j] > 0):
                indexes[i0] = j
                values[i0] = X[i][j].item()
                i0+=1
    for v in indexes:
        b=v.to_bytes(4,"little")
        f.write(b)
    for v in values:
        b=bytearray(struct.pack("f",v))
        f.write(b)
def write_sparse_tidx_from_sparse(f,o):
    write_header(f,o,4)
    X = o.X.T
    #print(X)
    print(X.shape)
    r=X.shape[0]
    c=X.shape[1]
    l=X.getnnz()
    print(l)

    rcounts = [0 for i in range(0,r)]
    indexes = [0 for i in range(l)]
    values = [0.0 for i in range(l)]
    j0=0
    print("created")

    for i in range(r):
        print(i,"/",r)
        row = X.getrow(i)
        rl = row.getnnz()
        rcounts[i]=rl
        for j in range(len(row.indices)):
            indexes[j0] = row.indices[j].item()
            values[j0] = row.data[j].item()
            j0+=1
        if (j0 % 10000==0):
            print(j0)
    print(j0)

    for v in rcounts:
        b=v.to_bytes(4,"little")
        f.write(b)
    for v in indexes:
        b=v.to_bytes(4,"little")
        f.write(b)
    for v in values:
        b=bytearray(struct.pack("f",v))
        f.write(b)


def parse_args():
    parser = argparse.ArgumentParser(description='Convert h5ad to tidx file')
    parser.add_argument('input', metavar='input', type=str,
                    help='input h5ad file')
    parser.add_argument('output', metavar='output', type=str,
                    help='output tidx file')

    parser.add_argument('-s', dest='sparse', action='store_true',help='if output sparse matrix')
    args = parser.parse_args()
    return args

def main():
    args = parse_args()
    print(args)
    input0 = args.input
    output0 = args.output
    print("Start...")
    print(output0)
    fout = open(output0,"wb")
    o = sc.read(input0)
    print(o)
    # TODO Check Sparse
    if scipy.sparse.issparse(o.X):
        print("input is sparse, TODO")
        write_sparse_tidx_from_sparse(fout,o)
    elif args.sparse:
        print("sparse")
        write_sparse_tidx(fout,o)
    else:
        print("dense")
        write_dense_tidx(fout,o)
    fout.flush()
    fout.close()



if __name__ == "__main__":
    main()
