#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Aug  5 15:53:16 2019

@author: pavel
"""

"""
    Qt wrapper/container class that handles all the top level events and maintains the
    methods necessary to use the QT signals and slots API.
"""

#from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
from PyQt5 import QtCore, QtGui, QtWidgets
from TubeCanvas import TubeDraw
import numpy as np
#import trimesh as tm

DEBUG = False

class TubeWidget(QtWidgets.QWidget):
    sigUpdate = QtCore.pyqtSignal(float, float, float)
    #Initializes the QT wrapper class.
    def __init__(self):
        super(TubeWidget, self).__init__()
        box = QtWidgets.QVBoxLayout(self)
        self.resize(500,500)
        self.setLayout(box)
        self.canvas = TubeDraw()
        #self.canvas.create_native()
        box.addWidget(self.canvas.native)
        self.camera = [0,0,0]
        self.down = False
        self.other = None

        self.canvas.location = self.geometry().center()
        self.canvas.events.mouse_press.connect(self.on_mouse_press)
        self.canvas.events.mouse_release.connect(self.on_mouse_release)
        self.canvas.events.mouse_move.connect(self.on_mouse_move)
        self.canvas.events.mouse_wheel.connect(self.on_mouse_wheel)

        #self.show()


    def link_cameras(self, o_canvas):
        self.canvas.events.mouse_press.connect(o_canvas.on_mouse_press)
        self.canvas.events.mouse_release.connect(o_canvas.on_mouse_release)
        self.canvas.events.mouse_move.connect(o_canvas.on_mouse_move)
        self.canvas.events.mouse_wheel.connect(o_canvas.on_mouse_wheel)
        
    def set_other(self, other):
        self.other = other
    
    def pass_event(self, event, case):
        if self.other != None:
            if case == 0:
                self.other.canvas.on_mouse_wheel(event)
            if case == 1:
                self.other.canvas.on_mouse_press(event)
            if case == 2:
                self.other.canvas.on_mouse_move(event)
            if case == 3:
                self.other.canvas.on_mouse_release(event)
            #if case == 4:
            #    self.other.sendCameraInfo()
        
        
    #Handles the mouse release event
    def on_mouse_release(self, event):
        self.down=False
        self.sendCameraInfo()
        self.pass_event(event, 3)

    #Handles the mouse move event
    def on_mouse_move(self, event):
        if self.down:
            self.sendCameraInfo()
            self.pass_event(event, 2)

    #Handles the mouse press events
    def on_mouse_press(self, event):
        self.down = True
        if event.button == 2:
            menu = QtWidgets.QMenu(self)
            NS = menu.addAction('Export Model')
            action = menu.exec_(event.native.globalPos())
            if action == NS:
                self.save_stl_mesh()
        else:
            self.pass_event(event, 1)
                

    #Handles the mouse wheel event
    def on_mouse_wheel(self, event):
        self.sendCameraInfo()
        self.pass_event(event, 0)

    #controls the emit function of the QT class to send a signal to the slot
    #located in the other window.
    def sendCameraInfo(self):
        #self.view = self.canvas.view
        self.camera = self.canvas.camera
        #print("stuff", self.view[3, 0], self.view[3, 1], self.view[3, 2])
        if DEBUG:
            print("stuff", self.camera[0], self.camera[1], self.camera[2])
        #self.pass_event(None, 4)
        self.sigUpdate.emit(self.camera[0], self.camera[1], self.camera[2])
        
    """
    Function to receive the signal with the information necessary to visualize
    specific fibers only. With the rest of them being minimized.
    """
    @QtCore.pyqtSlot(list)
    def select(self, x):
        self.canvas.select_edges(x)
#        for e in x:
#            if e in self.canvas.edge_dict:    
#                print(self.canvas.edge_dict[e])
#            elif (e[1], e[0]) in self.canvas.edge_dict:
#                print(self.canvas.edge_dict[(e[1], e[0])])
        print("got signal", x)

    """
        Initialization method that connects the slot to the function that handles
        the information being sent.
    """
    def connect(self, signal_object):
        signal_object.select.connect(self.select)
        
    def save_stl_mesh(self):
        triangles = self.canvas.triangle_data
        caps = self.canvas.cap_data
        points = self.canvas.cylinder_data['a_position']
        colors = self.canvas.cylinder_data['a_fg_color']
        normals = self.canvas.cylinder_data['a_normal']
        
        mesh = tm.Trimesh(vertices=points, faces=np.append(triangles, caps, axis=0),
                          vertex_colors=colors, vertex_normals=normals)
        mesh.export('with_caps.obj')
        mesh.export('with_caps.ply')