import bpy
import bmesh
from mathutils import Vector, Matrix
from bpy_extras import mesh_utils
from .utils import bound_box_center, contour_loops, get_object_color


def get_picker_datas(objects, canvas, rig):
    picker_datas = []
    gamma = 1 / 2.2

    if canvas.type =='CURVE':
        canvas_points = canvas.data.splines[0].points
    else:
        canvas_points = canvas.data.vertices
    
    canvas_coords = [canvas.matrix_world@Vector((p.co)) for p in canvas_points]

    canvas_x = [p[0] for p in canvas_coords]
    canvas_y = [p[1] for p in canvas_coords]

    canvas_center = sum(canvas_coords, Vector()) / len(canvas_coords)
    canvas_scale_fac = 4096 / (max(canvas_y) - min(canvas_y))# Reference height for the canvas

    objects.append(canvas)

    dg = bpy.context.evaluated_depsgraph_get()

    #sorted by their z axes
    for ob in sorted(objects, key=lambda x: bound_box_center(x)[2]):
        

        print('Storing shape', ob.name)
        mesh = bpy.data.meshes.new_from_object(ob.evaluated_get(dg))

        bm = bmesh.new()
        bm.from_mesh(mesh)
        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.002)
        bmesh.ops.dissolve_limit(bm, angle_limit=0.001745, verts=bm.verts, edges=bm.edges)

        bmesh.ops.connect_verts_concave(bm, faces=bm.faces)
        bmesh.ops.triangulate(bm, faces=bm.faces)

        #bm_loops = contour_loops(bm)
        #loops = [[l.index for l in loop] for loop in bm_loops]
        loops = []

        edges = [[v.index for v in e.verts] for e in bm.edges if len(e.link_faces)<=1]

        bm.to_mesh(mesh)
        mesh.update()
        bm.clear()

        points = []
        #edges = []
        polygons = []

        for p in mesh.vertices:
            point = ob.matrix_world@Vector((p.co))
            point = (point - canvas_center) * canvas_scale_fac
            points.append([round(point[0]), round(point[1])])

        for f in mesh.polygons:
            polygons.append([v for v in f.vertices])

        #for e in mesh.edges:
        #    
        #    edges.append([v for v in e.vertices])

        color = get_object_color(ob)
        if color:
            color = [round(pow(c, gamma), 4) for c in color]
        else:
            color = [0.5, 0.5, 0.5]

        shape = {
            'source_name': ob.name,
            'tooltip': ob.rig_picker.name,
            'points': points, 
            'polygons': polygons,
            'edges': edges,
            'loops': loops,
            'color': color,
            'type': 'CANVAS' if ob == canvas else ob.rig_picker.shape_type
        }

        if shape['type'] =='OPERATOR':
            shape['operator'] =  ob.rig_picker.operator
            #if ob.rig_picker.arguments:
            #shape['arguments'] = ob.rig_picker.arguments
            #if ob.rig_picker.shortcut:
            shape['shortcut'] = ob.rig_picker.shortcut

        elif shape['type'] =='BONE':
            shape['bone'] =  ob.rig_picker.name

        picker_datas.append(shape)


    #print(picker_datas)

    return picker_datas
    #rig.data.rig_picker['shapes'] = picker_datas