main

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 = []

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 Singleton(object):
    _instances = {}
    def __new__(class_, *args, **kwargs):
        if class_ not in class_._instances:
            class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
        else:
            class_._instances[class_].__init__(class_, *args, **kwargs)
        return class_._instances[class_]

class RightClickMenuButton(Singleton, qg.QPushButton):
    def __init__(self, name, parent=None):
        super(RightClickMenuButton, self).__init__(name)
        self.setContextMenuPolicy(qc.Qt.ActionsContextMenu)
        self.addMenuActions()
        self.buttonName = name
    def addMenuActions(self):
        edit = qg.QAction(self)
        edit.setText("edit")
        edit.triggered.connect(self.edit)
        self.addAction(edit)

        delete = qg.QAction(self)
        delete.setText("remove")
        delete.triggered.connect(self.delete)
        self.addAction(delete)

        deleteNetwork = qg.QAction(self)
        deleteNetwork.setText("delete network")
        deleteNetwork.triggered.connect(self.deleteNetwork)
        self.addAction(deleteNetwork)

        duplicateNetwork = qg.QAction(self)
        duplicateNetwork.setText("duplicate network")
        duplicateNetwork.triggered.connect(self.duplicateNetwork)
        self.addAction(duplicateNetwork)

    def edit(self):
        cmds.select(self.buttonName, r=True )
    def delete(self):
        favoriteMaterial_UI.removeSlot(self.buttonName)
        self.deleteLater()
    def deleteNetwork(self):
        pass
    def duplicateNetwork(self):
        if cmds.objExists(self.buttonName):
            list = pm.duplicate(self.buttonName, un=True)
            newMaterial = list[0]
            favoriteMaterial_UI.addSlot(newMaterial)


class favoriteMaterial_UI(Singleton, 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 addSlot(self, shaderName=None):
        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 refreshSlot(self):
        print favList
        for index, slot in enumerate(favList):
            #check if shader exist
            if not cmds.objExists(slot):
                favList.pop(index)
                print "Shader {0} doesn't exist. Deleting from list.".format(slot)
        self.displayLibrary()


    @classmethod
    def removeSlot(self, name):
        favList.remove(name)
        print "Shader {0} deleted from list.".format(name)


    def checkShadingNode(self, shader, shaderSG):
        # a shading group
        if not cmds.objExists(shaderSG):
            shading_group= cmds.sets(renderable=True,noSurfaceShader=True,empty=True, name=shaderSG)
        else:
            shading_group=shaderSG
        slot1 = shader + ".outColor"
        slot2 = shading_group + ".surfaceShader"
        if not cmds.isConnected(slot1,slot2):
            #connect shader to sg surface shader
            cmds.connectAttr(slot1,slot2,force=1)

    def assignMaterial(self, shader):
        if cmds.ls(selection=True):
            sh = favList[shader]
            shaderName = sh+"SG"
            if sh in favList[shader]:
                self.checkShadingNode(sh, shaderName)
                cmds.sets(e=True, forceElement=shaderName)
            else:
                print "It seems that this shader '{0}' is not on your favourite list. Wtf?How you get there.".format(shaderName)
        else:
            print "Select object first."

    def newMaterial(self):
        print "tworze nowy shader na podstawie ustawien i dodaje go odrazu na liste";

    def displayLibrary(self):
        print "wyswietlam wszystkie materialy z biblioteki w UI";
        #refreshList
        buttons = {}
        shadersRange = len(favList)
        #count rows/cols
        cols = math.ceil(float(shadersRange)/4)
        perRow = 4
        index = 0
        for i in range(int(cols)):
            if shadersRange < perRow:
                rowRange = shadersRange
            else:
                rowRange = 4
            shadersRange = shadersRange - perRow
            for j in range(int(rowRange)):
                # keep a reference to the buttons
                buttonName = str(favList[index])
                buttons[(i, j)] = RightClickMenuButton(buttonName)
                # add to the layout
                self.shadersGrid.layout().addWidget(buttons[(i, j)], i, j)
                #connect signal
                buttons[(i, j)].clicked.connect(partial(self.assignMaterial, index))
                index = index + 1

    def importLibrary(self):
        print "importuje plik materialow i wrzucam odpowiednio do tablicy";

    def checkIfMaterialExists(self):
        print "sprawdzam czy importowany material juz moze jest w scenie i daje opcje 'Skip or import as copy'"

    def exportLibrary(self):
        print "Wszystkie materialy obecnie na liscie zapisuje jako nowy plik";

    def exitNotice(self):
        print "Jesli mam sygnal ze ktos dodal/usunal/edytowal material to wyswietlam okienko z powiadomieniem 'Are you sure? Blabala'"

    def openSettings(self):
        print "otwieram okienko z ustawieniami";