"""

License:
This collection of code named GS CurveTools is a property of George Sladkovsky (Yehor Sladkovskyi)
and can not be copied or distributed without his written permission.

GS CurveTools v1.3.1 Studio
Copyright 2023, George Sladkovsky (Yehor Sladkovskyi)
All Rights Reserved

Autodesk Maya is a property of Autodesk, Inc.

Social Media and Contact Links:

Discord Server:       https://discord.gg/f4DH6HQ
Online Store:         https://sladkovsky3d.artstation.com/store
Online Documentation: https://gs-curvetools.readthedocs.io/
Twitch Channel:       https://www.twitch.tv/videonomad
YouTube Channel:      https://www.youtube.com/c/GeorgeSladkovsky
ArtStation Portfolio: https://www.artstation.com/sladkovsky3d
Contact Email:        george.sladkovsky@gmail.com

"""

import os
import sys
from datetime import datetime
from functools import partial as pa
from imp import reload

import maya.cmds as mc
from PySide2 import QtCore, QtGui, QtWidgets

from . import core, ui
from . import constants
from .constants import *
from .utils import style, tooltips, utils, wrap
from .utils.utils import deferred, deferredLp, noUndo, undo
from .utils.wrap import WIDGETS

reload(core)
reload(utils)
reload(style)
reload(wrap)
reload(ui)
reload(tooltips)
reload(constants)

# Loggers
MESSAGE = utils.logger
LOGGER = utils.logger.logger

LOGGER.debug('-----------------Starting Log Session-----------------')
LOGGER.debug('                 {}                 '.format(datetime.now().strftime("%d/%m/%Y, %H:%M:%S")))

### Interface Script Jobs ###


def checkScriptJobs(controlName):
    """ Checks if script jobs exist and adds them if necessary """
    jobNumbers = list()
    workspaceExists = False
    UI = 'control'
    if mc.workspaceControl(controlName, exists=1):
        workspaceExists = True
    if controlName == MAIN_WINDOW_NAME:
        UI = 'main'
    elif controlName == UV_EDITOR_NAME:
        UI = 'uv_editor'
    elif controlName == SCALE_FACTOR_UI:
        UI = 'scale_factor_ui'
    jobList = mc.scriptJob(lj=1)
    for job in jobList:
        if controlName in job:
            jobNumbers.append(job.split()[0][0:-1])
    if len(jobNumbers) == 0 and workspaceExists:
        scriptJobsInit(UI)
        LOGGER.info('scriptJobs created for "%s" UI!' % UI)
    elif len(jobNumbers) > 0 and not workspaceExists:
        LOGGER.info('scriptJobs deleted!')
        for number in jobNumbers:
            mc.scriptJob(k=number)


def scriptJobsInit(uiName):
    if uiName == 'main':
        mc.scriptJob(per=1, p=MAIN_WINDOW_NAME, event=['SceneOpened', pa(checkScriptJobs, MAIN_WINDOW_NAME)])
        mc.scriptJob(per=1, p=MAIN_WINDOW_NAME, event=['SceneOpened', pa(deferred(core.updateMainUI), True)])
        mc.scriptJob(per=1, p=MAIN_WINDOW_NAME, event=['SceneOpened', deferredLp(core.onSceneOpenedUpdateLayerCount)])
        mc.scriptJob(per=1, p=MAIN_WINDOW_NAME, event=['SelectionChanged', core.updateMainUI])
        mc.scriptJob(per=1, p=MAIN_WINDOW_NAME, event=['Undo', core.updateMainUI])
    elif uiName == 'control':
        mc.scriptJob(per=1, p=CURVE_CONTROL_NAME, event=['SelectionChanged', core.curveControlUI.updateUI])
        mc.scriptJob(per=1, p=CURVE_CONTROL_NAME, event=['Undo', deferred(core.curveControlUI.updateUI)])
    elif uiName == 'uv_editor':
        def updateUVs():
            if (mc.workspaceControl(UV_EDITOR_NAME, q=1, ex=1) and
                    mc.workspaceControl(UV_EDITOR_NAME, q=1, r=1)):
                ui.uveditor.updateEditor()
        mc.scriptJob(per=1, p=UV_EDITOR_NAME, event=['SelectionChanged', updateUVs])
        mc.scriptJob(per=1, p=UV_EDITOR_NAME, event=['Undo', updateUVs])


def main():
    utils.checkNativePlugins(['curveWarp'], MAIN_WINDOW_NAME)
    if mc.workspaceControl(MAIN_WINDOW_NAME, q=1, ex=1):
        if MAYA_VER >= 2018:
            if not mc.workspaceControl(MAIN_WINDOW_NAME, q=1, vis=1):
                mc.workspaceControl(MAIN_WINDOW_NAME, e=1, rs=1)
                core.updateMainUI()
            else:
                mc.workspaceControl(MAIN_WINDOW_NAME, e=1, vis=0)
        else:
            mc.workspaceControl(MAIN_WINDOW_NAME, e=1, fl=1)
            mc.deleteUI(MAIN_WINDOW_NAME)
    else:
        CurveToolsUI()
        mc.workspaceControl(MAIN_WINDOW_NAME, e=1, ui=UI_SCRIPT)
        try:
            core.toggleColor.checkColorStorageNode()
            checkScriptJobs(MAIN_WINDOW_NAME)
            utils.deferred(core.onSceneOpenedUpdateLayerCount)()  # Also updates the UI
        except Exception as e:
            LOGGER.exception(e)

# Main UI


class CurveToolsUI(QtWidgets.QWidget):

    def __init__(self):
        WIDGETS.clear()
        # Maya Native Workspace
        parent = ui.mayaWorkspaceControl(name=MAIN_WINDOW_NAME, label=MAIN_WINDOW_LABEL)

        # Resolve Fonts
        fontDatabase = QtGui.QFontDatabase()
        fontDatabase.removeAllApplicationFonts()
        fonts = os.listdir(utils.getFolder.fonts())
        for font in fonts:
            fontDatabase.addApplicationFont(utils.getFolder.fonts() + font)

        # Dockable Workspace Connection
        super(CurveToolsUI, self).__init__(parent)
        self.ui()
        parent.layout().addWidget(self)
        self.scrollWidget.setFocus()

        checkScriptJobs(MAIN_WINDOW_NAME)

    def ui(self):
        # Layout
        mainLayout = QtWidgets.QVBoxLayout(self)
        mainLayout.setContentsMargins(*style.scale([2, 0, 2, 0]))

        self.scrollWidget = QtWidgets.QWidget()
        layout = QtWidgets.QVBoxLayout(self.scrollWidget)
        scrollArea = QtWidgets.QScrollArea()
        scrollArea.setWidget(self.scrollWidget)
        mainLayout.addWidget(scrollArea)

        # Layout Settings
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(style.scale(2))
        layout.setMargin(0)
        layout.setAlignment(QtCore.Qt.AlignTop)

        scrollArea.setFrameShape(QtWidgets.QFrame.NoFrame)
        scrollArea.setWidgetResizable(True)

        # Menu buttons
        menuBarWidget = QtWidgets.QWidget()
        menuBarLayout = QtWidgets.QHBoxLayout(menuBarWidget)
        menuBarLayout.setContentsMargins(0, 0, 0, 0)
        menuBarLayout.setAlignment(QtCore.Qt.AlignCenter)

        menuBar = QtWidgets.QMenuBar()
        menuBar.setSizePolicy(PREFERRED_POLICY)
        menuBarLayout.addWidget(menuBar)
        layout.addWidget(menuBarWidget)

        # Options Menu
        with wrap.Menu('Options', menuBar) as menu:
            menu.triggered.connect(core.saveOptions)

            menu.addSection('Import / Export')
            importCurves = wrap.MenuItem('importCurves', 'Import Curves', menu)
            importCurves.triggered.connect(noUndo(core.importExport.importCurves))
            exportCurves = wrap.MenuItem('exportCurves', 'Export Curves', menu)
            exportCurves.triggered.connect(core.importExport.exportCurves)

            menu.addSection('Global Modifiers')
            changeScaleFactor = wrap.MenuItem('changeScaleFactor', 'Change Scale Factor', menu)
            changeScaleFactor.triggered.connect(ui.scaleFactorWindow)
            globalCurveThickness = wrap.MenuItem('globalCurveThickness', 'Global Curve Thickness', menu)
            globalCurveThickness.triggered.connect(ui.curveThicknessWindow)

            menu.addSection('Viewport Commands')
            setAOSettings = wrap.MenuItem('setAOSettings', 'Set AO Settings', menu)
            setAOSettings.triggered.connect(core.setAOSettings)

            with wrap.Menu('Transparency Settings', menu) as transparencySettingsMenu:
                simpleTransparency = wrap.MenuItem(
                    'setSimpleTransparency',
                    'Simple Transparency (Fast, Inncaurate)',
                    transparencySettingsMenu
                )
                simpleTransparency.triggered.connect(noUndo(pa(core.setTransparencySettings, 0)))
                objectSortingTransparency = wrap.MenuItem(
                    'setObjectSortingTransparency',
                    'Object Sorting Transparency (Average)',
                    transparencySettingsMenu
                )
                objectSortingTransparency.triggered.connect(noUndo(pa(core.setTransparencySettings, 1)))
                setDepthTransparency = wrap.MenuItem(
                    'setDepthTransparency',
                    'Depth Transparency (Accurate, Slow)',
                    transparencySettingsMenu
                )
                setDepthTransparency.triggered.connect(noUndo(pa(core.setTransparencySettings, 2)))

            menu.addSection('Convert Curves')
            with wrap.Menu('Convert Curves', menu) as convertCurvesSubmenu:
                convertToWarpCard = wrap.MenuItem('convertToWarpCard', "Convert to Warp Card", convertCurvesSubmenu)
                convertToWarpCard.triggered.connect(pa(undo(core.convertSelectionTo), 0))
                convertToWarpTube = wrap.MenuItem('convertToWarpTube', "Convert to Warp Tube", convertCurvesSubmenu)
                convertToWarpTube.triggered.connect(pa(undo(core.convertSelectionTo), 1))
                convertToExtrudeCard = wrap.MenuItem('convertToExtrudeCard', "Convert to Extrude Card", convertCurvesSubmenu)
                convertToExtrudeCard.triggered.connect(pa(undo(core.convertSelectionTo), 2))
                convertToExtrudeTube = wrap.MenuItem('convertToExtrudeTube', "Convert to Extrude Tube", convertCurvesSubmenu)
                convertToExtrudeTube.triggered.connect(pa(undo(core.convertSelectionTo), 3))

            menu.addSection('General Options')
            wrap.MenuItem('keepCurveAttributes', 'Keep Curve Attributes', menu, True, core.getOption('keepCurveAttributes'))
            wrap.MenuItem('populateBlendAttributes', 'Add Cards/Tubes Blend Attributes',
                          menu, True, core.getOption('populateBlendAttributes'))
            wrap.MenuItem('convertInstances', 'Auto Convert Instances', menu, True, core.getOption('convertInstances'))

            wrap.MenuItem('useAutoRefineOnNewCurves', 'Use Auto-Refine on New Curves',
                          menu, True, core.getOption('useAutoRefineOnNewCurves'))
            wrap.MenuItem('flipUVsAfterMirror', 'Flip UVs After Mirror',
                          menu, True, core.getOption('flipUVsAfterMirror'))
            enableTooltipsMenu = wrap.MenuItem('enableTooltips', 'Enable Tooltips', menu, True, core.getOption('enableTooltips'))
            enableTooltipsMenu.triggered.connect(self.toggleTooltips)

            menu.addSection('Color Options')
            syncColor = wrap.MenuItem('syncCurveColor', 'Sync Curve Color to Layer Color', menu, True, core.getOption('syncCurveColor'))
            syncColor.triggered.connect(core.toggleColor.syncCurveColors)
            wrap.MenuItem('colorizedRegroup', 'Colorize Regrouped Layers', menu, True, core.getOption('colorizedRegroup'))
            colorOnlyDiffuse = wrap.MenuItem('colorOnlyDiffuse', 'Color Only Affects Diffuse',
                                             menu, True, core.getOption('colorOnlyDiffuse'))
            colorOnlyDiffuse.triggered.connect(core.toggleColor.updateColorOptions)
            checkerPattern = wrap.MenuItem('checkerPattern', 'Checker Pattern for Color Mode', menu, True, core.getOption('checkerPattern'))
            checkerPattern.triggered.connect(core.toggleColor.updateColorOptions)

            menu.addSection('Bind Options')
            wrap.MenuItem('boundCurvesFollowParent', 'Bound Curves Follow Parent', menu, True, core.getOption('boundCurvesFollowParent'))
            wrap.MenuItem('massBindOption', 'Bind to All Available Empty Curves', menu, True, core.getOption('massBindOption'))
            wrap.MenuItem('bindDuplicatesCurves', 'Duplicate Curves Before Bind', menu, True, core.getOption('bindDuplicatesCurves'))
            wrap.MenuItem('bindFlipUVs', 'Flip UVs before Bind', menu, True, core.getOption('bindFlipUVs'))

            menu.addSection('Layer Options')
            wrap.MenuItem('ignoreLastLayer', 'Ignore Last Layer', menu, True, core.getOption('ignoreLastLayer'))
            wrap.MenuItem('syncOutlinerLayerVis', 'Sync Outliner/Layer Visibility', menu, True, core.getOption('syncOutlinerLayerVis'))
            wrap.MenuItem('replacingCurveLayerSelection', 'Replacing Curve Layer Selection', menu, True,
                          core.getOption('replacingCurveLayerSelection'))
            onlyNumbersInLayers = wrap.MenuItem('layerNumbersOnly', 'Use Only Numbers in Layers', menu, True,
                                                core.getOption('layerNumbersOnly'))
            onlyNumbersInLayers.triggered.connect(core.changeLayersToNumbers)
            onlyNumbersInLayers.triggered.connect(self.updateLayerList)
            with wrap.Menu('Number of Active Layers', menu) as layerNumberMenu:
                with wrap.ActionGroup('layerRowsActionGroup', layerNumberMenu) as actionGroup:
                    wrap.MenuItem('2layerRows', '20 Layers', layerNumberMenu, True,
                                  core.getOption('2layerRows'), collection=actionGroup)
                    wrap.MenuItem('3layerRows', '30 Layers', layerNumberMenu, True,
                                  core.getOption('3layerRows'), collection=actionGroup)
                    wrap.MenuItem('4layerRows', '40 Layers', layerNumberMenu, True,
                                  core.getOption('4layerRows'), collection=actionGroup)
                    wrap.MenuItem('6layerRows', '60 Layers', layerNumberMenu, True,
                                  core.getOption('6layerRows'), collection=actionGroup)
                    wrap.MenuItem('8layerRows', '80 Layers', layerNumberMenu, True,
                                  core.getOption('8layerRows'), collection=actionGroup)
                    actionGroup.triggered.connect(core.updateMainUI)

            menu.addSection('Layer Collection Options')
            wrap.MenuItem('ignoreTemplateCollections', 'Ignore "Template" Collection Names', menu, True, core.getOption('ignoreTemplateCollections'))
            wrap.MenuItem('groupTemplateCollections', 'Group "Template" Collections Together', menu, True, core.getOption('groupTemplateCollections'))
            layerCollectionsToggle = wrap.MenuItem('showLayerCollectionsMenu', 'Show Layer Collections Menu',
                                                   menu, True, core.getOption('showLayerCollectionsMenu'))
            layerCollectionsToggle.triggered.connect(core.layerCollections.toggleLayerCollectionsWidget)
            wrap.MenuItem('importIntoANewCollection', 'Import Into a New Collection',
                          menu, True, core.getOption('importIntoANewCollection'))

            menu.addSection('Other Options')
            with wrap.Menu('Other Options', menu) as otherOptionsMenu:
                otherOptionsMenu.addSection('Utility Commands')
                convertToNewLayerSystem = wrap.MenuItem('convertToNewLayerSystem', 'Convert to New Layer System', otherOptionsMenu)
                convertToNewLayerSystem.triggered.connect(utils.convertToNewLayerSystem)
                updateLayers = wrap.MenuItem('updateLayers', 'Update Layers', otherOptionsMenu)
                updateLayers.triggered.connect(undo(core.deleteUnusedLayers))  # TODO: Check if undo breaks anything
                resetToDefaults = wrap.MenuItem('resetToDefaults', 'Reset to Defaults', otherOptionsMenu)
                resetToDefaults.triggered.connect(utils.resetUI)

                otherOptionsMenu.addSection('Fixes')
                maya2020UVFix = wrap.MenuItem('maya2020UVFix', 'Fix Maya 2020-2022 UV Bug', otherOptionsMenu)
                maya2020UVFix.triggered.connect(undo(utils.fixMaya2020UVs))
                fixBrokenGraphs = wrap.MenuItem('mayaFixBrokenGraphs', 'Fix Broken Graphs', otherOptionsMenu)
                fixBrokenGraphs.triggered.connect(undo(utils.fixBrokenGraphs))
                convertBezierToNurbs = wrap.MenuItem('convertBezierToNurbs', 'Convert Selected Bezier to NURBS', otherOptionsMenu)
                convertBezierToNurbs.triggered.connect(undo(utils.convertBezierToNurbs))
                maya2020TwistFix = wrap.MenuItem('maya2020TwistAttribute', 'Fix Maya 2020.4 Twist Attribute', otherOptionsMenu)
                maya2020TwistFix.triggered.connect(undo(utils.fixMaya2020Twist))
                maya2020UnbindFix = wrap.MenuItem('maya2020UnbindFix', 'Fix Maya 2020.4 Unbind Function', otherOptionsMenu)
                maya2020UnbindFix.triggered.connect(undo(utils.fixMaya2020Unbind))
                deleteAllAnimationKeys = wrap.MenuItem('deleteAllAnimationKeys', 'Delete All Animation Keys', otherOptionsMenu)
                deleteAllAnimationKeys.triggered.connect(undo(utils.deleteKeysOnAllObjects))

        # Help Menu
        with wrap.Menu('Help', menuBar) as menu:
            openLogFile = wrap.MenuItem('openLogFile', 'Open Log File', menu)
            openLogFile.triggered.connect(utils.logger.openLogFile)
            openOnlineDocumentation = wrap.MenuItem('openOnlineDocumentation', 'Open Online Documentation', menu)
            openOnlineDocumentation.triggered.connect(utils.openDocs)
            usefulLinks = wrap.MenuItem('usefulLinks', 'Useful Links and Contacts', menu)
            usefulLinks.triggered.connect(ui.about.socialWindow)

        # About Menu
        with wrap.Menu('About', menuBar) as menu:
            aboutAction = wrap.MenuItem('gsAbout', 'About', menu)
            aboutAction.triggered.connect(ui.about.aboutWindow)
            menu.addSeparator()
            menu.addAction('Made by George Sladkovsky (%s)' % YEAR).setEnabled(False)

        # MAIN UI

        layout.addWidget(wrap.separator())

        # Extrude Warp Switch
        with wrap.Row(layout) as row:
            # Switch Group
            extrudeWarpSwitchGroup = QtWidgets.QButtonGroup(layout)
            WIDGETS['gsExtrudeWarpSwitchGroup'] = extrudeWarpSwitchGroup
            extrudeWarpSwitchGroup.buttonToggled.connect(self.extrudeWarpToggle)
            extrudeWarpSwitchGroup.buttonClicked.connect(core.saveOptions)

            warpSwitch = wrap.Button(row.layout(), 'warpSwitch')
            warpSwitch.setLabel('Warp', lineHeight=100)
            warpSwitch.setButtonStyle('small')
            warpSwitch.setCheckable(True)

            extrudeSwitch = wrap.Button(row.layout(), 'extrudeSwitch')
            extrudeSwitch.setLabel('Extrude', lineHeight=100)
            extrudeSwitch.setButtonStyle('small')
            extrudeSwitch.setCheckable(True)

            extrudeWarpSwitchGroup.addButton(warpSwitch, 0)
            extrudeWarpSwitchGroup.addButton(extrudeSwitch, 1)

        # New Card and New Tube
        with wrap.Row(layout) as row:
            newCard = wrap.Button(row.layout(), 'newCard')
            newCard.setLabel('New Card')
            newCard.clicked.connect(pa(undo(core.create.new), 0))

            newTube = wrap.Button(row.layout(), 'newTube')
            newTube.setLabel('New Tube')
            newTube.clicked.connect(pa(undo(core.create.new), 1))

        # Convert Curve to Card and Convert Curve to Tube
        with wrap.Row(layout) as row:
            curveCard = wrap.Button(row.layout(), 'curveCard')
            curveCard.setLabel('Curve Card')
            curveCard.clicked.connect(pa(undo(core.create.multiple), 0))

            curveTube = wrap.Button(row.layout(), 'curveTube')
            curveTube.setLabel('Curve Tube')
            curveTube.clicked.connect(pa(undo(core.create.multiple), 1))

        # Bind and Unbind
        with wrap.Row(layout) as row:
            bind = wrap.Button(row.layout(), 'gsBind')
            bind.setLabel('Bind')
            bind.setIcon('mod-top')
            bind.clicked.connect(undo(core.create.bind))

            unbind = wrap.Button(row.layout(), 'gsUnbind')
            unbind.setLabel('Unbind')
            unbind.clicked.connect(undo(core.create.unbind))

        layout.addWidget(wrap.separator())

        # Add Curve and Add Tube
        with wrap.Row(layout) as row:
            addCards = wrap.Button(row.layout(), 'addCards')
            addCards.setLabel('Add Card')
            addCards.setIcon('mod-top')
            addCards.clicked.connect(pa(undo(core.create.populate), 0))

            addTubes = wrap.Button(row.layout(), 'addTubes')
            addTubes.setLabel('Add Tube')
            addTubes.setIcon('mod-top')
            addTubes.clicked.connect(pa(undo(core.create.populate), 1))

        # Fill and Multiply
        with wrap.Row(layout) as row:
            fill = wrap.Button(row.layout(), 'gsFill')
            fill.setLabel('Fill')
            fill.setIcon('mod-top')
            fill.clicked.connect(pa(undo(core.create.fill)))

            subdivide = wrap.Button(row.layout(), 'gsSubdivide')
            subdivide.setLabel('Subdivide')
            subdivide.setIcon('mod-top')
            subdivide.clicked.connect(pa(undo(core.subdivideCurve)))

        # Add Slider
        with wrap.Row(layout) as row:
            m_addCardsSlider = mc.intSliderGrp('gsCurvesSlider', l='Add', f=1, adj=3,
                                               cw=[(1, 20), (2, 25), (3, 1)],
                                               min=1, max=10, v=3)
            addCardsSlider = wrap.mayaSlider(m_addCardsSlider, layout=row.layout())
            WIDGETS['gsCurvesSlider'] = addCardsSlider
            addCardsSlider.setContentsMargins(0, 0, 0, 0)
            addCardsSlider.children()[2].setFocusPolicy(QtCore.Qt.NoFocus)

        layout.addWidget(wrap.separator())

        # Edge to Curve
        with wrap.Row(layout) as row:
            edgeToCurve = wrap.Button(row.layout(), 'gsEdgeToCurve')
            edgeToCurve.setLabel('Edge To Curve')
            edgeToCurve.clicked.connect(pa(undo(core.edgeToCurve)))

            cardToCurve = wrap.Button(row.layout(), 'gsCardToCurve')
            cardToCurve.setLabel('Card To Curve')
            cardToCurve.clicked.connect(ui.cardToCurveWindow.openUI)

        layout.addWidget(wrap.separator())

        # Layer Collections Menu
        with wrap.Row(layout, objName='LayerCollectionsLayout', spacing=1) as layerCollectionsLayout:
            layerComboBox = wrap.LayerCollectionWidget('layerCollectionsComboBox')
            layerComboBox.setStyleSheet(style.smallComboBox)

            layerComboBox.currentIndexChanged.connect(lambda *_: deferred(core.updateMainUI)())
            layerComboBox.setSizeAdjustPolicy(layerComboBox.AdjustToMinimumContentsLength)
            layerComboBox.setDuplicatesEnabled(False)
            layerComboBox.setMinimumWidth(0)
            layerComboBox.setFixedHeight(style.scale(16))

            mc.popupMenu(mm=1, p=layerComboBox.objectName())
            mc.menuItem(rp='N', l='Clear', c=lambda *_: undo(core.layerCollections.clear)())
            mc.menuItem(rp='E', l='Copy', c=lambda *_: noUndo(core.layerCollections.copy)())
            mc.menuItem(rp='NE', l='Move Up', c=lambda *_: noUndo(core.layerCollections.moveUp)())
            mc.menuItem(rp='NW', l='Merge Up', c=lambda *_: noUndo(core.layerCollections.mergeUp)())
            mc.menuItem(rp='W', l='Paste', c=lambda *_: undo(core.layerCollections.paste)())
            mc.menuItem(rp='SW', l='Merge Down', c=lambda *_: noUndo(core.layerCollections.mergeDown)())
            mc.menuItem(rp='SE', l='Move Down', c=lambda *_: noUndo(core.layerCollections.moveDown)())
            mc.menuItem(rp='S', l='Rename', c=lambda *_: noUndo(core.layerCollections.rename)())

            with wrap.Row(layerCollectionsLayout.layout(), margins=style.scale([1, 0, 0, 0])) as plusMinusButtonsLayout:
                layerComboPlus = wrap.Button(objName="layerCollectionsPlus", layout=plusMinusButtonsLayout.layout())
                layerComboPlus.setFixedHeight(style.scale(16))
                layerComboPlus.setLabel("+", lineHeight=100)
                layerComboPlus.setMinimumWidth(1)
                layerComboPlus.setButtonStyle("small-filled")
                layerComboPlus.clicked.connect(core.layerCollections.createLayerCollection)

                layerComboMinus = wrap.Button(objName="layerCollectionsMinus", layout=plusMinusButtonsLayout.layout())
                layerComboMinus.setEnabled(False)
                layerComboMinus.setFixedHeight(style.scale(16))
                layerComboMinus.setMinimumWidth(1)
                layerComboMinus.setLabel("-", lineHeight=100)
                layerComboMinus.setButtonStyle("small-filled")
                layerComboMinus.clicked.connect(undo(core.layerCollections.deleteLayerCollection))

            layerCollectionsLayout.layout().addWidget(layerComboBox, 3)
            layerCollectionsLayout.layout().addWidget(plusMinusButtonsLayout, 1)

            layerComboBox.insertItem(0, "Main")

        # Layer Filters
        with wrap.Row(layout) as row:
            allFilter = wrap.Button(row.layout(), 'gsAllFilter')
            allFilter.setButtonStyle('small-filled')
            allFilter.setLabel('All', lineHeight=100)
            allFilter.setIcon('mod-top')
            allFilter.clicked.connect(pa(undo(core.layersFilterToggle), True, True))

            curveFilter = wrap.Button(row.layout(), 'gsCurveFilter')
            curveFilter.setButtonStyle('small-filled')
            curveFilter.setLabel('Curve', lineHeight=100)
            curveFilter.clicked.connect(pa(undo(core.layersFilterToggle), True, False, ignore=["Shift+Ctrl"]))

            mc.popupMenu(mm=1, p=curveFilter.objectName())
            mc.menuItem(rp='N', l='Toggle Always on Top', c=lambda *_: undo(core.alwaysOnTopToggle)())
            mc.menuItem(rp='S', l='Auto-Hide Curves on Inactive Collections',
                        cb=mc.optionVar(q='GSCT_AutoHideCurvesOnInactiveCollections'),
                        c=lambda cb: undo(core.collectionVisibilityToggle)(cb))

            geoFilter = wrap.Button(row.layout(), 'gsGeoFilter')
            geoFilter.setButtonStyle('small-filled')
            geoFilter.setLabel('Geo', lineHeight=100)
            geoFilter.clicked.connect(pa(undo(core.layersFilterToggle), False, True, ignore=["Shift+Ctrl"]))

            colorMode = wrap.Button(row.layout(), 'colorMode')
            colorMode.setButtonStyle('small-filled')
            colorMode.setCheckable(True)
            colorMode.setChecked(False)
            colorMode.setLabel('Color', lineHeight=100)
            colorMode.clicked.connect(pa(undo(core.toggleColor.toggleColorVis)))

            mc.popupMenu(mm=1, p=colorMode.objectName())
            mc.menuItem(rp='N', l='Randomize Colors', c=lambda *_: undo(core.toggleColor.randomizeColors)())
            mc.menuItem(rp='E', l='Reset Curve Colors', c=lambda *_: core.toggleColor.resetCurveColors())
            mc.menuItem(rp='W', l='Apply Curve Colors', c=lambda *_: core.toggleColor.syncCurveColors(True))
            mc.menuItem(rp='S', l='Custom Colors Window', c=ui.customLayerColors.window)

        # Layers
        with wrap.Layout(layout, objName='LayerLayout') as layerLayout:
            layerButtonGrp = QtWidgets.QButtonGroup(layerLayout.layout())
            layerButtonGrp.setObjectName(wrap.getUniqueName('LayerGroup'))
            layerButtonGrp.setExclusive(True)
            WIDGETS['LayerGroup'] = layerButtonGrp

            # First Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow0', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i, row.layout(), i))

            # Second Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow1', spacing=0) as row:
                letter = ord('A')
                letters = [chr(i) for i in range(letter, letter + 10)]
                if WIDGETS['layerNumbersOnly'].isChecked():
                    letters = [i for i in range(10, 20)]
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 10, row.layout(), letters[i]))

            # Third Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow2', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 20, row.layout(), i + 20))
            WIDGETS['layerRow2'].setHidden(True)

            # Fourth Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow3', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 30, row.layout(), i + 30))
            WIDGETS['layerRow3'].setHidden(True)

            # Fifth Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow4', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 40, row.layout(), i + 40))
            WIDGETS['layerRow4'].setHidden(True)

            # Sixth Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow5', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 50, row.layout(), i + 50))
            WIDGETS['layerRow5'].setHidden(True)

            # Seventh Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow6', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 60, row.layout(), i + 60))
            WIDGETS['layerRow6'].setHidden(True)

            # Eighth Layer Row
            with wrap.Row(layerLayout.layout(), 'layerRow7', spacing=0) as row:
                for i in range(10):
                    layerButtonGrp.addButton(self.selectionSets(i + 70, row.layout(), i + 70))
            WIDGETS['layerRow7'].setHidden(True)

            WIDGETS['curveGrp0'].setChecked(True)

        # Extract Selected and Extract All
        with wrap.Row(layout) as row:
            extractSelected = wrap.Button(row.layout(), 'gsExtractSelected')
            extractSelected.setLabel('Extract<br>Selected')
            extractSelected.setIcon('mod-bottom')
            extractSelected.clicked.connect(pa(undo(core.extractSelectedCurves)))

            extractAll = wrap.Button(row.layout(), 'gsExtractAll')
            extractAll.setLabel('Extract<br>All')
            extractAll.setIcon('mod-bottom')
            extractAll.clicked.connect(undo(core.extractAllCurves))

        layout.addWidget(wrap.separator())

        # Select Curve, Geo and Group
        with wrap.Row(layout) as row:
            selectCurve = wrap.Button(row.layout(), 'gsSelectCurve')
            selectCurve.setLabel('Select<br>Curve')
            selectCurve.clicked.connect(pa(undo(core.selectPart), 1))

            selectGeo = wrap.Button(row.layout(), 'gsSelectGeo')
            selectGeo.setLabel('Select<br>Geo')
            selectGeo.clicked.connect(pa(undo(core.selectPart), 2))

            selectGroup = wrap.Button(row.layout(), 'gsSelectGroup')
            selectGroup.setLabel('Select<br>Group')
            selectGroup.clicked.connect(pa(undo(core.selectPart), 0))

        # Group Curves Button
        with wrap.Row(layout) as row:
            groupCurves = wrap.Button(row.layout(), 'gsGroupCurves')
            groupCurves.setLabel('Group<br>Curves')
            groupCurves.clicked.connect(undo(core.groupCurves))

            regroupByLayer = wrap.Button(row.layout(), 'gsRegroupByLayer')
            regroupByLayer.setLabel('Regroup<br>by Layer')
            regroupByLayer.clicked.connect(undo(core.regroupByLayer))

        # Group Name Input Field
        groupName = wrap.LineEdit('gsGroupNameTextField', layout)
        groupName.setAlignment(QtCore.Qt.AlignCenter)
        groupName.setAutoFormat(True)
        groupName.setClearButtonEnabled(True)
        groupName.setPlaceholderText("Group Name")

        # Custom Layer Names Window
        customLayerNamesColors = wrap.Button(layout, 'gsCustomLayerNamesAndColors')
        customLayerNamesColors.setButtonStyle('small-filled')
        customLayerNamesColors.setLabel('Layer Names & Colors')
        customLayerNamesColors.clicked.connect(ui.customLayerColors.window)

        layout.addWidget(wrap.separator())

        # Select CVs Label
        layout.addWidget(wrap.wrapControl(mc.text(l='Select CVs')))

        # Select CVs Slider
        sliderWidget = wrap.wrapControl(
            mc.floatSliderGrp(
                'gsSelectCVSlider',
                w=1, min=0, max=1, step=0.05,
                dc=core.sliders.selectCVSlider,
                cc=core.sliders.release
            )
        )
        WIDGETS['gsSelectCVSlider'] = sliderWidget
        layout.addWidget(sliderWidget)

        # Select Curve, Geo and Group
        with wrap.Row(layout) as row:
            transferAttributes = wrap.Button(row.layout(), 'gsTransferAttributes')
            transferAttributes.setLabel('Transfer<br>Attr.')
            transferAttributes.setIcon('mod-bottom')
            transferAttributes.clicked.connect(undo(core.attributes.transferAttr))
            mc.popupMenu(mm=1, p=transferAttributes.objectName())
            mc.menuItem('gsCopyAttributes', rp='N', l='Copy Attrs', aob=1, c=lambda _: core.attributes.copyAttributes())
            mc.menuItem(ob=1, c=lambda _: ui.attributesFilter.openUI())
            mc.menuItem('gsPasteAttributes', rp='S', l='Paste Attrs', aob=1, c=lambda _: core.attributes.pasteAttributes())
            mc.menuItem(ob=1, c=lambda _: ui.attributesFilter.openUI())

            transferUVs = wrap.Button(row.layout(), 'gsTransferUVs')
            transferUVs.setLabel('Transfer<br>UVs')
            transferUVs.setIcon('mod-bottom')
            transferUVs.clicked.connect(undo(core.attributes.transferUV))
            mc.popupMenu(mm=1, p=transferUVs.objectName())
            mc.menuItem('gsCopyUVs', aob=1, rp='N', l='Copy UVs', c=lambda _: core.attributes.copyUVs())
            mc.menuItem(ob=1, c=lambda _: ui.attributesFilter.openUI())
            mc.menuItem('gsPasteUVs', aob=1, rp='S', l='Paste UVs', c=lambda _: core.attributes.pasteUVs())
            mc.menuItem(ob=1, c=lambda _: ui.attributesFilter.openUI())

            resetPivot = wrap.Button(row.layout(), 'gsResetPivot')
            resetPivot.setLabel('Reset<br>Pivot')
            resetPivot.clicked.connect(undo(core.resetCurvePivotPoint))
            resetPivot.setIcon('mod-bottom')
            mc.popupMenu(mm=1, p=resetPivot.objectName())
            mc.menuItem('gsResetPivotToRoot', rp='N', l='Reset to Root', c=lambda _: core.resetCurvePivotPoint())
            mc.menuItem('gsResetPivotToTip', rp='S', l='Reset to Tip', c=lambda _: core.resetCurvePivotPoint(2))

        layout.addWidget(wrap.separator())

        # Rebuild Curve
        def rebuildSliderRelease(_):
            core.sliders.rebuildSliderRelease()
            core.sliders.release()

        def rebuildButtonClicked():
            core.sliders.rebuildSliderDrag()
            rebuildSliderRelease(None)

        with wrap.Row(layout, margins=style.scale([1.5, 0, 1.5, 0])) as rebuildResetRow:
            rebuildButton = wrap.Button(objName='gsRebuildWithCurrentValue')
            rebuildButton.setButtonStyle('small-filled')
            rebuildButton.setLabel("R", lineHeight=100)
            rebuildButton.setMinimumWidth(1)
            rebuildButton.setMaximumSize(*style.scale([16, 16]))
            rebuildButton.clicked.connect(rebuildButtonClicked)

            resetButton = wrap.Button(objName='gsResetRebuildSliderRange')
            resetButton.setButtonStyle('small-filled')
            resetButton.setIcon('reset')
            resetButton.setMinimumWidth(1)
            resetButton.setMaximumSize(*style.scale([16, 16]))
            resetButton.clicked.connect(lambda: mc.intSliderGrp('gsRebuildSlider', e=1, min=1, max=50))

            rebuildResetRow.layout().addWidget(rebuildButton, 1)
            rebuildResetRow.layout().addWidget(wrap.wrapControl(mc.text(l='Rebuild Curve')), 3)
            rebuildResetRow.layout().addWidget(resetButton, 1)

        rebuildCurveSlider = wrap.wrapControl(mc.intSliderGrp(
            'gsRebuildSlider', f=1, cw=[(1, 32), (2, 28)], min=1, max=50, fmx=999, v=1,
            dc=core.sliders.rebuildSliderDrag,
            cc=rebuildSliderRelease))
        WIDGETS['gsRebuildSlider'] = rebuildCurveSlider
        layout.addWidget(rebuildCurveSlider)

        # Duplicate and Randomize
        with wrap.Row(layout) as row:
            duplicateCurve = wrap.Button(row.layout(), 'gsDuplicateCurve')
            duplicateCurve.setLabel('Duplicate')
            duplicateCurve.clicked.connect(undo(core.duplicateCurve))

            randomizeCurve = wrap.Button(row.layout(), 'gsRandomizeCurve')
            randomizeCurve.setLabel('Randomize')
            randomizeCurve.clicked.connect(ui.randomizeCurveWindow)

        # Extend and Reduce
        with wrap.Row(layout) as row:
            extendCurve = wrap.Button(row.layout(), 'gsExtendCurve')
            extendCurve.setLabel('Extend')
            extendCurve.clicked.connect(undo(core.extendCurve))

            reduceCurve = wrap.Button(row.layout(), 'gsReduceCurve')
            reduceCurve.setLabel('Reduce')
            reduceCurve.clicked.connect(undo(core.reduceCurve))

        # Smooth
        with wrap.Row(layout) as row:
            smooth = wrap.Button(row.layout(), 'gsSmooth')
            smooth.setLabel('Smooth')
            smooth.clicked.connect(undo(core.smoothCurve))
            smooth.setIcon('marking-top')
            mc.popupMenu(mm=1, p=smooth.objectName())
            mc.radioMenuItemCollection()
            mc.menuItem('gsSmoothMult1', rp='N', rb=1, l='x1')
            mc.menuItem('gsSmoothMult3', rp='E', rb=0, l='x3')
            mc.menuItem('gsSmoothMult5', rp='S', rb=0, l='x5')
            mc.menuItem('gsSmoothMult10', rp='W', rb=0, l='x10')

        # Smooth Slider
        factorSlider = wrap.wrapControl(mc.floatSliderGrp(
            'gsFactorSlider', l='Factor', adj=3, w=1, cw=[(1, 32), (2, 28)], min=1, max=100))
        WIDGETS['gsFactorSlider'] = factorSlider
        layout.addWidget(factorSlider)

        layout.addWidget(wrap.separator())

        # Mirroring
        with wrap.Frame(layout, objName='MirrorFrame', label='Mirroring', margins=[1, 1, 1, 1]) as frame:
            with wrap.Row(frame.getFrameLayout()) as row:
                mirrorX = wrap.Button(row.layout(), 'mirrorX')
                mirrorX.setLabel('X')
                mirrorX.setFontSize(16)
                mirrorX.clicked.connect(pa(undo(core.mirrorHair), 0))
                mirrorY = wrap.Button(row.layout(), 'mirrorY')
                mirrorY.setLabel('Y')
                mirrorY.setFontSize(16)
                mirrorY.clicked.connect(pa(undo(core.mirrorHair), 1))
                mirrorZ = wrap.Button(row.layout(), 'mirrorZ')
                mirrorZ.setLabel('Z')
                mirrorZ.setFontSize(16)
                mirrorZ.clicked.connect(pa(undo(core.mirrorHair), 2))

            with wrap.Row(frame.getFrameLayout()) as row:
                mirrorFlipGrp = QtWidgets.QButtonGroup(row.layout())
                mirror = wrap.Button(row.layout(), 'mirrorRadio')
                mirror.setLabel('Mirror')
                mirror.setButtonStyle('small')
                mirror.setCheckable(True)
                mirror.setChecked(True)
                flip = wrap.Button(row.layout(), 'flipRadio')
                flip.setLabel('Flip')
                flip.setButtonStyle('small')
                flip.setCheckable(True)

                mirrorFlipGrp.addButton(mirror)
                mirrorFlipGrp.addButton(flip)

        layout.addWidget(wrap.separator())

        # Control Curve and Apply
        with wrap.Row(layout) as row:
            controlCurve = wrap.Button(row.layout(), 'gsControlCurve')
            controlCurve.setLabel('Control Curve')
            controlCurve.clicked.connect(undo(core.controlCurveCreate))

            applyControlCurve = wrap.Button(row.layout(), 'gsApplyControlCurve')
            applyControlCurve.setLabel('Apply')
            applyControlCurve.setFixedWidth(style.scale(48))
            applyControlCurve.clicked.connect(undo(core.controlCurveApply))

        layout.addWidget(wrap.separator())

        # Curve Control Window
        with wrap.Row(layout) as row:
            curveControlWindow = wrap.Button(row.layout(), 'gsCurveControlWindow')
            curveControlWindow.setLabel('Curve Control Window')
            curveControlWindow.pressed.connect(ui.curveControlWorkspace)

        layout.addWidget(wrap.separator())

        # UV Editor Window
        with wrap.Row(layout) as row:
            uvEditor = wrap.Button(row.layout(), 'gsUVEditorMain')
            uvEditor.setLabel('UV Editor Window')
            uvEditor.pressed.connect(ui.uvEditorWorkspace)

        layout.addWidget(wrap.separator())

        # Version
        layout.addWidget(wrap.wrapControl(mc.text(l=core.VERSION)))

        # Toggling the correct switch
        warpSwitch.setChecked(core.getOption('warpSwitch'))
        extrudeSwitch.setChecked(not core.getOption('warpSwitch'))

        # Toggling layer collections widget
        core.layerCollections.toggleLayerCollectionsWidget()

        # Setting the custom tooltips
        tooltips.toggleCustomTooltipsMain(core.getOption('enableTooltips'))

    def selectionSets(self, i, layout, label):  # Creates layer button
        def toggleGeometryEdit(*_):
            core.curveGeometryEditToggle(i)
            core.updateMainUI()

        def toggleCurveVisibility(*_):
            core.toggleObjVisibility(i, 0)
            core.updateMainUI()

        def toggleGeoVisibility(*_):
            core.toggleObjVisibility(i, 1)
            core.updateMainUI()

        def toggleLayerVisibility(*_):
            core.toggleLayerVisibility(i)
            core.updateMainUI()
        selSet = wrap.Layer(layout=layout, objName='curveGrp%s' % i)
        selSet.setStyleSheet(style.layer())
        selSet.setLabel(str(label))
        mc.popupMenu(mm=1, p=selSet.objectName())
        mc.menuItem(rp='N', l='Add Selection to Layer', c=lambda _: core.curveAddToLayer(i))
        mc.menuItem(rp='NW', l='Extract Geometry', c=lambda _: core.extractCurveGeo(i))
        mc.menuItem(rp='NE', l='Toggle Geometry Edit', c=toggleGeometryEdit)
        mc.menuItem(rp='W', l='Select Curves', c=lambda _: core.curveLayerSelectObj(i, 0))
        mc.menuItem(rp='E', l='Select Geometry', c=lambda _: core.curveLayerSelectObj(i, 1))
        mc.menuItem(rp='SW', l='Toggle Curve Visibility', c=toggleCurveVisibility)
        mc.menuItem(rp='SE', l='Toggle Geo Visibility', c=toggleGeoVisibility)
        mc.menuItem(rp='S', l='Toggle Layer Visibility', c=toggleLayerVisibility)
        selSet.clicked.connect(pa(undo(core.layerClicked), i))
        return selSet

    def extrudeWarpToggle(self):
        buttons = ['newCard', 'newTube', 'curveCard', 'curveTube', 'addCards', 'addTubes']
        buttonStyle = style.buttonNormal
        if WIDGETS['extrudeSwitch'].isChecked():
            buttonStyle = style.buttonNormalBlueBorder
        for button in buttons:
            WIDGETS[button].setStyleSheet(buttonStyle)

    def updateLayerList(self):
        if 'gsLayerSelector' in WIDGETS:
            WIDGETS['gsLayerSelector'].updateLayerList()
            core.curveControlUI.updateUI()

    def toggleTooltips(self):
        for widget in WIDGETS:
            if hasattr(WIDGETS[widget], "enableTooltip") and callable(getattr(WIDGETS[widget], "enableTooltip")):
                WIDGETS[widget].enableTooltip(core.getOption('enableTooltips'))
        tooltips.toggleCustomTooltipsMain(core.getOption('enableTooltips'))
        tooltips.toggleCustomTooltipsCurveControl(core.getOption('enableTooltips'))