from numpy.lib.function_base import meshgrid

#
#  This module is incomplete.
# I eventually discovered that blender has a "grid fill" operator that
# accomplishes something different than I was attempting, but is equally useful.
#

__author__ = 'thoth'
bl_info = {
    "name": "mesh gridify",
    "description": "divide a very large Ngon into lots of squares on a uniform grid",
    "author": "Robert Forsman <blender@thoth.purplefrog.com>",
    "version": (0, 1),
    "blender": (2, 76, 0),
    "location": "3D View > something",
    "warning": "",
    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/something",
    "category": "Mesh",
}



import bpy
import bmesh
from mathutils import *
from math import *


def intersection_for_u(edge, x, matrix, x_axis_index=0):
    """
    :param edge:
    :param x: x coordinate after transformation by matrix
    :param matrix: the transformation matrix to apply to all coordinates
    :return: [co, t] where co is a coordinate along the line, and t is the value corresponding to co = (1-t)edge.verts[0] + t*edge.verts[1]
    """

    v1 = matrix * edge.verts[0].co
    v2 = matrix * edge.verts[1].co

    x1 = v1[x_axis_index]
    x2 = v2[x_axis_index]
    t = (x - x1) / (x2-x1)
    co = (1-t)*edge.verts[0].co + t*edge.verts[1].co
    return co, t

def subdivide_edges(bm, u_axis, v_axis, u_interval, v_interval):

    epsilon = min(u_interval, v_interval) * 0.01

    matrix = Matrix([ u_axis, v_axis, u_axis.cross(v_axis).normalized()])
    matrix.transpose()
    matrix.invert()

    target_edges = [ e for e in bm.edges if e.select ]
    corners = [ e.verts for e in target_edges]
    all_vs = [v_axis.dot( v.co) for v2 in corners for v in v2]
    min_v = min( all_vs )
    max_v = max( all_vs )

    print([min_v, max_v])

    v = v_interval * ceil(min_v/v_interval)

    intersections = []
    for e in target_edges:
        (co, t) = intersection_for_u(e, v, matrix, 1)
        if t>=0 and t<=1:
            # legitimate intersection
            intersections.append( [ co, t, e ])
    print(intersections)

from bpy.props import FloatProperty, BoolProperty, FloatVectorProperty


class MeshGridify(bpy.types.Operator):
    """Add a simple box mesh"""
    bl_idname = "mesh.mesh_gridify"
    bl_label = "Mesh Gridify"
    bl_options = {'REGISTER', 'UNDO'}

    u_interval = FloatProperty(
            name="U interval",
            description="separation between lines on the U axis",
            min=0.01, max=100.0,
            default=1.0,
            )
    v_interval = FloatProperty(
            name="V interval",
            description="separation between lines on the V axis",
            min=0.01, max=100.0,
            default=1.0,
            )

    def execute(self, context):

        if bpy.context.mode != 'EDIT_MESH':
            self.report({'ERROR'}, "active object must be a mesh in edit mode")
            return {'CANCELLED'}

        mesh = bpy.context.active_object.data
        bm = bmesh.from_edit_mesh(mesh)

        u_axis = Vector([1,0,0])
        v_axis = Vector([0,1,0])

        if bpy.context.tool_settings.mesh_select_mode[1]:
            subdivide_edges(bm, u_axis, v_axis, self.u_interval, self.v_interval)
        else:
            self.report({'ERROR'}, "mesh edit mode is not EDGE; we do not support other modes")
            return {'CANCELLED'}

        bmesh.update_edit_mesh(mesh)

        return {'FINISHED'}


#def menu_func(self, context):
#    self.layout.operator(AddBox.bl_idname, icon='MESH_CUBE')


def register():
    bpy.utils.register_class(MeshGridify)
#    bpy.types.INFO_MT_mesh_add.append(menu_func)


def unregister():
    bpy.utils.unregister_class(MeshGridify)
#    bpy.types.INFO_MT_mesh_add.remove(menu_func)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.mesh.mesh_gridify()