from Togra import *
from TograUtil import *
import math
import sys
import random
#import Tracker
from OpenGL.GL import *
import time

GLUT_SHIFT_KEY = 1
GLUT_CTRL_KEY = 2
GLUT_ALT_KEY = 4

size = int(sys.argv[2])
density = float(sys.argv[3])
schema = []
for i in range(size):
	st = []
	for j in range(size):
		if random.random() * 100 < density:
			st.append(1)
		else:
			st.append(0)
	schema.append(st)


XS=20
YS=20
ZS=20


PROP = float(sys.argv[1])

connections = []

def f_rend(time):
	for t in connections:
		p1 = t[0].getPosition()
		p2 = t[1].getPosition()
		glBegin(GL_LINES)
		glVertexd(p1[0], p1[1], p1[2])
		glVertexd(p2[0], p2[1], p2[2])
		glEnd()


def f_compile():
	return 0

msel = Material(ambient=(1,0,0,1))
munsel = Material(ambient=(0,0,1,1))
is_pressed = 0
last_x = 0
last_y = 0
oldsel = []
dest_pos = []

def mouseFunc(*args):
	global is_pressed, last_x, last_y, oldsel, dest_pos, pm
	is_pressed = args[1]
	if not is_pressed:
		pm.setSelected(None, None)
		return
	last_x = args[2]
	last_y = args[3]
	items = scene.pick(args[2], args[3])
	item = None
	for item in items:
		if item[2] is not None:
			if type(item[2]) is not type(Container()):
				break
	if not args[4] & GLUT_SHIFT_KEY:
		for olditem in oldsel:
			olditem.setMaterial(munsel)
		oldsel = []
		dest_pos = []
		
	if item is None:
		return

	item[2].setMaterial(msel)
	oldsel.append(item[2])
	dest_pos.append(item[2].transformContainer[1].getPosition())
	selTCs = map(lambda a: a.transformContainer[1], oldsel)
	pm.setSelected(selTCs, dest_pos)
				

def motionFunc(*args):
	global is_pressed, last_x, last_y, dest_pos, oldsel
	if not is_pressed:
		return
	difx = args[0] - last_x
	dify = args[1] - last_y
	last_x = args[0]
	last_y = args[1]
	ratio = scene.view_from[2] / -700.0
	if len(oldsel) == 0:
		return
	rvec = Vector(difx*ratio, dify*ratio, 0)
	dest_pos = map(lambda a: a - rvec, dest_pos)
	selTCs = map(lambda a: a.transformContainer[1], oldsel)

	pm.setSelected(selTCs, dest_pos)
	#pd = dest_pos[item] - p
	#f = 100
	#g.addForce(Vector(f*pd[0],f*pd[1],f*pd[2]))
	

scene = init()

pm = CustomGraphMixin()

pr = ProtoRender()
pr.setRender(f_rend)
pr.setCompile(f_compile)

ode = ODEMixin()

scene.addMixin(pm)
scene.addMixin(ode)
ode.setGravity(Vector(0,0,0))

scene.setBackgroundColour(0,0,0)

scene.view_from = Vector(0,0,-160)
#t = Tracker.initTracker(scene)

sel = -1
mat = Material(ambient=(0.5,0.5,0.5,1))
selmat = Material(ambient=(1,0,0,1))
activemat = Material(ambient=(0,0,1,1))
selactivemat = Material(ambient=(1,0,1,1))

seld = []

def key_pressed(key):
	global knobs, sel, mat, selmat, d, seld, scene
	if key == ord('n'):
		if sel > -1:
			if sel in seld:
				knobs[sel][0].setMaterial(selmat)
			else:
				knobs[sel][0].setMaterial(mat)
		sel += 1
		if sel == len(knobs):
			sel = 0
		if sel in seld:
			knobs[sel][0].setMaterial(selactivemat)
		else:
			knobs[sel][0].setMaterial(activemat)
	elif key == ord('s'):
		if sel == -1:
			return
		try:
			p = seld.index(sel)
		except:
			p = -1
		if p == -1:
			seld.append(sel)
			knobs[sel][0].setMaterial(selactivemat)
		else:
			seld = seld[:p] + seld[p+1:]
			knobs[sel][0].setMaterial(activemat)
	
	elif key == ord('d'):
		for s in seld:
			pm.removeObjectConnections(s)
	elif key == ord('c'):
		px = random.random() * XS - XS/2
		py = random.random() * YS - YS/2
		pz = random.random() * ZS - ZS/2
		knobs.append(ODESphere(1, 1, Vector(px, py, pz), 
				Vector(0,0,0), 30, 30))
		scene.baseContainer.append(knobs[-1][0])
		for s in oldsel:
			connect(knobs[-1][1], s.transformContainer[1])
	elif key == ord('k'):
		for s in seld:
			if s == sel:
				knobs[s][0].setMaterial(activemat)
			else:
				knobs[s][0].setMaterial(mat)
			seld = []
	elif key == ord('j'):
		if not len(oldsel) == 2:
			return
		k0 = oldsel[0].transformContainer[1]
		k1 = oldsel[1].transformContainer[1]
		connect(k0,k1)
	elif key == ord('D'):
		return
		schema = []
		for i in range(len(knobs)):
			sr = []
			for j in range(len(knobs)):
				if j <= i:
					sr.append(0)
				else:
					sr.append(0)
					for item in d[knobs[i][1]]:
						if item == knobs[j][1]:
							sr[-1] = 1
							break
			schema.append(sr)
		if fname is None:
			print schema
		else:
			f = open(fname + ".py",'w')
			f.write("schema = " + str(schema))
			f.close()
		

pauseQuitKeystrokes(scene, key_pressed)
scene.mouseFunction = mouseFunc
scene.motionFunction = motionFunc

scene.newLight(Vector(-10,10,0), (0.8,0.2,0.2,1))
scene.newLight(Vector(20,0,-10), (0.2,0.2,0.8,1))

def ODESphere(density, radius, position, velocity, segs, stacks):
	global i
        t = sphere(0, 0, 0, radius, segs, stacks)
        o = ODETransform(ode)
        o.setSphere(density, radius)
        o.setPosition(position)
        o.setVelocity(velocity)
        t.transformContainer.append(o)
	t.setMaterial(munsel)
	graph.addNode(o)
        return (t, o)

graph = Graph()

def connect(a, b):
	global pm
	graph.addConnection(a, b, 8, 10)
	connections.append((a, b))

knobs = []
for item in schema:
	px = random.random() * XS - XS/2
	py = random.random() * YS - YS/2
	pz = random.random() * ZS - ZS/2
	knobs.append(ODESphere(1, 1, Vector(px, py, 0), Vector(0,0,0), 30, 30))

for i in range(len(schema)):
	for j in range(i + 1, len(schema)):
		if schema[i][j]:
			connect(knobs[i][1], knobs[j][1])

for i in range(graph.getNumGroups()):
	nodes = graph.getGroupNodes(i)
	
        dd = 100 / math.sqrt(len(nodes))
        tt = random.random() * 2 * math.pi
        px = dd * math.cos(tt)
        py = dd * math.sin(tt)
	
	for node in nodes:
		ppy = py + random.random() * YS - YS/2
		ppx = px + random.random() * XS - XS/2
		node.setPosition(Vector(ppx, ppy, 0))

	

for knob in knobs:
	scene.baseContainer.append(knob[0])

pm.setGraph(graph)

#scene.baseContainer.transformContainer.append(t)
scene.baseContainer.append(pr)

scene.run()