def gda2csv(gda, dest):
    if isinstance(gda, basestring):
        with open(gda, 'rb') as f:
            gda, header = gff4.read_gff4(f)
    elif not isinstance(gda, gff4.Structure):
        gda, header = gff4.read_gff4(gda)

    close = False
    if isinstance(dest, basestring):
        f = open(dest, 'wb')
        close = True

    try:
        csvw = csv.writer(f)
        csvw.writerow([colname(col) for col in gda[10002]])
        csvw.writerow([coltypes[col[10999]] for col in gda[10002]])
        for row in gda[10003]:
            csvw.writerow([colvalue(v) for k, v in sorted(row.iteritems())])
    finally:
        if close:
            f.close()
                n = data[index]
                shift = 0
        if e == -1:
            break
        sb.append(unichr(-e - 1))
    return sb.tounicode()

def _dump(htlk, out):
    table = htlk[19007]
    e = len(table) / 2 - 1
    for n in htlk[19008]:
        for bit in xrange(32):
            e = table[e * 2 + (n & 1)]
            n >>= 1
            if e < 0:
                out.write(unichr(-e - 1).encode('utf_16le'))
                e = len(table) / 2 - 1
    

if __name__ == '__main__':
    from gff4 import read_gff4, write_gff4
    import sys
    
    with open(sys.argv[1], 'rb') as f:
        g, h = read_gff4(f)
    
    tlk = htlk2tlk(g)
    
    with open(sys.argv[2], 'wb') as f:
        write_gff4(f, tlk, tlkheader)
        return '$%08x' % col[10001]


coltypes = {
    0: 'string',
    1: 'int',
    2: 'float',
    3: 'bool',
    4: 'resource',
}


def colvalue(v):
    if v is None:
        return '****'
    elif isinstance(v, unicode):
        return v.encode('utf_8')
    else:
        return v


with open(sys.argv[1], 'rb') as f:
    gff, header = gff4.read_gff4(f)

with open(sys.argv[2], 'wb') as f:
    csv = csv.writer(f)
    csv.writerow([colname(col) for col in gff[10002]])
    csv.writerow([coltypes[col[10999]] for col in gff[10002]])
    for row in gff[10003]:
        csv.writerow([colvalue(v) for k, v in sorted(row.iteritems())])
            Structrows = gff4._structtype(rowtype.fourcc, rowtype.fields, rowtype.size)
            field10003 = gff4.Field(field.label, gff4._listtype(Structrows, False), False, field.offset)
        elif field.label == 10002:
            field10002 = gff4.Field(field.label, ListStructcolm, False, field.offset)
    Structgtop = gff4._structtype(header.structs[0].fourcc, (field10002, field10003), header.structs[0].size)
    header = header._replace(structs=(Structgtop, Structcolm, Structrows))
    
    gtop = Structgtop()
    colms = gtop[10002]
    existing = []
    for colm in data[10002]:
        colm = Structcolm(colm)
        if not colm[10000]:
            colname = lookupcolname(colm[10001], cache)
            if colname is not None:
                colm[10000] = colname
        else:
            existing.append(colm[10000])
        colms.append(colm)
    gtop[10003].extend(Structrows(row) for row in data[10003])
    addnames(existing)
    
    return gtop, header

if __name__ == '__main__':
    import sys
    with open(sys.argv[1], 'rb') as f:
        g, h = gff4.read_gff4(f)
    
    annotate(g, h)
    gff4._DEBUG_COMPARISONS = True

    t = clock()
    with open(filename, 'rb') as f:
        mem = StringIO(f.read())
    print 'file read in %.2f seconds' % (clock() - t)

    t = clock()
    gff = LazyGFF4(mem)
    data, header = gff.root, gff.header
    print 'data loaded in %.2f seconds' % (clock() - t)

    #from gff4.toyaml import gff2yamlevents
    #import yaml
    #yaml.emit(gff2yamlevents(data, header, True), sys.stdout)

    t = clock()
    hold = StringIO()
    write_gff4(hold, data, header)
    print 'data dumped in %.2f seconds' % (clock() - t)

    t = clock()
    hold.seek(0)
    data2, header2 = read_gff4(hold)
    print 'data reloaded in %.2f seconds' % (clock() - t)

    t = clock()
    if data != data2:
        print 'data dumped is not the same as that that was loaded'
    print 'data compared in %.2f seconds' % (clock() - t)