import os
import math
import random
from functools import partial

import maya.cmds as cmds
import maya.OpenMayaUI as omui
import pymel.core as pm

from PySide import QtCore as qc
from PySide import QtGui as qg
import System.QTutils as qu
reload(qu)

uiFile = "C:/kTools/__favoriteMaterial/ui/main.ui"
uiSettings = "C:/kTools/__favoriteMaterial/ui/settings.ui"
favList = []
ports = {}
# favList = ['blinn1', 'lambert1', 'anisotropic2', 'anisotropic1']
# favList = ['blinn1', 'lambert1', 'anisotropic2', 'anisotropic1']
form_class, base_class = qu.loadUiType(uiFile)

def maya_main_window():
    main_window_ptr = omui.MQtUtil.mainWindow()
    return qu.wrapinstance(long(main_window_ptr), qg.QMainWindow)

class favoriteMaterial_UI(form_class, base_class):
    def __init__(self, parent=maya_main_window()):
        super(favoriteMaterial_UI, self).__init__(parent)
        self.setupUi(self)

        #assign functions to ui
        self.addSlotButton.clicked.connect(self.addSlot)
        self.refreshSlotButton.clicked.connect(self.refreshSlot)
        self.importLibraryAction.triggered.connect(self.importLibrary)
        self.exportLibraryAction.triggered.connect(self.exportLibrary)
        # self.settingsAction.triggered.connect(self.openSettings)
        self.randomShaderButton.clicked.connect(self.newMaterial)

        self.displayLibrary()

    def displayLibrary(self):
        #this is creating layout from favList[], like adding it to grid 4xN, creating swatches and context menus.

        #before runing this function, make sure you do not have any swatches (ports[]), cause maya would just make new ones over the old ones.
        self.clearAllSwatches()
        if favList:
            # Create the port using cmds first. I couldn't get the displayPort to work unless I created a window first
            tempwin = cmds.window()
            cmds.columnLayout()
            buttons = {}
            shadersRange = len(favList)
            cols = math.ceil(float(shadersRange)/4)
            perRow = 4
            index = 0
            labels = {}
            vLayouts = {}
            qPorts = {}

            for i in range(int(cols)):
                if shadersRange < perRow:
                    rowRange = shadersRange
                else:
                    rowRange = 4
                shadersRange = shadersRange - perRow
                for j in range(int(rowRange)):
                    labelName = str(favList[index])
                    labels[(i, j)] = qg.QPushButton(labelName)
                    labels[(i, j)].setObjectName(labelName)
                    labels[(i,j)].setFixedSize(qc.QSize(50,20))
                    labels[(i, j)].clicked.connect(partial(self.assignSlot, index))
                    ports[index] = cmds.swatchDisplayPort(labelName, rs=50, wh=(50, 50), sn=labelName)
                    qPorts[(i,j)] = qu.toQtObject(ports[index])
                    qPorts[(i,j)].setContextMenuPolicy(qc.Qt.ActionsContextMenu)

                    edit = qg.QAction(self)
                    edit.setText("edit")
                    edit.triggered.connect(partial(self.editSlot, index))

                    delete = qg.QAction(self)
                    delete.setText("remove from library")
                    delete.triggered.connect(partial(self.deleteSlot, index))
                    # delete.triggered.connect(self.deleteSlot)

                    deleteNet = qg.QAction(self)
                    deleteNet.setText("delete network")
                    deleteNet.triggered.connect(partial(self.deleteNetwork, index))

                    duplicateNet = qg.QAction(self)
                    duplicateNet.setText("duplicate network")
                    duplicateNet.triggered.connect(partial(self.duplicateNetwork, index))

                    qPorts[(i,j)].addAction(edit)
                    qPorts[(i,j)].addAction(delete)
                    qPorts[(i,j)].addAction(deleteNet)
                    qPorts[(i,j)].addAction(duplicateNet)
                    vLayouts[(i,j)] = qg.QVBoxLayout()
                    vLayouts[(i,j)].addWidget(qPorts[(i,j)])
                    vLayouts[(i,j)].addWidget(labels[(i,j)])

                    self.shadersGrid.layout().addLayout(vLayouts[(i,j)], i, j)
                    index = index + 1
            cmds.deleteUI(tempwin)

    def addSlot(self, shaderName=None):
        #Add selected material to FavList[] after few checks
        if shaderName:
            if cmds.objExists(shaderName):
                material = shaderName
            else:
                print "Material doesn't exist."
                material = None
        elif cmds.ls(selection=True):
            selection = cmds.ls(selection=True, materials=True)
            if selection:
                material = selection[0]
            else: material = None
        else:
            print "Something went wrong. Maybe your material doesn't exists?"
            material = None

        if material:
            if material not in favList:
                favList.append(material)
            else:
                print "Shader {0} already on the list. Skipping.".format(material)
            self.refreshSlot()
    def clearAllSwatches(self):
        #this should delete all shader swatches
        if ports:
            for index, port in enumerate(ports):
                if (cmds.swatchDisplayPort(ports[index], exists=True)):
                    print "DelUI to {0}".format(ports[index])
                    cmds.deleteUI(ports[index])

    def clearSwatch(self, slot):
        #this should delete selected swatch
        if (cmds.swatchDisplayPort(ports[slot], exists=True)):
            cmds.deleteUI(ports[slot])

    def refreshSlot(self):
        #check if shader exists in maya, if not pop from a list
        # after that just displayList again.
        for index, slot in enumerate(favList):
            if not cmds.objExists(slot):
                favList.pop(index)
                print "Shader {0} doesn't exist. Deleting from list.".format(slot)
        self.displayLibrary()

    def editSlot(self, material):
        #just select material
        materialName = str(favList[material])
        cmds.select(materialName, r=True )

    def deleteSlot(self, material=None):
        #delete Slot / this is context menu option
        #
        self.clearSwatch(material)
        favList.pop(0)
        # print "Shader {0} deleted from list.".format(name)
        self.refreshSlot()

    def deleteNetwork(self, material):
        # / this is context menu option
        pass
    def duplicateNetwork(self, material):
        # / this is context menu option
        pass

    def assignSlot(self, material):
        # / this is context menu option
        print "I'm working!"

    def checkShadingNode(self):
        pass
    def newMaterial(self):
        # create new random material

        #right now its just used for testing.

        # line below seems to work well?
        # self.clearSwatch(0)

        #line below is hell
        self.clearAllSwatches()

    def importLibrary(self):
        # / this is context menu option
        pass
    def exportLibrary(self):
        # / this is context menu option
        pass