# -*- coding: utf-8 -*-

"""
***************************************************************************
    
    ---------------------
    Date                 : 27.03.2018
    Copyright            : (C) 2018 by Benjamin Jakimow
    Email                : benjamin jakimow at geo dot hu-berlin dot de
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""
# noinspection PyPep8Naming
import sys, os, re, collections
from qgis import *
from qgis.core import *
from qgis.gui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *

import pyqtgraph.opengl as gl
from pyqtgraph import functions as fn
from OpenGL.GL import *
import OpenGL.GLUT
from pyqtgraph.opengl import *
from pyqtgraph.opengl.GLGraphicsItem import GLGraphicsItem
from pyqtgraph.Vector import Vector

from eotimeseriesviewer.temporalprofiles import *



DT_SELECTION = 200
class AxisGrid3D(GLGraphicsItem):

    def __init__(self, *args, **kwds):
        super(AxisGrid3D, self).__init__(*args, **kwds)
        self.antialias = True
        self.mRangesMin = np.asarray([0,0,0], dtype=np.float64)
        self.mRangesMax = np.asarray([1,1,1], dtype=np.float64)
        self.mSteps = np.asarray([10,10,10], dtype=np.int)
        self.mVisibility = np.ones((3), dtype=np.bool)
        self.mColor = QColor('grey')
        self.mDims = ['xy', 'xz', 'yz']
    def setColor(self, color):
        self.mColor = QColor(color)



    def set(self, dim, v0=None, v1=None, steps=None, visible=None, skipUpdate=False):
        assert isinstance(dim, str)
        dim = dim.lower()
        assert dim in self.mDims
        i = self.mDims.index(dim)
        if v0 is not None:
            self.mRangesMin[i] = v0

        if v1 is not None:
            self.mRangesMax[i] = v1

        if isinstance(steps, int):
            self.mSteps[i] = steps

        if isinstance(visible, bool):
            self.mVisibility[i] = visible

        if not skipUpdate:
            self.update()

    def setXY(self, **kwds):
        self.set('xy', **kwds)

    def setXZ(self, **kwds):
        self.set('xz', **kwds)

    def setYZ(self, **kwds):
        self.set('yz', **kwds)


    def setMinRanges(self, ranges):
        self.mRangesMin[:] = ranges

    def setMaxRanges(self, ranges):
        self.mRangesMax[:] = ranges


    def paint(self):
        self.setupGLState()

        if self.antialias:
            glEnable(GL_LINE_SMOOTH)
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
            glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)

        glBegin(GL_LINES)

        #T = self.transform()

        #origin of axis values
        valMin = Vector(*self.mRangesMin)

        #max extent of axis values
        valMax = Vector(*self.mRangesMax)
        valRange = valMax - valMin
        if valRange.x() <= 0:
            valRange.setX(1)
        if valRange.y() <= 0:
            valRange.setY(1)
        if valRange.z() <= 0:
            valRange.setZ(1)
        stepSize = valRange / Vector(self.mSteps)

        valuesX = np.arange(valMin.x(), valMax.x()+1.00001*stepSize.x(), stepSize.x())
        valuesY = np.arange(valMin.y(), valMax.y()+1.00001*stepSize.y(), stepSize.y())
        valuesZ = np.arange(valMin.z(), valMax.z()+1.00001*stepSize.z(), stepSize.z())


        c = fn.glColor(self.mColor)
        glColor4f(*c)


        if self.mVisibility[0]: #show XY
            for x in valuesX:
                glVertex3f(x, valuesY[0], valMin.z())
                glVertex3f(x, valuesY[-1], valMin.z())
            for y in valuesY:
                glVertex3f(valuesX[0],  y, valMin.z())
                glVertex3f(valuesX[-1], y, valMin.z())

        if self.mVisibility[1]:  # show XZ
            for x in valuesX:
                glVertex3f(x, valMin.y(), valuesZ[0])
                glVertex3f(x, valMin.y(), valuesZ[-1])
            for z in valuesZ:
                glVertex3f(valuesX[0], valMin.y(), z)
                glVertex3f(valuesX[-1], valMin.y(), z)

        if self.mVisibility[2]:  # show YZ
            for y in valuesY:
                glVertex3f(valMin.x(), y, valuesZ[0])
                glVertex3f(valMin.x(), y, valuesZ[-1])
            for z in valuesZ:
                glVertex3f(valMin.x(), valuesY[0], z)
                glVertex3f(valMin.x(), valuesY[-1], z)


        glEnd()


class Label3D(GLGraphicsItem):

    def __init__(self, label='', *args, **kwds):
        super(Label3D, self).__init__(*args, **kwds)
        self.mLabel = label
        self.mIsVisible = True

        self.mPos =np.asarray([0,0,0], dtype=np.float)

    def setPos(self, x,y,z):
        self.mPos[0] = x
        self.mPos[1] = y
        self.mPos[2] = z


    def setText(self, text):
        assert isinstance(text, str)
        self.mLabel = text
    def text(self):
        return self.mLabel

    def setVisible(self, b):
        assert isinstance(b, bool)
        self.mIsVisible = b
        self.update()

    def isVisible(self):
        return self.mIsVisible

    def paint(self, *args, **kwds):

        s = ""

        if False:
            self.setupGLState()

            #glBegin(GL_LINES)
            glEnable(GL_LINE_SMOOTH)
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
            glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)

            #glBegin(GL_LINES)

            glPushMatrix()
            x,y,z= self.mPos
            glTranslatef(1,0,0)
            #glScale()
            from OpenGL.GLUT import glutStrokeCharacter,glutStrokeWidth, GLUT_STROKE_ROMAN
            w = 0
            text = self.mLabel.encode('utf-8')
            for c in text:
                w += glutStrokeWidth(GLUT_STROKE_ROMAN, c)
            glRotate(1,0,1,0)
            glScale(0.1,0.1,0.1)
            glTranslatef(-w / 2., -w/5., -w/2.)
            for c in text:
                glutStrokeCharacter(GLUT_STROKE_ROMAN, c)

            glPopMatrix()


            #glEnd()

class ViewWidget3D(GLViewWidget):

    def __init__(self, parent=None):
        super(ViewWidget3D, self).__init__(parent)
        self.mousePos = QPoint(-1, -1)
        self.setBackgroundColor(QColor('black'))
        self.setMouseTracking(True)

        self.mDataMinRanges = np.asarray([0, 0, 0])
        self.mDataMaxRanges = np.asarray([1, 1, 1])
        self.mDataSpan = self.mDataMaxRanges - self.mDataMinRanges

        self.mScale = np.asarray([1.,1.,1.])

        self.mDataN = 0

        self.glAxes = Axis3D()
        from pyqtgraph.Transform3D import Transform3D
        self.mItemTransformation = Transform3D()
        #self.glGridItemXY = AxisGrid3D()
        #self.glGridItemXZ = AxisGrid3D()
        #self.glGridItemYZ = AxisGrid3D()
        self.glGridItem = AxisGrid3D()
        #self.glGridItemXZ.setVisible(False)
        #self.glGridItemYZ.setVisible(False)

        x, y, z = self.glAxes.size()

        #self.glGridItemYZ.rotate(-90, 0, 1, 0)
        #self.glGridItemXZ.rotate( 90, 1, 0, 0)

        # self.glGridItemXY.scale(x/10,y/10, 1)
        # self.glGridItemXZ.scale(x/10,z/10, 1)
        # self.glGridItemYZ.scale(y/10,z/10, 1)

        #self.mBasicItems = [self.glGridItemXY, self.glGridItemXZ, self.glGridItemYZ, self.glAxes]
        self.mBasicItems = [self.glAxes, self.glGridItem]
        for item in self.mBasicItems:
            if item == self.glAxes:
                item.setDepthValue(-10)
            else:
                item.setDepthValue(0)

            self.addItem(item)  # draw grid/axis after surfaces since they may be translucent


    """
    def setDataRangeX(self, x0, x1):
        assert x0 < x1
        self.mDataMinRanges[0] = x0
        self.mDataMaxRanges[0] = x1

    def setDataRangeY(self, y0, y1):
        assert y0 < y1
        self.mDataMinRanges[0] = y0
        self.mDataMaxRanges[0] = y1

    def setDataRangeZ(self, z0, z1):
        assert z0 < z1
        self.mDataMinRanges[0] = z0
        self.mDataMaxRanges[0] = z1
    """

    def setCameraPosition(self, pos=None, distance=None, elevation=None, azimuth=None):

        if distance is not None:
            self.opts['distance'] = distance
        if elevation is not None:
            self.opts['elevation'] = elevation
        if azimuth is not None:
            self.opts['azimuth'] = azimuth
        if pos is not None:
            if not isinstance(pos, QVector3D):
                pos = Vector(pos)
            self.opts['center'] = pos

    def resetCamera(self):

        # self.mDataMinRanges
        self.updateDataRanges()
        self.resetScaling()
        x,y,z = self.mDataMaxRanges
        self.setCameraPosition([1.,0.5,0.5], distance=10, elevation=10, azimuth=10)
        self.update()



    def clearItems(self):
        to_remove = [i for i in self.items if i not in self.mBasicItems]

        for i in to_remove:
            self.items.remove(i)
            i._setView(None)
        self.update()


    def paintGL(self, *args, **kwds):
        GLViewWidget.paintGL(self, *args, **kwds)
        self.qglColor(Qt.white)
        self.renderAnnotations()

    def zoomToFull(self):
        x = y = z = 0
        for item in self.items:
            if item not in self.mBasicItems:
                pos = item.pos
                #self.setCameraPosition(pos=pos, distance=10)
                break

        s = ""

    def updateDataRanges(self):
        """
        Re-calcuates the data ranges of the added plot items.
        Calls this before re-scaling the transformation matrix.
        """
        x0 = x1 = y0 = y1 = z0 = z1 = n = None

        if hasattr(self, 'items'):
            for item in self.items:
                if item not in self.mBasicItems and hasattr(item, 'pos'):
                    pos = item.pos
                    if x0 is None:
                        n = pos.shape[0]
                        x0 = pos[:, 0].min()
                        y0 = pos[:, 1].min()
                        z0 = pos[:, 2].min()
                        x1 = pos[:, 0].max()
                        y1 = pos[:, 1].max()
                        z1 = pos[:, 2].max()
                    else:
                        n = max(n, pos.shape[0])
                        x0 = min(x0, pos[:, 0].min())
                        y0 = min(y0, pos[:, 1].min())
                        z0 = min(z0, pos[:, 2].min())
                        x1 = max(x1, pos[:, 0].max())
                        y1 = max(y1, pos[:, 1].max())
                        z1 = max(z1, pos[:, 2].max())
            if x1 is not None:
                self.mDataMinRanges = np.asarray([x0, y0, z0])
                self.mDataMaxRanges = np.asarray([x1, y1, z1])
                self.mDataSpan = self.mDataMaxRanges - self.mDataMinRanges
                #avoid division by zero and provide a minimum range of 1/10000
                self.mDataSpan = np.where(self.mDataSpan == 0, np.ones((3), dtype=np.float64)/10000., self.mDataSpan)
                self.mDataMaxRanges = self.mDataMinRanges + self.mDataSpan
                self.mDataN = n

                self.glAxes.setMinRanges(self.mDataMinRanges)
                self.glAxes.setMaxRanges(self.mDataMaxRanges)
                self.glGridItem.setMinRanges(self.mDataMinRanges)
                self.glGridItem.setMaxRanges(self.mDataMaxRanges)


    def resetScaling(self):
        t = pg.Transform3D()
        scale = np.asarray([0.9, 1.0, 0.8]) / np.asarray(self.mDataSpan)  # scale to 0-1
        t.scale(*scale)
        t.translate(*(-1 * np.asarray(self.mDataMinRanges)))  # set axis origin to 0:0:0


        vMin = t*Vector(self.mDataMinRanges)
        vMax = t*Vector(self.mDataMaxRanges)
        #pos = (self.mDataMinRanges+self.mDataMaxRanges)*0.5
        #self.setCameraPosition(pos=Vector(*pos)*t)
        #self.setCameraPosition(pos=t*Vector(*pos))
        #self.setCameraPosition(pos=Vector(*pos))
        self.setItemTransform(t)
        #self.setCameraPosition(pos=Vector(0.5,0.5,0.5))

    def setItemTransform(self, transform):
        assert isinstance(transform, pg.Transform3D)
        self.mItemTransformation = transform
        for item in self.items:
            item.setTransform(transform)
    def itemTransformation(self):
        return self.mItemTransformation

    def addItems(self, items):
        """Adds a list of items to this plot"""
        for item in items:
            assert isinstance(item, GLGraphicsItem)
            if hasattr(item, 'initializeGL'):
                self.makeCurrent()
                try:
                    item.initializeGL()
                except:
                    self.checkOpenGLVersion('Error while adding item %s to GLViewWidget.' % str(item))
            item._setView(self)
        self.items.extend(items)
        self.updateDataRanges()
        self.update()

    def removeItems(self, items):

        for item in items:
            if item in self.items:
                self.items.remove(item)
                item._setView(None)
        self.updateDataRanges()
        self.update()


    def mouseMoveEvent(self, ev):
        assert isinstance(ev, QMouseEvent)
        """ Allow Shift to Move and Ctrl to Pan.
        Example taken from https://gist.github.com/blink1073/7406607
        """
        shift = ev.modifiers() & QtCore.Qt.ShiftModifier
        ctrl = ev.modifiers() & QtCore.Qt.ControlModifier
        if shift:
            y = ev.pos().y()
            if not hasattr(self, '_prev_zoom_pos') or not self._prev_zoom_pos:
                self._prev_zoom_pos = y
                return
            dy = y - self._prev_zoom_pos

            def delta():
                return -dy * 5

            ev.delta = delta
            self._prev_zoom_pos = y
            self.wheelEvent(ev)
        elif ctrl:
            pos = ev.pos().x(), ev.pos().y()
            if not hasattr(self, '_prev_pan_pos') or not self._prev_pan_pos:
                self._prev_pan_pos = pos
                return
            dx = pos[0] - self._prev_pan_pos[0]
            dy = pos[1] - self._prev_pan_pos[1]
            self.pan(dx, dy, 0, relative=True)
            self._prev_pan_pos = pos
        else:
            super(ViewWidget3D, self).mouseMoveEvent(ev)

        # items = self.itemsAt((pos.x(), pos.y(), 3, 3))

    def mousePressEvent(self, event):
        super(ViewWidget3D, self).mousePressEvent(event)
        self.mousePos = event.pos()
        if event.button() == Qt.RightButton:
            self.select = True

        else:
            self.select = False

        try:
            glColorSelected = fn.glColor(QColor('red'))
            for item in self.itemsAt((self.mousePos.x(), self.mousePos.y(), 3, 3)):



                if isinstance(item, GLLinePlotItem):
                    c = item.color
                    item.setData(color=glColorSelected)
                    QTimer.singleShot(DT_SELECTION, lambda item=item, c=c: item.setData(color=c))

        except:
            pass


    def renderAnnotations(self):

        if self.glAxes.visible():
            x0, y0, z0 = self.glAxes.rangeMinima()
            x1, y1, z1 = self.glAxes.rangeMaxima()
            dx, dy, dz = self.glAxes.rangeSpan()


            T = self.glAxes.transform()

            #transform
            d = 0.1

            V0 = T * Vector(*self.glAxes.rangeMinima())
            V1 = T * Vector(*self.glAxes.rangeMaxima())

            dx = V1.x() - V0.x()
            dy = V1.y() - V0.y()
            dz = V1.z() - V0.z()

            sx = V1.x() + 0.1*dx
            sy = V1.y() + 0.1*dy
            sz = V1.z() + 0.1*dz
            if x1 is not None:
                #self.renderText(x1 + d*dx, 0, 0, self.glAxes.mLabels[0])
                self.renderText(sx, 0, 0, self.glAxes.mLabels[0])
            if y1 is not None:
                #self.renderText(0, y1 + d*dy, 0, self.glAxes.mLabels[1])
                self.renderText(0, sy, 0, self.glAxes.mLabels[1])
            if z1 is not None:
                #self.renderText(0, 0, z1 + d*dz, self.glAxes.mLabels[2])
                self.renderText(0, 0, sz, self.glAxes.mLabels[2])

            if True: #set axes origin
                l = '{} {} {}'.format(x0,y0,z0)
                self.renderText(V0.x()-0.1*dx,V0.y()-0.1*dy, V0.z()-0.1*dz, l)


        # self.renderText(0.8, 0.8, 0.8, 'text 3D')
        # self.renderText(5, 10, 'text 2D fixed')

        self.qglColor(Qt.darkYellow)
        self.renderText(5, 10, '(3D Mode still experimental)')

    def contextMenuEvent(self, event):
        assert isinstance(event, QContextMenuEvent)

        menu = QMenu()

        a = menu.addAction('Reset Camera')
        a.triggered.connect(self.resetCamera)

        menu.addSeparator()

        # define grid options
        m = menu.addMenu('Grids')

        def gridVisibility(b):
            for d in ['XY','XZ','YZ']:
                self.glGridItem.set(d, visible=b)
            self.glGridItem.update()



        a = m.addAction('Show All')
        a.setCheckable(False)
        a.triggered.connect(lambda: gridVisibility(True))

        a = m.addAction('Hide All')
        a.setCheckable(False)
        a.triggered.connect(lambda: gridVisibility(False))

        m.addSeparator()

        for i, dim in enumerate(['XY','XZ','YZ']):
            a = m.addAction(dim)
            a.setCheckable(True)
            a.setChecked(self.glGridItem.mVisibility[i])
            a.toggled.connect(lambda b, dim=dim:self.glGridItem.set(dim,visible=b))



        m = menu.addMenu('Axes')

        a = m.addAction('Show All')
        a.setCheckable(False)
        a.triggered.connect(lambda : self.glAxes.setAxes('xyz', visible=True))

        a = m.addAction('Hide All')
        a.setCheckable(False)
        a.triggered.connect(lambda: self.glAxes.setAxes('xyz', visible=False))

        m.addSeparator()

        a = m.addAction('X')
        a.setCheckable(True)
        a.setChecked(self.glAxes.mVisibility[0])
        a.toggled.connect(lambda b: self.glAxes.setX(visible=b))

        a = m.addAction('Y')
        a.setCheckable(True)
        a.setChecked(self.glAxes.mVisibility[1])
        a.toggled.connect(lambda b: self.glAxes.setY(visible=b))

        a = m.addAction('Z')
        a.setCheckable(True)
        a.setChecked(self.glAxes.mVisibility[2])
        a.toggled.connect(lambda b: self.glAxes.setZ(visible=b))


        menuLabels = menu.addMenu('Labels')

        frame = QFrame()
        layout = QGridLayout()
        frame.setLayout(layout)

        names = ['X','Y','Z']
        for i, label in enumerate(self.glAxes.labels()):
            dim = names[i]
            layout.addWidget(QLabel(dim), i,0)
            tb = QLineEdit()
            tb.setText(label)
            tb.textChanged.connect(lambda t, dim=dim : self.glAxes.setAxes(dim, label=t))
            layout.addWidget(tb,i,1)
        layout.setSpacing(1)
        layout.setMargin(1)
        frame.setMinimumSize(layout.sizeHint())
        wa = QWidgetAction(menuLabels)
        wa.setDefaultWidget(frame)
        menuLabels.addAction(wa)


        menu.exec_(self.mapToGlobal(event.pos()))

class GLTextItem(GLGraphicsItem):
    def __init__(self, X=None, Y=None, Z=None, text=None):
        GLGraphicsItem.__init__(self)

        self.text = text
        self.X = X
        self.Y = Y
        self.Z = Z

    def setGLViewWidget(self, GLViewWidget):
        self.GLViewWidget = GLViewWidget

    def setText(self, text):
        self.text = text
        self.update()

    def setX(self, X):
        self.X = X
        self.update()

    def setY(self, Y):
        self.Y = Y
        self.update()

    def setZ(self, Z):
        self.Z = Z
        self.update()

    def paint(self):
        self.GLViewWidget.qglColor(Qt.white)
        self.GLViewWidget.renderText(self.X, self.Y, self.Z, self.text)

class Axis3D(GLAxisItem):

    def __init__(self, *args, **kwds):
        super(Axis3D, self).__init__(*args, **kwds)

        self.mRanges = np.asarray([[0, 1], [0, 1], [0, 1]])
        self.mColors = [QColor('white'), QColor('white'), QColor('white')]
        self.mVisibility = [True, True, True]
        self.mLabels = ['X', 'Y', 'Z']

    def rangeMinima(self):
        return self.mRanges[:, 0]

    def rangeMaxima(self):
        return self.mRanges[:, 1]

    def setMinRanges(self, ranges):
        self.mRanges[:,0] = ranges

    def setMaxRanges(self, ranges):
        self.mRanges[:,1] = ranges


    def rangeSpan(self):

        return self.mRanges[:,1] - self.mRanges[:,0]


    def setAxes(self, ax, vMin=None, vMax=None, label=None, color=None, visible=None):

        for c in ax:
            i = ['x', 'y', 'z'].index(c.lower())
            if vMin is not None:
                self.mRanges[i][0] = vMin
            if vMax is not None:
                self.mRanges[i][1] = vMax
            if color is not None:
                self.mColors[i] = color
            if label is not None:
                self.mLabels[i] = label
            if visible is not None:
                self.mVisibility[i] = visible
        self.update()

    def setLabels(self, x,y,z):
        self.mLabels = [x,y,z]

    def labels(self):
        return self.mLabels[:]

    def setX(self, **kwds):
        self.setAxes('x', **kwds)

    def setY(self, **kwds):
        self.setAxes('y', **kwds)

    def setZ(self, **kwds):
        self.setAxes('z', **kwds)

    def paint(self):
        self.setupGLState()

        if self.antialias:
            glEnable(GL_LINE_SMOOTH)
            glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)

        x0, y0, z0 = self.rangeMinima()
        x1, y1, z1 = self.rangeMaxima()


        #V0 = Vector(*self.rangeMinima())
        #V1 = Vector(*self.rangeMaxima())
        #T = self.transform()
        #V0 = V0*T
        #V1 = V1*T
        #x0,y0,z0 = V0.x(), V0.y(), V0.z()
        #x1, y1, z1 = V1.x(), V1.y(), V1.z()

        glLineWidth(3.0)
        glBegin(GL_LINES)

        if self.mVisibility[0]:
            glColor4f(*fn.glColor(self.mColors[0]))
            glVertex3f(x0, y0, z0)
            glVertex3f(x1, y0, z0)

        if self.mVisibility[1]:
            glColor4f(*fn.glColor(self.mColors[1]))
            glVertex3f(x0, y0, z0)
            glVertex3f(x0, y1, z0)

        if self.mVisibility[2]:
            glColor4f(*fn.glColor(self.mColors[2]))
            glVertex3f(x0, y0, z0)
            glVertex3f(x0, y0, z1)

        glEnd()
        glLineWidth(1.0)

