import dialogs.InputDialog;
import elements.BaseGuiElement;
import elements.GuiPanel;
import elements.GuiText;
import elements.GuiButton;
import elements.GuiSprite;
import elements.GuiCheckbox;
import elements.GuiSkinElement;
import elements.GuiContextMenu;
import elements.MarkupTooltip;
import resources, ship_groups;
import elements.Gui3DObject;
#include "dialogs/include/UniqueDialogs.as"
import obj_selection;
import icons;
from gui import animate_time;
from targeting.targeting import cancelTargeting;
from targeting.MoveTarget import isExtendedMoveTarget;

const int GROUP_WIDTH = 256;
const int GROUP_SPACING = 32;

const int SUPPORT_PADDING = 12;
const int SUPPORT_HEIGHT = 56;
const int SUPPORT_WIDTH = GROUP_WIDTH - SUPPORT_PADDING * 2;
const int SUPPORT_SPACING = 8;
const int BAR_WIDTH = SUPPORT_WIDTH + SUPPORT_PADDING * 2 + 20;
const vec2i addButtonSize = vec2i(180,32);

const double ANIM_TIME = 0.15;

from tabs.GalaxyTab import GalaxyOverlay;
GalaxyOverlay@ createSupportOverlay(IGuiElement@ tab, Object@ obj, Object@ to, bool animate = true) {
	return SupportOverlay(tab, obj, to, animate);
}

class SupportOverlay : GalaxyOverlay, BaseGuiElement {
	Object@ leader;

	GroupDisplay@ main;
	GroupDisplay@ secondary;

	SupportClass@[] selected;
	vec2i dragStart;
	bool leftDown = false;
	bool rightDown = false;
	bool dragging = false;
	bool closing = false;

	SupportClass@ clsHover;
	GroupDisplay@ grpHover;

	SupportOverlay(IGuiElement@ parent, Object@ Leader, Object@ To, bool animate) {
		@leader = Leader;
		super(parent, Alignment(Left, Top, Right, Bottom));

		if(To !is null)
			makeSecondary(To);

		@main = GroupDisplay(leader, this, 255);
		Alignment align(Left+4, Top+34, Left+4+BAR_WIDTH, Bottom);
		if(animate)
			main.animate(align);
		else
			@main.alignment = align;

		updateAbsolutePosition();
		bringToFront();
		setGuiFocus(this);
	}

	void makeSecondary(Object@ obj) {
		if(main !is null && obj is main.leader)
			@obj = null;
		if(secondary !is null) {
			if(obj is null) {
				secondary.remove();
				@secondary = null;
			}
			else {
				secondary.set(obj);
			}
		}
		else if(obj !is null) {
			@secondary = GroupDisplay(obj, this);
			@secondary.alignment = Alignment(Left+2+BAR_WIDTH, Top+94, Left+2+BAR_WIDTH*2, Bottom-220);
			secondary.sendToBack();
		}
	}

	GroupDisplay@ getHoveredGroup(vec2i absPos) {
		if(main.absolutePosition.isWithin(absPos))
			return main;
		if(secondary !is null && secondary.absolutePosition.isWithin(absPos))
			return secondary;
		return null;
	}

	SupportClass@ getHoveredClass(vec2i absPos) {
		GroupDisplay@ grp = getHoveredGroup(absPos);
		if(grp !is null)
			return grp.getHoveredClass(absPos);
		return null;
	}

	bool isOpen() {
		return parent !is null;
	}

	bool objectInteraction(Object& object, uint mouseButton, bool doubleClicked) {
		return false;
	}

	void close() {
		if(parent is null || closing)
			return;
		close(main);
	}

	void close(GroupDisplay@ disp) {
		if(disp is main) {
			main.animateClose();
			closing = true;
		}
		else if(disp is secondary) {
			secondary.remove();
			@secondary = null;
			deselect();
		}
	}

	IGuiElement@ elementFromPosition(const vec2i& pos) {
		if(dragging) {
			//Cannot access inner elements while dragging,
			//we handle all the drag and drop stuff ourselves
			if(AbsoluteClipRect.isWithin(pos))
				return this;
			return null;
		}
		else {
			return BaseGuiElement::elementFromPosition(pos);
		}
	}

	void updateHover() {
		@grpHover = getHoveredGroup(mousePos);
		if(grpHover !is null)
			@clsHover = grpHover.getHoveredClass(mousePos);
		else
			@clsHover = null;
	}

	void dropGroups() {
		updateTimer = 0.1;

		Object@ transferTo;
		if(grpHover !is null)
			@transferTo = grpHover.leader;
		else
			@transferTo = hoveredObject;
		if(transferTo !is null && transferTo.owner.controlled && transferTo.hasLeaderAI) {
			for(uint i = 0, cnt = selected.length; i < cnt; ++i) {
				SupportClass@ cls = selected[i];
				if(cls.disp.leader is transferTo || cls.disp is null)
					continue;

				uint amt = cls.dat.totalSize - cls.leaveAmount;
				cls.disp.leader.transferSupports(cls.dat.dsg, amt, transferTo);
			}
		}

		main.update();
		if(secondary !is null)
			secondary.update();
		deselect();
	}

	void deselect() {
		for(uint i = 0, cnt = selected.length; i < cnt; ++i) {
			selected[i].selected = false;
			selected[i].leaveAmount = 0;
		}
		selected.length = 0;
	}

	void select(SupportClass@ cls) {
		cls.selected = true;
		cls.leaveAmount = 0;
		if(selected.find(cls) == -1)
			selected.insertLast(cls);
	}

	void deselect(SupportClass@ cls) {
		cls.selected = false;
		cls.leaveAmount = 0;
		selected.remove(cls);
	}

	void pingUpdate() {
		main.update();
		if(secondary !is null)
			secondary.update();
		updateTimer = 0.15;
	}

	double updateTimer = 0.0;
	bool update(double time) {
		if(closing)
			return true;
		if(selectedObject !is main.leader) {
			if(selectedObject is null || !selectedObject.hasLeaderAI)
				return false;
			main.set(selectedObject);
			if(secondary !is null) {
				secondary.remove();
				@secondary = null;
			}
		}

		updateTimer -= time;
		if(updateTimer <= 0) {
			main.update();
			if(secondary !is null) {
				secondary.update();
				secondary.visible = !main.animating;
			}
			updateTimer += 0.5;
		}

		return true;
	}

	bool onMouseEvent(const MouseEvent& event, IGuiElement@ source) {
		if(event.type == MET_Button_Down) {
			if(event.button == 0) {
				dragging = false;
				leftDown = true;
				dragStart = mousePos;

				if(clsHover !is null) {
					if(ctrlKey) {
						if(clsHover.selected)
							deselect(clsHover);
						else
							select(clsHover);
						leftDown = false;
					}
					else {
						if(!shiftKey)
							deselect();
						select(clsHover);
					}
				}
				else {
					deselect();
				}
			}
			else if(event.button == 1) {
				if(!leftDown)
					dragStart = mousePos;
				rightDown = true;
				return false;
			}
		}
		else if(event.type == MET_Moved) {
			updateHover();
			if(!dragging && leftDown && mousePos.distanceTo(dragStart) > 3 && selected.length != 0) {
				bool selSats = false;
				for(uint i = 0, cnt = selected.length; i < cnt; ++i)  {
					if(selected[i].dat.dsg.hasTag(ST_Satellite)) {
						selSats = true;
						break;
					}
				}
				if(!selSats) {
					dragging = true;
					for(uint i = 0, cnt = selected.length; i < cnt; ++i) {
						if(shiftKey)
							selected[i].leaveAmount = selected[i].dat.totalSize - selected[i].dat.amount;
						else
							selected[i].leaveAmount = 0;
					}
				}
			}
			if(dragging) {
			}
		}
		else if(event.type == MET_Scrolled) {
			for(uint i = 0, cnt = selected.length; i < cnt; ++i) {
				SupportClass@ cls = selected[i];

				int y = event.y;
				if(shiftKey)
					y *= 10;
				cls.leaveAmount = clamp(cls.leaveAmount - y, 0, cls.dat.totalSize);
			}
			return true;
		}
		else if(event.type == MET_Button_Up) {
			if(event.button == 0) {
				leftDown = false;
				if(dragging) {
					dropGroups();
					dragging = false;
					return true;
				}
			}
			else if(event.button == 1) {
				rightDown = false;
				if(mousePos.distanceTo(dragStart) < 5 && !isExtendedMoveTarget() && hoveredObject is null) {
					close(main);
					cancelTargeting();
					return true;
				}
			}
		}
		return BaseGuiElement::onMouseEvent(event, source);
	}

	bool onKeyEvent(const KeyboardEvent& event, IGuiElement@ source) override {
		switch(event.type) {
			case KET_Key_Down:
				if(event.key == KEY_ESC)
					return true;
			break;
			case KET_Key_Up:
				if(event.key == KEY_ESC) {
					close(main);
					return true;
				}
			break;
		}
		return BaseGuiElement::onKeyEvent(event, source);
	}

	bool get_isRoot() const override {
		return getHoveredGroup(mousePos) is null;
	}

	void draw() override {
		BaseGuiElement::draw();

		if(dragging) {
			vec2i dragDiff = mousePos - dragStart;
			for(uint i = 0, cnt = selected.length; i < cnt; ++i)
				selected[i].drawAt(selected[i].absolutePosition.topLeft + dragDiff, true);
		}
	}
};

class GroupDisplay : BaseGuiElement {
	SupportOverlay@ overlay;
	Object@ leader;
	Alignment@ targPos;
	bool animating = false;
	bool closing = false;

	//Group leader display
	GuiSkinElement@ capBG;
	GuiText@ capText;
	GuiText@ groupSize;

	//List of support groups
	GuiPanel@ listPanel;
	SupportClass@[] classes;
	GroupData[] groupData;

	//Action buttons
	GuiButton@ addButton;
	GuiButton@ rebuyButton;
	GuiButton@ clearButton;
	GuiCheckbox@ autoBuy;
	GuiCheckbox@ autoFill;
	GuiCheckbox@ allowFillFrom;

	GroupDisplay(Object@ obj, SupportOverlay@ Overlay, int offset = 0) {
		@leader = obj;
		@overlay = Overlay;

		super(overlay, recti());

		@capBG = GuiSkinElement(this, Alignment(Left, Top, Right-22, Top+50), SS_FullTitle);

		@capText = GuiText(this, Alignment(Left+12, Top+8, Right-12, Top+24), locale::SUPPORT_CAPACITY);
		capText.font = FT_Bold;

		@groupSize = GuiText(this, Alignment(Left+4, Top+20, Right-32, Top+48));
		groupSize.horizAlign = 1.0;

		@listPanel = GuiPanel(this, Alignment(Left+SUPPORT_PADDING, Top+55, Right-SUPPORT_PADDING, Bottom-offset-108));

		@addButton = GuiButton(this, recti(0, 0, 180, 32), locale::ADD_SUPPORTS);
		addButton.tooltip = locale::CREATE_SUPPORT_SHIPS;
		addButton.buttonIcon = icons::Add;

		@rebuyButton = GuiButton(this, Alignment(Left+4, Bottom-offset-60, Left+0.5f-15, Bottom-offset-30), locale::REBUY_GHOSTS);
		setMarkupTooltip(rebuyButton, locale::TT_REBUY_GHOSTS);
		rebuyButton.color = colors::Money;
		rebuyButton.setIcon(icons::Money);
		@clearButton = GuiButton(this, Alignment(Left+0.5f-6, Bottom-offset-60, Right-25, Bottom-offset-30), locale::CLEAR_GHOSTS);
		clearButton.color = colors::Red;
		clearButton.setIcon(icons::Remove);
		setMarkupTooltip(clearButton, locale::TT_CLEAR_GHOSTS);

		@autoFill = GuiCheckbox(this, Alignment(Left+8, Bottom-offset-29, Left+0.5f-15, Bottom-offset-3), locale::AUTO_FILL_SUPPORTS);
		setMarkupTooltip(autoFill, locale::TT_AUTO_FILL_SUPPORTS);
		@autoBuy = GuiCheckbox(this, Alignment(Left+0.5f-5+3, Bottom-offset-29, Right-25, Bottom-offset-3), locale::AUTO_BUY_SUPPORTS);
		setMarkupTooltip(autoBuy, locale::TT_AUTO_BUY_SUPPORTS);
		@allowFillFrom = GuiCheckbox(this, Alignment(Left+8, Bottom-offset-29, Left+0.5f-15, Bottom-offset-3), locale::ALLOW_FILL_FROM_SUPPORTS);
		setMarkupTooltip(allowFillFrom, locale::TT_ALLOW_FILL_FROM_SUPPORTS);

		update();
	}

	void remove() {
		@overlay = null;
		BaseGuiElement::remove();
	}

	void set(Object@ obj) {
		@leader = obj;
		update();
	}

	SupportClass@ getHoveredClass(vec2i absPos) {
		for(uint i = 0, cnt = classes.length; i < cnt; ++i) {
			if(classes[i].absolutePosition.isWithin(absPos))
				return classes[i];
		}
		return null;
	}

	void update() {
		groupData.syncFrom(leader.getSupportGroups());

		//Remove old buttons
		uint newCnt = groupData.length;
		uint oldCnt = classes.length;

		for(uint i = newCnt; i < oldCnt; ++i) {
			classes[i].remove();
			@classes[i] = null;
		}

		//Update current buttons
		classes.length = newCnt;
		int y = SUPPORT_SPACING;
		for(uint i = 0; i < newCnt; ++i) {
			if(classes[i] is null)
				@classes[i] = SupportClass(this);

			SupportClass@ cls = classes[i];
			cls.set(groupData[i]);
			cls.position = vec2i(0, y);
			y += SUPPORT_HEIGHT + SUPPORT_SPACING;
		}

		//Update action button position
		if(y + 36 > listPanel.size.height)
			y = listPanel.rect.botRight.y + 14;
		else
			y += 55;
		addButton.position = vec2i((GROUP_WIDTH - addButton.size.width) / 2, y);

		//Update group size
		uint size = 0;
		Ship@ leaderShip = cast<Ship>(leader);
		if(leaderShip !is null)
			size = leaderShip.blueprint.design.size;

		int supUsed = leader.SupplyUsed;
		int supCap = leader.SupplyCapacity;
		groupSize.text = toString(supUsed) + " / "
							+ toString(supCap);
		if(supUsed >= supCap)
			capBG.color = colors::Red;
		else if(float(supUsed) >= float(supCap) * 0.9f)
			capBG.color = Color(0xff8000ff);
		else
			capBG.color = colors::White;
		addButton.disabled = supUsed >= supCap;

		//Update controls
		autoFill.visible = !leader.isPlanet && !leader.isOrbital;
		allowFillFrom.visible = !autoFill.visible;
		autoBuy.visible = true;
		rebuyButton.visible = !leader.isPlanet;
		clearButton.visible = !leader.isPlanet;
		autoBuy.checked = leader.autoBuySupports;

		if(autoFill.visible) {
			autoFill.checked = leader.autoFillSupports;

			int cost = 0;
			for(uint i = 0; i < newCnt; ++i) {
				auto@ dat = groupData[i];
				if(dat.ghost > 0)
					cost += getBuildCost(dat.dsg) * dat.ghost;
			}

			rebuyButton.disabled = cost == 0 || !playerEmpire.canPay(cost);
			clearButton.disabled = cost == 0;
			rebuyButton.text = format(locale::REBUY_GHOSTS, formatMoney(cost));
		}
		else {
			allowFillFrom.checked = leader.allowFillFrom;
		}
	}

	void draw() {
		uint flags = SF_Normal;
		recti pos = AbsolutePosition;
		if(!listPanel.vert.visible)
			pos.botRight.x -= 20;
		skin.draw(SS_GroupPanel, flags, pos);
		BaseGuiElement::draw();
	}

	void animate(Alignment@ pos) {
		@targPos = pos;
		@alignment = null;
		recti endPos = targPos.resolve(parent.size);
		rect = endPos + vec2i(0, endPos.height);
		animate_time(this, endPos, ANIM_TIME);
		animating = true;
		if(overlay.secondary !is null)
			overlay.secondary.visible = false;
	}

	void animateClose() {
		if(parent is null || overlay is null)
			return;
		@alignment = null;
		recti endPos = rect + vec2i(0, rect.height);
		animate_time(this, endPos, ANIM_TIME);
		animating = true;
		closing = true;
		if(overlay.secondary !is null)
			overlay.secondary.visible = false;
	}

	bool onMouseEvent(const MouseEvent& event, IGuiElement@ source) override {
		if(event.type == MET_Button_Down) {
			if(event.button == 1) {
				return true;
			}
		}
		else if(event.type == MET_Button_Up) {
			if(event.button == 1) {
				overlay.close(this);
				return true;
			}
		}
		return BaseGuiElement::onMouseEvent(event, source);
	}

	bool onGuiEvent(const GuiEvent& evt) {
		if(evt.type == GUI_Clicked) {
			if(evt.caller is addButton) {
				CreateSupportDialog dlg(overlay, leader, null, 10);
				addDialog(D_SupportAmount, dlg);
				return true;
			}
			if(evt.caller is clearButton) {
				leader.clearAllGhosts();
				overlay.pingUpdate();
				return true;
			}
			if(evt.caller is rebuyButton) {
				leader.rebuildAllGhosts();
				overlay.pingUpdate();
				return true;
			}
		}
		else if(evt.type == GUI_Changed) {
			if(evt.caller is autoFill) {
				leader.autoFillSupports = autoFill.checked;
				return true;
			}
			if(evt.caller is autoBuy) {
				leader.autoBuySupports = autoBuy.checked;
				return true;
			}
			if(evt.caller is allowFillFrom) {
				leader.allowFillFrom = allowFillFrom.checked;
				return true;
			}
		}
		else if(evt.type == GUI_Animation_Complete) {
			animating = false;
			if(closing) {
				if(overlay !is null)
					overlay.remove();
			}
			else {
				@alignment = targPos;
				if(overlay.secondary !is null)
					overlay.secondary.visible = true;
			}
			return true;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}
};

class SupportClass : BaseGuiElement {
	GroupDisplay@ disp;
	GroupData@ dat;
	bool selected = false;
	uint leaveAmount = 0;

	GuiButton@ addButton;
	GuiButton@ removeButton;

	SupportClass(GroupDisplay@ d) {
		@disp = d;
		super(disp.listPanel, recti(0, 0, SUPPORT_WIDTH, SUPPORT_HEIGHT));

		@addButton = GuiButton(this, Alignment(Right-40, Top, Right, Top+0.5f));
		addButton.tooltip = locale::CREATE_SUPPORT_SHIPS;
		addButton.color = colors::Green;
		addButton.visible = false;
		addButton.setIcon(icons::Add);

		@removeButton = GuiButton(this, Alignment(Right-40, Top+0.5f, Right, Bottom));
		removeButton.tooltip = locale::SCUTTLE_SUPPORT_SHIPS;
		removeButton.color = colors::Red;
		removeButton.setIcon(icons::Minus);
		removeButton.visible = false;
	}

	void remove() {
		@disp = null;
		BaseGuiElement::remove();
	}

	void set(GroupData@ data) {
		@dat = data;
	}

	void drawAt(const vec2i& absPos, bool dragging) {
		recti pos = recti_area(absPos, size);

		uint flags = SF_Normal;
		if(disp !is null && disp.overlay.clsHover is this)
			flags |= SF_Hovered;
		if(selected)
			flags |= SF_Active;

		uint tot = dat.totalSize;
		uint amount = dat.amount;
		uint ghost = dat.ghost;
		uint ordered = dat.ordered;

		if(dragging) {
			tot = dat.totalSize - leaveAmount;

			//Calculate proportions to take
			uint lv = leaveAmount;
			uint take = min(ordered, lv);
			lv -= take;
			ordered -= take;

			take = min(ghost, lv);
			lv -= take;
			ghost -= take;

			take = min(amount, lv);
			lv -= take;
			amount -= take;
		}
		else if(disp.overlay.dragging && selected) {
			tot = leaveAmount;

			//Calculate proportions to leave
			uint lv = leaveAmount;
			uint take = min(ghost, lv);
			lv -= take;
			ghost = take;

			take = min(ordered, lv);
			lv -= take;
			ordered = take;

			take = min(amount, lv);
			lv -= take;
			amount= take;
		}

		skin.draw(SS_PatternBox, flags, pos, dat.dsg.color);
		if(disp !is null && disp.overlay.clsHover is this && !dragging)
			skin.draw(SS_SubtleGlow, SF_Normal, pos, dat.dsg.color);

		Color col;
		col = dat.dsg.color;
		col.a = 0x80;
		dat.dsg.icon.draw(recti_area(pos.topLeft+vec2i(4,0), vec2i(pos.height, pos.height)), col);

		const Font@ normal = skin.getFont(FT_Normal);
		normal.draw(pos=recti_area(pos.topLeft + vec2i(pos.height+6, 6), vec2i(pos.width-pos.height-12, 22)), text=formatShipName(dat.dsg), stroke=colors::Black);

		const Font@ bold = skin.getFont(FT_Bold);
		bold.draw(pos=recti_area(pos.topLeft + vec2i(pos.height+12, 28), vec2i(60, 22)), text=toString(amount)+"x", stroke=colors::Black);

		if(ordered > 0)
			normal.draw(pos=recti_area(pos.topLeft + vec2i(pos.height+82, 28), vec2i(60, 22)), text="(+"+toString(ordered)+"x)", stroke=colors::Black, color=Color(0x80ff80ff));
		if(ghost > 0)
			normal.draw(pos=recti_area(pos.topLeft + vec2i(pos.height+132, 28), vec2i(60, 22)), text="(-"+toString(ghost)+"x)", stroke=colors::Black, color=Color(0xff8080ff));
	}

	bool onGuiEvent(const GuiEvent& evt) {
		if(evt.type == GUI_Clicked) {
			if(evt.caller is addButton) {

				GuiContextMenu menu(mousePos);

				uint canBuild = uint(double(disp.leader.SupplyAvailable) / dat.dsg.size);
				uint max = canBuild + dat.ghost;
				if(max > 0)
					menu.addOption(OrderSupports(disp.leader, dat.dsg, max));
				if(dat.ghost > 0 && dat.ghost < max)
					menu.addOption(OrderSupports(disp.leader, dat.dsg, dat.ghost));
				uint maxMoney = floor(double(playerEmpire.RemainingBudget) / double(getBuildCost(dat.dsg)));
				if(maxMoney < max && maxMoney != dat.ghost)
					menu.addOption(OrderSupports(disp.leader, dat.dsg, maxMoney));
				if(max > 10 && maxMoney > 10)
					menu.addOption(OrderSupports(disp.leader, dat.dsg, 10));
				if(max > 1 && maxMoney > 1)
					menu.addOption(OrderSupports(disp.leader, dat.dsg, 1));

				uint orderAmt = 10;
				if(dat.ghost != 0)
					orderAmt = dat.ghost;
				if(orderAmt > max)
					orderAmt = max;
				menu.addOption(CustomSupportOrder(disp.overlay, disp.leader, dat.dsg, orderAmt));
				menu.finalize();

				return true;
			}
			else if(evt.caller is removeButton) {
				InputDialog@ dialog = InputDialog(ScuttleSupports(this), disp.overlay);
				dialog.addTitle(locale::SCUTTLE_SUPPORT_SHIPS);
				dialog.accept.text = locale::REMOVE;

				uint defAmount = 0;
				if(dat.ghost > 0)
					defAmount = dat.ghost;
				if(dat.ordered > 0)
					defAmount = dat.ordered;
				dialog.addSpinboxInput(locale::AMOUNT, defAmount, 10.0, 1.0, dat.totalSize, 0);

				addDialog(D_SupportAmount, dialog);
				dialog.focusInput();
			}
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void draw() {
		drawAt(AbsolutePosition.topLeft, false);

		bool hover = disp !is null && !disp.overlay.dragging && disp.overlay.clsHover is this;
		addButton.visible = hover && (disp.leader.SupplyAvailable >= uint(dat.dsg.size) || dat.ghost > 0);
		removeButton.visible = hover;

		BaseGuiElement::draw();
	}
};

class OrderSupports : GuiContextOption {
	Object@ forObject;
	const Design@ dsg;
	uint amount;
	int build = 0;
	int maintain = 0;

	OrderSupports(Object@ forObject, const Design@ dsg, uint amount) {
		double labor = 0;
		getBuildCost(dsg, this.build, maintain, labor, amount);

		this.amount = amount;
		@this.forObject = forObject;
		@this.dsg = dsg;

		string text = format(locale::ORDER_SUPPORT_COUNT, toString(amount), dsg.name);
		text += " ("+formatMoney(this.build, maintain)+")";
		super(text);
	}

	void call(GuiContextMenu@ menu) {
		if(dsg !is null && amount > 0)
			forObject.orderSupports(dsg, amount);
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		if(!playerEmpire.canPay(this.build))
			drawRectangle(absPos, Color(0xff900040));
		GuiContextOption::draw(ele, flags, absPos);
	}
};

class CustomSupportOrder : GuiContextOption {
	SupportOverlay@ overlay;
	Object@ forObject;
	const Design@ dsg;
	uint amount;

	CustomSupportOrder(SupportOverlay@ overlay, Object@ forObject, const Design@ dsg, uint amount) {
		this.amount = amount;
		@this.forObject = forObject;
		@this.dsg = dsg;
		@this.overlay = overlay;

		super(locale::ORDER_SUPPORT_CUSTOM);
	}

	void call(GuiContextMenu@ menu) {
		CreateSupportDialog dlg(overlay, forObject, dsg, amount);
		addDialog(D_SupportAmount, dlg);
	}
};

enum Dialogs {
	D_SupportAmount,
};

class ScuttleSupports : InputDialogCallback {
	Object@ at;
	const Design@ dsg;

	ScuttleSupports(SupportClass@ cls) {
		@at = cls.disp.leader;
		@dsg = cls.dat.dsg;
	}

	void inputCallback(InputDialog@ dialog, bool accepted) {
		if(accepted) {
			double amt = dialog.getSpinboxInput(0);
			at.scuttleSupports(dsg, round(amt));
		}
	}
};

class CreateSupportDialog : Dialog {
	array<const Design@> designs;
	const Design@ dsg;
	Object@ forObject;

	GuiText@ designLabel;
	GuiListbox@ designList;

	GuiText@ amountLabel;
	GuiSpinbox@ amountBox;

	GuiText@ costLabel;
	GuiText@ costText;

	GuiButton@ accept;
	GuiButton@ cancel;

	CreateSupportDialog(SupportOverlay@ overlay, Object@ obj, const Design@ design = null, int defaultNum = 10) {
		@dsg = design;
		@forObject = obj;
		super(overlay);

		addTitle(locale::ADD_SUPPORTS);
		width = 700;

		int y = 32;

		//Show list of designs
		if(dsg is null) {
			@designLabel = GuiText(bg, recti(12, y, width / 3 - 6, y+22), locale::ORDER_SUPPORT_DESIGN);
			designLabel.font = FT_Bold;
			@designList = GuiListbox(bg, recti(width / 3 + 6, y, width - 12, y+222));
			designList.required = true;
			designList.itemHeight = 40;
			designList.tabIndex = 0;
			designList.style = SS_PlainBox;

			{
				ReadLock lck(playerEmpire.designMutex);
				uint cnt = playerEmpire.designCount;
				designs.reserve(cnt);
				designs.length = 0;
				for(uint i = 0; i < cnt; ++i) {
					const Design@ other = playerEmpire.designs[i];
					if(other.obsolete || other.newest() !is other)
						continue;
					if(other.hasTag(ST_Support) || (obj.canHaveSatellites && other.hasTag(ST_Satellite))) {
						designList.addItem(GuiListText(formatShipName(other), other.icon * other.color));
						designs.insertLast(other);
					}
				}
			}

			y += 232;
			height += 232;
		}

		//Show spinbox
		@amountLabel = GuiText(bg, recti(12, y, width / 3 - 6, y+22), locale::ORDER_SUPPORT_AMOUNT);
		amountLabel.font = FT_Bold;
		@amountBox = GuiSpinbox(bg, recti(width / 3 + 6, y, width - 12, y+22), double(defaultNum));
		amountBox.tabIndex = 1;
		amountBox.min = 0;
		amountBox.decimals = 0;
		amountBox.step = 10.0;

		y += 32;
		height += 28;

		//Show cost
		@costLabel = GuiText(bg, recti(12, y, width / 3 - 6, y+22), locale::ORDER_SUPPORT_COST);
		costLabel.font = FT_Bold;
		@costText = GuiText(bg, recti(width / 3 + 6, y, width - 12, y+22));
		costText.font = FT_Medium;

		height += 32;

		@accept = GuiButton(bg, recti());
		accept.text = locale::BUILD;
		accept.tabIndex = 2;
		@accept.callback = this;

		@cancel = GuiButton(bg, recti());
		cancel.text = locale::CANCEL;
		cancel.tabIndex = 3;
		@cancel.callback = this;

		alignAcceptButtons(accept, cancel);
		updateCost();
	}

	const Design@ get_currentDesign() {
		if(dsg is null && designList.selected != -1)
			return designs[designList.selected];
		return dsg;
	}

	void updateCost() {
		const Design@ cur = currentDesign;
		if(cur !is null) {
			double canBuild = double(forObject.SupplyAvailable) / cur.size;
			canBuild += forObject.getGhostCount(cur);
			amountBox.maximum = floor(canBuild);

			int build = 0, maintain = 0;
			double time = 0.0;
			getBuildCost(cur, build, maintain, time, amountBox.value);

			costText.text = formatMoney(build)+" / "+formatMoney(maintain);
			if(playerEmpire.RemainingBudget >= build) {
				costText.color = Color(0xffffffff);
				accept.disabled = false;
			}
			else if(playerEmpire.canPay(build)) {
				costText.color = Color(0xfdff00ff);
				accept.disabled = false;
			}
			else {
				costText.color = Color(0xff0000ff);
				accept.disabled = true;
			}
		}
		else
			costText.text = "";
	}

	void close() {
		close(false);
	}

	void close(bool accepted) {
		if(accepted) {
			@dsg = currentDesign;
			int amount = ceil(amountBox.value);
			if(dsg !is null && amount > 0)
				forObject.orderSupports(dsg, amount);
		}
		Dialog::close();
	}

	void confirmDialog() {
		close(true);
	}

	bool onGuiEvent(const GuiEvent& event) {
		if(Closed)
			return false;
		if(event.type == GUI_Clicked && (event.caller is accept || event.caller is cancel)) {
			close(event.caller is accept);
			return true;
		}
		else if(event.type == GUI_Changed && (event.caller is amountBox || event.caller is designList)) {
			updateCost();
			return true;
		}
		else if(event.type == GUI_Confirmed) {
			close(true);
			return true;
		}
		return Dialog::onGuiEvent(event);
	}
};