// ===========================================================================
// Copyright 2018 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
proc int indexToMapSize(int $i)
{
	int $val;

	switch ($i)
	{
	case 1:
		$val = 4096;
		break;
	case 2:
		$val = 2048;
		break;
	case 4:
		$val = 512;
		break;
	case 5:
		$val = 256;
		break;
	case 6:
		$val = 128;
		break;
	case 7:
		$val = 64;
		break;
	case 8:
		$val = 32;
		break;
	case 3:
	default:
		$val = 1024;
		break;
	}

	return $val;
}

proc setOptionVars(int $forceFactorySettings)
{
	if ($forceFactorySettings || !`optionVar -exists polyRelaxAlgorithm`)
		optionVar -intValue polyRelaxAlgorithm 1;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxPinBoundary`)
		optionVar -intValue polyRelaxPinBoundary 1;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxPinSelected`)
		optionVar -intValue polyRelaxPinSelected 0;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxPinUnselected`)
		optionVar -intValue polyRelaxPinUnselected 0;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxUseMaxIterations`)
		optionVar -intValue polyRelaxUseMaxIterations 0;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxMaxIterations`)
		optionVar -intValue polyRelaxMaxIterations 5;
	if ($forceFactorySettings || !`optionVar -exists polyRelaxPinUVs`)
		optionVar -intValue polyRelaxPinUVs 0;

	if ($forceFactorySettings || !`optionVar -exists OptimizeAlgorithm`)
		optionVar -intValue OptimizeAlgorithm 1; 

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizeIterations`)
		optionVar -intValue Unfold3DOptimizeIterations 1;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizeSurfaceAngle`)
		optionVar -floatValue Unfold3DOptimizeSurfaceAngle 1.0;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizePower`)
		optionVar -intValue Unfold3DOptimizePower 100;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DBorderOptimizeIntersect`)
		optionVar -intValue Unfold3DBorderOptimizeIntersect 1;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizeTriFlip`)
		optionVar -intValue Unfold3DOptimizeTriFlip 1;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizeMapSize`)
		optionVar -intValue Unfold3DOptimizeMapSize 3;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DOptimizeRoomSpace`)
		optionVar -intValue Unfold3DOptimizeRoomSpace 0;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DFixNonManifoldBeforeOptimize`)
		optionVar -intValue Unfold3DFixNonManifoldBeforeOptimize 0;

	if ($forceFactorySettings || !`optionVar -exists Unfold3DAskToFixNonManifoldBeforeOptimize`)
		optionVar -intValue Unfold3DAskToFixNonManifoldBeforeOptimize 1;
}

global proc optimizeSetup(string $parent, int $forceFactorySettings)
{
	setOptionVars($forceFactorySettings);
	setParent $parent;

	int $alg = 1;

	int $u3DLoaded = `pluginInfo -q -loaded Unfold3D`;
	if ($u3DLoaded)
	{
		// Which algorithm to use.
		// 1: Unfold3D Optimize
		// 2: Legacy relax
		$alg = `optionVar -q OptimizeAlgorithm`;
		if ($alg < 1 || $alg > 2)
			$alg = 1;
		radioButtonGrp -e -select $alg OptimizeAgorithm_RBG;

		tabLayout -e -selectTabIndex $alg optimizeAlgorithmTabs;
	}
	else
	{
		$alg = 2;
	}


	int $ival = `optionVar -query polyRelaxAlgorithm`;
	radioButtonGrp -edit -sl $ival polyRelaxAlgorithm;

	$ival = `optionVar -query polyRelaxPinBoundary`;
	checkBoxGrp -edit -value1 $ival polyRelaxPinBoundary;

	$ival = `optionVar -query polyRelaxPinUVs`;
	if($ival == 1)
	{
		checkBoxGrp -edit -value1 $ival polyRelaxPinUVs;
		radioButtonGrp -edit -enable 1 polyRelaxPinUVsOptions;

		$ival = `optionVar -query polyRelaxPinSelected`;
		if($ival)
			radioButtonGrp -edit -sl 1 polyRelaxPinUVsOptions;

		$ival = `optionVar -query polyRelaxPinUnselected`;
		if($ival)
			radioButtonGrp -edit -sl 2 polyRelaxPinUVsOptions;
	}
	else
	{
		radioButtonGrp -edit -enable 0 polyRelaxPinUVsOptions;
	}

	if ($u3DLoaded)
	{
		$ival = `optionVar -query polyRelaxMaxIterations`;
		intSliderGrp -edit -value $ival polyRelaxMaxIterations;

		$iVal = `optionVar -q Unfold3DOptimizeIterations`;
		intSliderGrp -edit -value $iVal Iterations_ISG;
	
		$iVal = `optionVar -q Unfold3DOptimizePower`;
		intSliderGrp -edit -value $iVal Power_ISG;
	
		float $fVal = `optionVar -q Unfold3DOptimizeSurfaceAngle`;
		floatSliderGrp -edit -value $fVal SurfaceAngle_FSG;

		$iVal = `optionVar -q Unfold3DOptimizeBorderIntersect`;
		checkBoxGrp -edit -value1 (0 != $iVal) BorderIntersect_CBG;
	
		$iVal = `optionVar -q Unfold3DOptimizeTriFlip`;
		checkBoxGrp -edit -value1 (0 != $iVal) TriFlip_CBG;	
	
		$iVal = `optionVar -q Unfold3DOptimizeMapSize`;
		optionMenuGrp -edit -select $iVal MapSize_OMG;

		$iVal = `optionVar -q Unfold3DOptimizeRoomSpace`;
		intSliderGrp -edit -value $iVal RoomSpace_ISG;
		
		$ival = `optionVar -query Unfold3DFixNonManifoldBeforeOptimize`;
		checkBoxGrp -e -v1 (0 != $ival) Unfold3DOptimizeFixNonManifold_CBG;
	}
}

global proc optimizeCallback(string $parent, int $doIt)
{
	setParent $parent;

	int $u3DLoaded = `pluginInfo -q -loaded Unfold3D`;
	if ($u3DLoaded)
	{
		int $alg = `radioButtonGrp -q -select OptimizeAgorithm_RBG`;
		optionVar -iv OptimizeAlgorithm $alg;
	}

	optionVar -intValue polyRelaxAlgorithm
		`radioButtonGrp -query -sl polyRelaxAlgorithm`;

	optionVar -intValue polyRelaxPinBoundary
		`checkBoxGrp -query -value1 polyRelaxPinBoundary`;

	int $ival = `checkBoxGrp -query -value1 polyRelaxPinUVs`;
	optionVar -intValue polyRelaxPinUVs $ival;
	if($ival == 1)
	{
		int $ival2 = `radioButtonGrp -q -sl polyRelaxPinUVsOptions`;
		if($ival2 == 1)
		{
			optionVar -intValue polyRelaxPinSelected 1;
			optionVar -intValue polyRelaxPinUnselected 0;
		}
		else
		{
			optionVar -intValue polyRelaxPinSelected 0;
			optionVar -intValue polyRelaxPinUnselected 1;
		}
	}
	else
	{
		optionVar -intValue polyRelaxPinSelected 0;
		optionVar -intValue polyRelaxPinUnselected 0;
	}

	optionVar -intValue polyRelaxMaxIterations
		`intSliderGrp -query -value polyRelaxMaxIterations`;

	if ($u3DLoaded)
	{
		$iVal = `intSliderGrp -q -value Iterations_ISG`;
		optionVar -intValue Unfold3DOptimizeIterations $iVal;
	
		$iVal = `intSliderGrp -q -value Power_ISG`;
		optionVar -intValue Unfold3DOptimizePower $iVal;
	
		$iVal = `checkBoxGrp -q -value1 BorderIntersect_CBG`;
		optionVar -intValue Unfold3DOptimizeBorderIntersect $iVal;
	
		$iVal = `checkBoxGrp -q -value1 TriFlip_CBG`;
		optionVar -intValue Unfold3DOptimizeTriFlip $iVal;
	
		$iVal = `optionMenuGrp -q -select MapSize_OMG`;
		optionVar -intValue Unfold3DOptimizeMapSize $iVal;
	
		$iVal = `intSliderGrp -q -value RoomSpace_ISG`;
		optionVar -intValue Unfold3DOptimizeRoomSpace $iVal;

		float $fVal = `floatSliderGrp -q -value SurfaceAngle_FSG`;
		optionVar -floatValue Unfold3DOptimizeSurfaceAngle $fVal;

		$ival = `checkBoxGrp -q -value1 Unfold3DOptimizeFixNonManifold_CBG`;
		optionVar -intValue Unfold3DFixNonManifoldBeforeOptimize $ival;
	}

	if ($doIt) {
		performPolyOptimizeUV 0;
		addToRecentCommandQueue "performPolyOptimizeUV 0" "PolyOptimizeUVs";
	}
}

global proc optimizeAgorithmChange()
{
	if (`radioButtonGrp -exists OptimizeAgorithm_RBG`)
	{
		int $alg = `radioButtonGrp -q -select OptimizeAgorithm_RBG`;
		tabLayout -e -selectTabIndex $alg optimizeAlgorithmTabs;
	}
}

proc newOptimizeOptions()
{
	string $topLevelParent = `setParent -q`;
	string $parent = `columnLayout`;

	string $settingsLabel = (uiRes("m_performPolyOptimizeUV.kSettingsFrame"));
	string $fixNonManifoldLabel = (uiRes("m_performPolyOptimizeUV.kFixNonManifold"));
	string $optsLabel = (uiRes("m_performPolyOptimizeUV.kOptimizeOptionsFrame"));
	string $iterLabel = (uiRes("m_performPolyOptimizeUV.kIterations"));
	string $packLabel = (uiRes("m_performPolyOptimizeUV.kPack"));
	string $selfIntLabel = (uiRes("m_performPolyOptimizeUV.kPreventSI"));
	string $triFlipLabel = (uiRes("m_performPolyOptimizeUV.kPreventTF"));
	string $roomLabel = (uiRes("m_performPolyOptimizeUV.kRoomSpace"));
	string $mapSizeLabel = (uiRes("m_performPolyOptimizeUV.kMapSize"));
	string $roomSpaceLabel = (uiRes("m_performPolyOptimizeUV.kRoomSpaceSize"));

	string $surfangleLabel = (uiRes("m_performPolyOptimizeUV.kSurfangle"));
	string $powerLabel = (uiRes("m_performPolyOptimizeUV.kPower"));

	// Setting frame
	string $settingsFrame = `frameLayout -l $settingsLabel`;
		columnLayout;
	
		checkBoxGrp 
			-l "" -label1 $fixNonManifoldLabel
			-value1 false 
			Unfold3DOptimizeFixNonManifold_CBG;
		
		setParent ..; //columnLayout
	setParent $parent; // frameLayout
	
	// Solver settings frame
	string $optionsFrame =  `frameLayout -label $optsLabel`;
	
		columnLayout;

		intSliderGrp -label $iterLabel -min 1 -max 10  -fieldMinValue 0 -fieldMaxValue 999 -value 1 Iterations_ISG;
		floatSliderGrp -label $surfangleLabel -min 0.0 -max 1.0 -field true -value 1.0 SurfaceAngle_FSG;
		intSliderGrp -label $powerLabel -min 1 -max 100  -fieldMinValue 0 -fieldMaxValue 999 -field true -value 100 Power_ISG;
		checkBoxGrp -label "" -label1 $selfIntLabel -value1 true BorderIntersect_CBG;
		checkBoxGrp -label "" -label1 $triFlipLabel -value1 true TriFlip_CBG;

		setParent ..; // columnLayout
		
	setParent $parent; // frameLayout	

	// Room space settings
	string $roomFrame =  `frameLayout -label $roomLabel`;

		columnLayout;

		optionMenuGrp -label $mapSizeLabel MapSize_OMG;
			menuItem -label "4096";
			menuItem -label "2048";
			menuItem -label "1024";
			menuItem -label "512";
			menuItem -label "256";
			menuItem -label "128";
			menuItem -label "64";
			menuItem -label "32";
		optionMenuGrp -edit -select 3 MapSize_OMG;

		intSliderGrp -label $roomSpaceLabel -field true -min 0 -max 10 
				-value 2 -fieldMinValue 0 -fieldMaxValue 999 RoomSpace_ISG;

		setParent ..; // columnLayout

	setParent $parent; // frameLayout

	setParent $topLevelParent;
}

proc legacyRelaxOptions()
{
	global int $gOptionBoxTemplateFrameSpacing;

	// Form layout
	string $parent = `formLayout polyRelaxUVOptions`;

		// Pinning frame
		string $pinningFrame = 
		`frameLayout -label (uiRes("m_performPolyOptimizeUV.kPinningFrame"))`;
	
			columnLayout;
	
			checkBoxGrp -label1 (uiRes("m_performPolyOptimizeUV.kPinUVBorder")) polyRelaxPinBoundary;

			separator -style "none";

			checkBoxGrp -label1 (uiRes("m_performPolyOptimizeUV.kPinUVs")) 
				-onc "radioButtonGrp -edit -en 1 polyRelaxPinUVsOptions"
				-ofc "radioButtonGrp -edit -en 0 polyRelaxPinUVsOptions" polyRelaxPinUVs;

			radioButtonGrp -label ""
				-numberOfRadioButtons 2
				-label1 (uiRes("m_performPolyOptimizeUV.kPolyRelaxPinSel"))
				-label2 (uiRes("m_performPolyOptimizeUV.kPolyRelaxPinUnsel"))
				-select 1 -vr -cat 2 "left" 20
				polyRelaxPinUVsOptions;

		setParent $parent;

		// Other settings frame
		string $otherSettingsFrame = 
		`frameLayout -label (uiRes("m_performPolyOptimizeUV.kOtherSettingsFrame"))`;

			columnLayout;

			radioButtonGrp -label (uiRes("m_performPolyOptimizeUV.kEdgeWeights"))
				-numberOfRadioButtons 2
				-label1 (uiRes("m_performPolyOptimizeUV.kPolyRelaxUform"))
				-label2 (uiRes("m_performPolyOptimizeUV.kPolyRelaxWorldSpace"))
				-select 1 -vr 
				polyRelaxAlgorithm;

			intSliderGrp 
				-label (uiRes("m_performPolyOptimizeUV.kMaxIterations")) 
				-min 1 
				-max 10 
				-fmn 1 
				-fmx 1000000 
				polyRelaxMaxIterations;

		setParent $parent;	
		
	setParent ..;

	// Attach frames to form layout
	formLayout -e
		-af $pinningFrame "top" $gOptionBoxTemplateFrameSpacing
		-af $pinningFrame "left" $gOptionBoxTemplateFrameSpacing
		-af $pinningFrame "right" $gOptionBoxTemplateFrameSpacing
		-an $pinningFrame "bottom"

		-ac $otherSettingsFrame "top" $gOptionBoxTemplateFrameSpacing $pinningFrame
		-af $otherSettingsFrame "left" $gOptionBoxTemplateFrameSpacing
		-af $otherSettingsFrame "right" $gOptionBoxTemplateFrameSpacing
		-an $otherSettingsFrame "bottom" 
	$parent;
}

proc optimizeOptions()
{
	// Global template variables for form and widget spacing
	global int $gOptionBoxTemplateDescriptionMarginWidth;
	global int $gOptionBoxTemplateFrameSpacing;
	global int $gOptionBoxTemplateTextColumnWidth;
	global int $gOptionBoxTemplateSingleWidgetWidth;
	global int $gOptionBoxTemplateSliderWidgetWidth;
	global int $gOptionBoxTemplateOffsetText;
	
	//	Name of the command for this option box.
	//
	string $commandName = "optimize";
	string $callback = ($commandName + "Callback");
	string $setup = ($commandName + "Setup");

	//	Get the option box.
	//
	string $layout = getOptionBox();
	setParent $layout;
	
	//	Pass the command name to the option box.
	//
	setOptionBoxCommandName($commandName);
	
	//	Activate the option box UI template.
	//
	setUITemplate -pushTemplate OptionBoxTemplate;

	string $parent = `scrollLayout`;

	// Form layout
	formLayout polyOpimizeOptions;

		if (`pluginInfo -q -loaded Unfold3D`)
		{
			string $legacyLbl = (uiRes("m_performPolyOptimizeUV.kLegacyLabel"));
			string $unfold3DLbl = (uiRes("m_performPolyOptimizeUV.kUnfoldLabel"));

			radioButtonGrp -numberOfRadioButtons 2 -label (uiRes("m_performPolyOptimizeUV.kMethodLabel"))
				-labelArray2 $unfold3DLbl $legacyLbl
				-vertical
				-changeCommand "optimizeAgorithmChange"
				OptimizeAgorithm_RBG;
			setParent ..;

			string $tabs = `tabLayout -tabsVisible false optimizeAlgorithmTabs`;

				newOptimizeOptions();
				legacyRelaxOptions;

			setParent ..;
		}
		else
		{
			legacyRelaxOptions;
			setParent ..;
		}


	//	Deactivate the default UI template.
	//
	setUITemplate -popTemplate;

	//	'Apply' button.
	//
	string $applyBtn = getOptionBoxApplyBtn();
	button -edit
		-command ($callback + " " + $parent + " " + 1)
		$applyBtn;

	//	'Save' button.
	//
	string $saveBtn = getOptionBoxSaveBtn();
	button -edit 
		-command ($callback + " " + $parent + " " + 0 + "; hideOptionBox")
		$saveBtn;

	//	'Reset' button.
	//
	string $resetBtn = getOptionBoxResetBtn();
	button -edit 
		-command ($setup + " " + $parent + " " + 1)
		$resetBtn;

	//	Set the option box title.
	//
	setOptionBoxTitle (uiRes("m_performPolyOptimizeUV.kOptimizeUVsOptions"));
	setOptionBoxHelpTag("OptimizeUVs");

	//	Set the current values of the option box.
	//
	eval (($setup + " " + $parent + " " + 0));
	
	//	Show the option box.
	//
	showOptionBox();
}

proc string assembleCmd()
{
	string $cmd;
	int $alg = 2;

	if (`pluginInfo -q -loaded Unfold3D`)
	{
		$alg = `optionVar -q OptimizeAlgorithm`;
		if ($alg < 1 || $alg > 2)
			$alg = 1;
	}

	if (2 == $alg)
	{
		int		$ra = `optionVar -query polyRelaxAlgorithm`;
		int		$pb = `optionVar -query polyRelaxPinBoundary`;
		int		$ps = `optionVar -query polyRelaxPinSelected`;
		int		$pu = `optionVar -query polyRelaxPinUnselected`;
		float	$tol = 0.0;
		string	$ras[] = { "uniform", "harmonic" };

		$cmd = "untangleUV -r " + $ras[$ra-1] + " -pb " + $pb + " -ps " + $ps + " -pu " + $pu
				+ " -rt " + $tol;
		int	 $mri = `optionVar -query polyRelaxMaxIterations`;

		$cmd += " -mri " + $mri;
	}
	else
	{
		$cmd = "u3dOptimize ";
		int $iVal;
		float $fVal;

		$iVal = `optionVar -q Unfold3DOptimizeIterations`;
		$cmd += ("-ite " + $iVal + " ");

		$iVal = `optionVar -q Unfold3DOptimizePower`;
		$cmd += ("-pow " + ($iVal/100) + " ");
	
		$fVal = `optionVar -q Unfold3DOptimizeSurfaceAngle`;
		$cmd += ("-sa " + $fVal + " ");

		$iVal = `optionVar -q Unfold3DOptimizeBorderIntersect`;
		$cmd += ("-bi " + $iVal + " ");
	
		$iVal = `optionVar -q Unfold3DOptimizeTriFlip`;
		$cmd += ("-tf " + $iVal + " ");
	
		$iVal = `optionVar -q Unfold3DOptimizeMapSize`;
		$iVal = indexToMapSize($iVal);
		$cmd += ("-ms " + $iVal + " ");

		$iVal = `optionVar -q Unfold3DOptimizeRoomSpace`;
		$cmd += ("-rs " + $iVal + ";");
	}

	return $cmd;
}

global proc Unfold3DFixNonManifoldBeforeOptimizeDialog()
{
	string $commandName = "Optimize";
	string $commandDisplayName = (uiRes("m_performPolyOptimizeUV.kOptimize"));
	Unfold3DFixNonManifoldDialog($commandName, $commandDisplayName);
}

global proc string performPolyOptimizeUV(int $action)
{
	string $cmd = "";

	switch ($action) {

		//	Execute the command.
		//
		case 0:
			//	Retrieve the option settings
			//
			setOptionVars(false);

			//	Get the command.
			//
			$cmd = `assembleCmd`;

			int $alg = 1;
			if (`pluginInfo -q -loaded Unfold3D`)
			{
				$alg = `optionVar -q OptimizeAlgorithm`;
				if ($alg < 1 || $alg > 2)
					$alg = 1;
			}
			
			if ($alg == 1)
			{
				// validate the mesh and clean it up
				string $topoValidCmd = "u3dTopoValid -type";
				string $topoErrors[] = eval($topoValidCmd);

				if (size($topoErrors) > 0)
				{
					int $doClean = 0;
					if (`optionVar -q Unfold3DFixNonManifoldBeforeOptimize`)
						$doClean = 1;
					else if (`optionVar -q Unfold3DAskToFixNonManifoldBeforeOptimize`)
					{
						string $ret = `layoutDialog -title (uiRes("m_performPolyOptimizeUV.kFixNonManifold")) -ui "Unfold3DFixNonManifoldBeforeOptimizeDialog"`;
						if($ret == "yes")
							$doClean = 1;
					}
					
					if ($doClean)
						Unfold3DFixNonManifold($topoErrors);
				}
			}
			//	Execute the command with the option settings.
			//
			evalEcho($cmd);

			break;

		//	Show the option box.
		//
		case 1:
			optimizeOptions;
			break;

		//	Return the command string.
		//
		case 2:
			//	Retrieve the option settings.
			//
			setOptionVars (false);

			//	Get the command.
			//
			$cmd = `assembleCmd`;

			break;
	}
	return $cmd;
}