/*
 * opsu! - an open-source osu! client
 * Copyright (C) 2014, 2015 Jeffrey Han
 *
 * opsu! is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * opsu! is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with opsu!.  If not, see <http://www.gnu.org/licenses/>.
 */

package itdelatrisu.opsu.states;

import itdelatrisu.opsu.GameImage;
import itdelatrisu.opsu.Utils;
import itdelatrisu.opsu.audio.MusicController;
import itdelatrisu.opsu.audio.SoundController;
import itdelatrisu.opsu.audio.SoundEffect;
import itdelatrisu.opsu.beatmap.Beatmap;
import itdelatrisu.opsu.beatmap.BeatmapSetList;
import itdelatrisu.opsu.beatmap.BeatmapSetNode;
import itdelatrisu.opsu.downloads.Updater;
import itdelatrisu.opsu.states.ButtonMenu.MenuState;
import itdelatrisu.opsu.ui.*;
import itdelatrisu.opsu.ui.MenuButton.Expand;
import itdelatrisu.opsu.ui.animations.AnimatedValue;
import itdelatrisu.opsu.ui.animations.AnimationEquation;

import java.awt.Desktop;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;

import org.lwjgl.opengl.Display;
import org.newdawn.slick.Color;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.util.Log;
import yugecin.opsudance.core.Constants;
import yugecin.opsudance.core.Entrypoint;
import yugecin.opsudance.core.state.BaseOpsuState;
import yugecin.opsudance.core.state.OpsuState;

import static itdelatrisu.opsu.GameImage.*;
import static itdelatrisu.opsu.ui.Colors.*;
import static itdelatrisu.opsu.ui.animations.AnimationEquation.*;
import static java.awt.Desktop.Action.*;
import static org.lwjgl.input.Keyboard.*;
import static yugecin.opsudance.core.InstanceContainer.*;
import static yugecin.opsudance.options.Options.*;

/**
 * "Main Menu" state.
 * <p>
 * Players are able to enter the song menu or downloads menu from this state.
 */
public class MainMenu extends BaseOpsuState {

	/** Idle time, in milliseconds, before returning the logo to its original position. */
	private static final short LOGO_IDLE_DELAY = 6000;

	/** Max alpha level of the menu background. */
	private static final float BG_MAX_ALPHA = 0.9f;
	
	private float barHeight;

	/** Logo button that reveals other buttons on click. */
	private MenuButton logo;

	/** Logo states. */
	private enum LogoState { DEFAULT, OPENING, OPEN, CLOSING }

	/** Current logo state. */
	private LogoState logoState = LogoState.DEFAULT;

	/** Delay timer, in milliseconds, before starting to move the logo back to the center. */
	private int logoTimer = 0;

	/** Logo horizontal offset for opening and closing actions. */
	private AnimatedValue logoPosition;
	private float logoPositionOffsetX;
	
	private int lastMouseX;
	private int lastMouseY;

	/** Logo button alpha levels. */
	private AnimatedValue logoButtonAlpha;
	
	/** Now playing position vlaue. */
	private final AnimatedValue nowPlayingPosition;

	/** Main "Play" and "Exit" buttons. */
	private MenuButton playButton, exitButton;

	/** Music control buttons. */
	private MenuButton musicPlay, musicPause, musicStop, musicNext, musicPrev;
	private MenuButton[] musicButtons = new MenuButton[5];

	/** Button linking to Downloads menu. */
	private MenuButton downloadsButton;

	/** Button linking to repository. */
	private MenuButton repoButton;

	/** Button linking to dance repository. */
	private MenuButton danceRepoButton;

	/** Buttons for installing updates. */
	private MenuButton updateButton, restartButton;

	private int textMarginX;
	private int textTopMarginY;
	private int textLineHeight;

	/** Indexes of previous songs. */
	private Stack<Integer> previous;

	/** Background alpha level (for fade-in effect). */
	private AnimatedValue bgAlpha = new AnimatedValue(1100, 0f, BG_MAX_ALPHA, AnimationEquation.LINEAR);

	/** Whether or not a notification was already sent upon entering. */
	private boolean enterNotification = false;

	/** Music position bar coordinates and dimensions. */
	private int musicBarX, musicBarY, musicBarWidth, musicBarHeight;

	/** Last measure progress value. */
	private float lastMeasureProgress = 0f;

	/** The star fountain. */
	private StarFountain starFountain;
	
	/** Time format used to show running time. */
	private final SimpleDateFormat timeFormat;
	
	private LinkedList<PulseData> pulseData = new LinkedList<>();
	private float lastPulseProgress;
	
	public MainMenu() {
		this.nowPlayingPosition = new AnimatedValue(1000, 0, 0, OUT_QUART);
		this.timeFormat = new SimpleDateFormat("HH:mm");
	}

	@Override
	protected void revalidate() {
		previous = new Stack<>();

		final int width = displayContainer.width;
		final int height = displayContainer.height;

		this.barHeight = height * 0.1125f;

		this.textMarginX = (int) (width * 0.015f);
		this.textTopMarginY = (int) (height * 0.01f);
		this.textLineHeight = (int) (Fonts.MEDIUM.getLineHeight() * 0.925f);

		// initialize menu buttons
		Image logoImg = GameImage.MENU_LOGO.getImage();
		Image playImg = GameImage.MENU_PLAY.getImage();
		Image exitImg = GameImage.MENU_EXIT.getImage();
		float exitOffset = (playImg.getWidth() - exitImg.getWidth()) / 3f;
		logo = new MenuButton(logoImg, displayContainer.width / 2f, displayContainer.height / 2f);
		playButton = new MenuButton(playImg,
				displayContainer.width * 0.75f, (displayContainer.height / 2) - (logoImg.getHeight() / 5f)
		);
		exitButton = new MenuButton(exitImg,
				displayContainer.width * 0.75f - exitOffset, (displayContainer.height / 2) + (exitImg.getHeight() / 2f)
		);
		final int logoAnimationDuration = 350;
		logo.setHoverAnimationDuration(logoAnimationDuration);
		playButton.setHoverAnimationDuration(logoAnimationDuration);
		exitButton.setHoverAnimationDuration(logoAnimationDuration);
		final AnimationEquation logoAnimationEquation = AnimationEquation.IN_OUT_EXPO;
		logo.setHoverAnimationEquation(logoAnimationEquation);
		playButton.setHoverAnimationEquation(logoAnimationEquation);
		exitButton.setHoverAnimationEquation(logoAnimationEquation);
		final float logoHoverScale = 1.096f;
		logo.setHoverExpand(logoHoverScale);
		playButton.setHoverExpand(logoHoverScale);
		exitButton.setHoverExpand(logoHoverScale);

		// initialize music buttons
		final int musicSize = (int) (this.textLineHeight * 0.8f);
		final float musicScale = (float) musicSize / MUSIC_STOP.getImage().getWidth();
		final int musicSpacing = (int) (musicSize * 0.8f) + musicSize; // (center to center)
		int x = width - this.textMarginX - musicSize / 2;
		int y = this.textLineHeight * 2 + this.textLineHeight / 2;
		this.musicNext = new MenuButton(MUSIC_NEXT.getScaledImage(musicScale), x, y);
		x -= musicSpacing;
		this.musicStop = new MenuButton(MUSIC_STOP.getScaledImage(musicScale), x, y);
		x -= musicSpacing;
		this.musicPause = new MenuButton(MUSIC_PAUSE.getScaledImage(musicScale), x, y);
		x -= musicSpacing;
		this.musicPlay = new MenuButton(MUSIC_PLAY.getScaledImage(musicScale), x, y);
		x -= musicSpacing;
		this.musicPrev = new MenuButton(MUSIC_PREVIOUS.getScaledImage(musicScale), x, y);
		this.musicButtons[0] = this.musicPrev;
		this.musicButtons[1] = this.musicPlay;
		this.musicButtons[2] = this.musicPause;
		this.musicButtons[3] = this.musicStop;
		this.musicButtons[4] = this.musicNext;
		for (MenuButton b : this.musicButtons) {
			b.setHoverExpand(1.15f);
		}

		// initialize music position bar location
		this.musicBarX = x - musicSize / 2;
		this.musicBarY = y + musicSize;
		this.musicBarWidth = musicSize + musicSpacing * 4;
		this.musicBarHeight = (int) (musicSize * 0.3f);

		// initialize downloads button
		Image dlImg = GameImage.DOWNLOADS.getImage();
		downloadsButton = new MenuButton(dlImg, displayContainer.width - dlImg.getWidth() / 2f, displayContainer.height / 2f);
		downloadsButton.setHoverAnimationDuration(350);
		downloadsButton.setHoverAnimationEquation(AnimationEquation.IN_OUT_BACK);
		downloadsButton.setHoverExpand(1.03f, Expand.LEFT);

		// initialize repository button (only if a webpage can be opened)
		if (Desktop.isDesktopSupported() && Desktop.getDesktop().isSupported(BROWSE)) {
			final Image repoImg = GameImage.REPOSITORY.getImage();
			float repoX = this.textMarginX + repoImg.getWidth() / 2;
			final float repoY = height - this.barHeight / 2;
			repoButton = new MenuButton(repoImg, repoX, repoY);
			repoButton.setHoverAnimationDuration(100);
			repoButton.setHoverExpand(1.1f);
			repoX += repoImg.getWidth() * 1.5f;
			danceRepoButton = new MenuButton(repoImg, repoX, repoY);
			danceRepoButton.setHoverAnimationDuration(100);
			danceRepoButton.setHoverExpand(1.1f);
		}

		// initialize update buttons
		float updateX = displayContainer.width / 2f, updateY = displayContainer.height * 17 / 18f;
		Image downloadImg = GameImage.DOWNLOAD.getImage();
		updateButton = new MenuButton(downloadImg, updateX, updateY);
		updateButton.setHoverAnimationDuration(400);
		updateButton.setHoverAnimationEquation(AnimationEquation.IN_OUT_QUAD);
		updateButton.setHoverExpand(1.1f);
		Image updateImg = GameImage.UPDATE.getImage();
		restartButton = new MenuButton(updateImg, updateX, updateY);
		restartButton.setHoverAnimationDuration(2000);
		restartButton.setHoverAnimationEquation(AnimationEquation.LINEAR);
		restartButton.setHoverRotate(360);

		// initialize star fountain
		starFountain = new StarFountain(displayContainer.width, displayContainer.height);

		// logo animations
		logoPositionOffsetX = 0.4f * MENU_LOGO.getImage().getHeight();
		logoPosition = new AnimatedValue(1, 0, 1, AnimationEquation.OUT_QUAD);
		logoButtonAlpha = new AnimatedValue(200, 0f, 1f, AnimationEquation.LINEAR);
	}

	@Override
	public void render(Graphics g) {
		int width = displayContainer.width;
		int height = displayContainer.height;

		// draw background
		Beatmap beatmap = MusicController.getBeatmap();
		if (OPTION_DYNAMIC_BACKGROUND.state &&
			beatmap != null && beatmap.drawBackground(width, height, bgAlpha.getValue(), true))
			;
		else {
			Image bg = GameImage.MENU_BG.getImage();
			bg.setAlpha(bgAlpha.getValue());
			bg.draw();
		}

		// top/bottom horizontal bars
		float oldAlpha = Colors.BLACK_ALPHA.a;
		Colors.BLACK_ALPHA.a = 0.4f;
		g.setColor(Colors.BLACK_ALPHA);
		g.fillRect(0, 0, width, this.barHeight);
		g.fillRect(0, height - this.barHeight, width, this.barHeight);
		Colors.BLACK_ALPHA.a = oldAlpha;

		// draw star fountain
		starFountain.draw();

		// draw downloads button
		downloadsButton.draw();

		// draw buttons
		if (logoState == LogoState.OPEN || logoState == LogoState.CLOSING) {
			playButton.draw();
			exitButton.draw();
		}

		// draw logo (pulsing)
		Color color = OPTION_COLOR_MAIN_MENU_LOGO.state ? Cursor.lastCursorColor : Color.white;
		for (PulseData pd : this.pulseData) {
			final float progress = OUT_CUBIC.calc(pd.position / 1000f);
			final float scale = pd.initialScale + (0.432f * progress);
			final Image p = GameImage.MENU_LOGO_PULSE.getImage().getScaledCopy(scale);
			p.setAlpha(0.15f * (1f - IN_QUAD.calc(progress)));
			p.drawCentered(logo.getX(), logo.getY(), color);
		}
		Float position = MusicController.getBeatProgress();
		Float beatLength = MusicController.getBeatLength();
		boolean renderPiece = position != null;
		if (position == null) {
			position = System.currentTimeMillis() % 1000 / 1000f;
			beatLength = 1000f;
		}
		final float hoverScale = logo.getCurrentHoverExpandValue();
		if (position < this.lastPulseProgress) {
			this.pulseData.add(new PulseData((int) (position*beatLength), hoverScale));
		}
		this.lastPulseProgress = position;
		final float smoothExpandProgress;
		if (position < 0.05f) {
			smoothExpandProgress = 1f - IN_CUBIC.calc(position / 0.05f);
		} else {
			smoothExpandProgress = (position - 0.05f) / 0.95f;
		}
		logo.draw(color, 0.9726f + smoothExpandProgress * 0.0274f);
		if (renderPiece) {
			Image piece = GameImage.MENU_LOGO_PIECE.getImage();
			piece = piece.getScaledCopy(hoverScale);
			piece.rotate(position * 360);
			piece.drawCentered(logo.getX(), logo.getY(), color);
		}
		final float ghostScale = hoverScale * 1.0186f - smoothExpandProgress * 0.0186f;
		Image ghostLogo = GameImage.MENU_LOGO.getImage().getScaledCopy(ghostScale);
		ghostLogo.setAlpha(0.25f);
		ghostLogo.drawCentered(logo.getX(), logo.getY(), color);
		
		// now playing
		final Image np = GameImage.MUSIC_NOWPLAYING.getImage();
		final String trackText;
		if (beatmap != null) {
			if (OPTION_SHOW_UNICODE.state) {
				Fonts.loadGlyphs(Fonts.MEDIUM, beatmap.titleUnicode);
				Fonts.loadGlyphs(Fonts.MEDIUM, beatmap.artistUnicode);
			}
			trackText = beatmap.getArtist() + ": " + beatmap.getTitle();
		} else {
			trackText = "Loading...";
		}
		final float textWidth = Fonts.MEDIUM.getWidth(trackText);
		final float npheight = Fonts.MEDIUM.getLineHeight() * 1.15f;
		final float npscale = npheight / np.getHeight();
		final float npwidth = np.getWidth() * npscale;
		float totalWidth = textMarginX + textWidth + npwidth;
		if (this.nowPlayingPosition.getMax() != totalWidth) {
			final float current = this.nowPlayingPosition.getValue();
			this.nowPlayingPosition.setValues(current, totalWidth);
		}
		final float npimgx = width - this.nowPlayingPosition.getValue();
		final float npx = npimgx + npwidth;
		MUSIC_NOWPLAYING_BG_BLACK.getImage().draw(npx, 0, width - npx, npheight);
		MUSIC_NOWPLAYING_BG_WHITE.getImage().draw(npimgx, npheight, width - npimgx, 2);
		np.draw(npimgx, 0, npscale);
		Fonts.MEDIUM.drawString(npx, 0, trackText);

		// draw music buttons
		for (MenuButton b : this.musicButtons) {
			b.draw();
		}

		// draw music position bar
		int mouseX = displayContainer.mouseX;
		int mouseY = displayContainer.mouseY;
		g.setColor((musicPositionBarContains(mouseX, mouseY)) ? Colors.BLACK_BG_HOVER : Colors.BLACK_BG_NORMAL);
		g.fillRect(this.musicBarX, this.musicBarY, this.musicBarWidth, this.musicBarHeight);
		g.setColor(Colors.WHITE_ALPHA_75);
		if (!MusicController.isTrackLoading() && beatmap != null) {
			final float trackpos = MusicController.getPosition();
			final float tracklen = MusicController.getDuration();
			final float barwidth = musicBarWidth * Math.min(trackpos / tracklen, 1f);
			g.fillRect(this.musicBarX, this.musicBarY, barwidth, this.musicBarHeight);
		}

		// draw repository buttons
		if (repoButton != null) {
			String text;
			int fheight, fwidth;
			repoButton.draw();
			text = "opsu!";
			fheight = Fonts.SMALL.getLineHeight();
			fwidth = Fonts.SMALL.getWidth(text);
			Fonts.SMALL.drawString(repoButton.getX() - fwidth / 2, repoButton.getY() - repoButton.getImage().getHeight() / 2 - fheight, text, Color.white);
			danceRepoButton.draw();
			text = "opsu!dance";
			fheight = Fonts.SMALL.getLineHeight();
			fwidth = Fonts.SMALL.getWidth(text);
			Fonts.SMALL.drawString(danceRepoButton.getX() - fwidth / 2, repoButton.getY() - repoButton.getImage().getHeight() / 2 - fheight, text, Color.white);
		}

		// draw update button
		if (updater.showButton()) {
			Updater.Status status = updater.getStatus();
			if (status == Updater.Status.UPDATE_AVAILABLE || status == Updater.Status.UPDATE_DOWNLOADING) {
				updateButton.draw();
			} else if (status == Updater.Status.UPDATE_DOWNLOADED) {
				restartButton.draw();
			}
		}

		// draw text
		g.setFont(Fonts.MEDIUM);
		g.setColor(Color.white);
		String txt = String.format(
			"You have %d beatmaps (%d songs) available!",
			BeatmapSetList.get().getMapCount(),
			BeatmapSetList.get().getMapSetCount()
		);
		g.drawString(txt, textMarginX, textTopMarginY);
		txt = String.format(
			"%s has been running for %s.",
			Constants.PROJECT_NAME,
			Utils.getTimeString((int) (Entrypoint.runtime() / 1000L))
		);
		g.drawString(txt, textMarginX, textTopMarginY + textLineHeight);
		txt = String.format(
			"It is currently %s.",
			this.timeFormat.format(new Date())
		);
		g.drawString(txt, textMarginX, textTopMarginY + textLineHeight * 2);

		UI.draw(g);
	}

	@Override
	public void preRenderUpdate() {
		int delta = displayContainer.renderDelta;
		
		final Iterator<PulseData> pulseDataIter = this.pulseData.iterator();
		while (pulseDataIter.hasNext()) {
			final PulseData pd = pulseDataIter.next();
			pd.position += delta;
			if (pd.position > 1000) {
				pulseDataIter.remove();
			}
		}

		UI.update(delta);
		if (MusicController.trackEnded())
			nextTrack(false);  // end of track: go to next track
		int mouseX = displayContainer.mouseX;
		int mouseY = displayContainer.mouseY;
		logo.hoverUpdate(delta, mouseX, mouseY, 0.25f);
		playButton.hoverUpdate(delta, mouseX, mouseY, 0.25f);
		exitButton.hoverUpdate(delta, mouseX, mouseY, 0.25f);
		if (repoButton != null) {
			repoButton.hoverUpdate(delta, mouseX, mouseY);
			danceRepoButton.hoverUpdate(delta, mouseX, mouseY);
		}
		if (updater.showButton()) {
			updateButton.autoHoverUpdate(delta, true);
			restartButton.autoHoverUpdate(delta, false);
		}
		downloadsButton.hoverUpdate(delta, mouseX, mouseY);
		for (MenuButton b : this.musicButtons) {
			b.hoverUpdate(delta, b.contains(mouseX, mouseY));
		}
		starFountain.update(delta);

		// window focus change: increase/decrease theme song volume
		if (MusicController.isThemePlaying() &&
		    MusicController.isTrackDimmed() == Display.isActive())
				MusicController.toggleTrackDimmed(0.33f);

		// fade in background
		Beatmap beatmap = MusicController.getBeatmap();
		if (!(OPTION_DYNAMIC_BACKGROUND.state && beatmap != null && beatmap.isBackgroundLoading()))
			bgAlpha.update(delta);

		// check measure progress
		Float measureProgress = MusicController.getMeasureProgress(2);
		if (measureProgress != null) {
			if (measureProgress < lastMeasureProgress)
				starFountain.burst(true);
			lastMeasureProgress = measureProgress;
		}

		// buttons
		int centerX = displayContainer.width / 2;
		float currentLogoButtonAlpha;
		switch (logoState) {
		case DEFAULT:
			break;
		case OPENING:
			if (logoPosition.update(delta))  // shifting to left
				logo.setX(centerX - logoPosition.getValue());
			else {
				logoState = LogoState.OPEN;
				logoTimer = 0;
				logoButtonAlpha.setTime(0);
			}
			break;
		case OPEN:
			if (logoButtonAlpha.update(delta)) {  // fade in buttons
				currentLogoButtonAlpha = logoButtonAlpha.getValue();
				playButton.getImage().setAlpha(currentLogoButtonAlpha);
				exitButton.getImage().setAlpha(currentLogoButtonAlpha);
			}
			if (this.lastMouseX != mouseX || this.lastMouseY != mouseY) {
				this.logoTimer = 0;
				this.lastMouseX = mouseX;
				this.lastMouseY = mouseY;
			} else {
				this.logoTimer += delta;
				if (this.logoTimer >= LOGO_IDLE_DELAY) {
					this.closeLogo();
				}
			}
			break;
		case CLOSING:
			if (logoButtonAlpha.update(-delta)) {  // fade out buttons
				currentLogoButtonAlpha = logoButtonAlpha.getValue();
				playButton.getImage().setAlpha(currentLogoButtonAlpha);
				exitButton.getImage().setAlpha(currentLogoButtonAlpha);
			}
			if (logoPosition.update(-delta))  // shifting to right
				logo.setX(centerX - logoPosition.getValue());
			break;
		}

		// tooltips
		if (musicPositionBarContains(mouseX, mouseY))
			UI.updateTooltip(delta, "Click to seek to a specific point in the song.", false);
		else if (musicPrev.contains(mouseX, mouseY))
			UI.updateTooltip(delta, "Previous track", false);
		else if (musicPlay.contains(mouseX, mouseY))
			UI.updateTooltip(delta, "Play", false);
		else if (musicPause.contains(mouseX, mouseY))
			UI.updateTooltip(delta, "Pause", false);
		else if (musicStop.contains(mouseX, mouseY))
			UI.updateTooltip(delta, "Stop", false);
		else if (musicNext.contains(mouseX, mouseY))
			UI.updateTooltip(delta, "Next track", false);
		else if (updater.showButton()) {
			Updater.Status status = updater.getStatus();
			if (((status == Updater.Status.UPDATE_AVAILABLE || status == Updater.Status.UPDATE_DOWNLOADING) && updateButton.contains(mouseX, mouseY)) ||
			    (status == Updater.Status.UPDATE_DOWNLOADED && restartButton.contains(mouseX, mouseY)))
				UI.updateTooltip(delta, status.getDescription(), true);
		}
		
		nowPlayingPosition.update(delta);
	}

	@Override
	public void enter() {
		super.enter();

		logo.setX(displayContainer.width / 2);
		logoPosition.setTime(0);
		logoButtonAlpha.setTime(0);
		nowPlayingPosition.setTime(0);
		logoState = LogoState.DEFAULT;

		UI.enter();
		if (!enterNotification) {
			if (updater.getStatus() == Updater.Status.UPDATE_AVAILABLE) {
				barNotifs.send("An opsu! update is available.");
			} else if (updater.justUpdated()) {
				barNotifs.send("opsu! is now up to date!");
			}
			enterNotification = true;
		}

		// reset measure info
		lastMeasureProgress = 0f;
		starFountain.clear();

		// reset button hover states if mouse is not currently hovering over the button
		int mouseX = displayContainer.mouseX;
		int mouseY = displayContainer.mouseY;
		if (!logo.contains(mouseX, mouseY, 0.25f))
			logo.resetHover();
		if (!playButton.contains(mouseX, mouseY, 0.25f))
			playButton.resetHover();
		if (!exitButton.contains(mouseX, mouseY, 0.25f))
			exitButton.resetHover();
		for (MenuButton b : this.musicButtons) {
			if (!b.contains(mouseX, mouseY)) {
				b.resetHover();
			}
		}
		if (repoButton != null && !repoButton.contains(mouseX, mouseY))
			repoButton.resetHover();
		if (danceRepoButton != null && !danceRepoButton.contains(mouseX, mouseY))
			danceRepoButton.resetHover();
		updateButton.resetHover();
		restartButton.resetHover();
		if (!downloadsButton.contains(mouseX, mouseY))
			downloadsButton.resetHover();
	}

	@Override
	public void leave() {
		super.leave();
		if (MusicController.isTrackDimmed())
			MusicController.toggleTrackDimmed(1f);
	}

	@Override
	public boolean mousePressed(int button, int x, int y) {
		// check mouse button
		if (button == Input.MOUSE_MIDDLE_BUTTON)
			return false;

		// music position bar
		if (MusicController.isPlaying() && musicPositionBarContains(x, y)) {
			this.lastMeasureProgress = 0f;
			float pos = (float) (x - this.musicBarX) / this.musicBarWidth;
			MusicController.setPosition((int) (pos * MusicController.getDuration()));
			return true;
		}

		// music button actions
		if (musicPrev.contains(x, y)) {
			lastMeasureProgress = 0f;
			if (!previous.isEmpty()) {
				songMenuState.setFocus(BeatmapSetList.get().getBaseNode(previous.pop()), -1, true, false);
				if (OPTION_DYNAMIC_BACKGROUND.state) {
					bgAlpha.setTime(0);
				}
			} else {
				MusicController.setPosition(0);
			}
			barNotifs.send("<< Previous");
			return true;
		} else if (musicPlay.contains(x, y)) {
			if (MusicController.isPlaying()) {
				lastMeasureProgress = 0f;
				MusicController.setPosition(0);
			} else if (!MusicController.isTrackLoading()) {
				MusicController.resume();
			}
			barNotifs.send("Play");
			return true;
		} else if (musicPause.contains(x, y)) {
			if (MusicController.isPlaying()) {
				MusicController.pause();
				barNotifs.send("Pause");
			} else if (!MusicController.isTrackLoading()) {
				MusicController.resume();
				barNotifs.send("Unpause");
			}
		} else if (musicStop.contains(x, y)) {
			if (MusicController.isPlaying()) {
				MusicController.setPosition(0);
				MusicController.pause();
			}
			barNotifs.send("Stop Playing");
		} else if (musicNext.contains(x, y)) {
			nextTrack(true);
			barNotifs.send(">> Next");
			return true;
		}

		// downloads button actions
		if (downloadsButton.contains(x, y)) {
			SoundController.playSound(SoundEffect.MENUHIT);
			displayContainer.switchState(downloadState);
			return true;
		}

		// repository button actions
		if (repoButton != null && repoButton.contains(x, y)) {
			try {
				Desktop.getDesktop().browse(Constants.REPOSITORY_URI);
			} catch (UnsupportedOperationException e) {
				barNotifs.send("The repository web page could not be opened.");
			} catch (IOException e) {
				Log.error("could not browse to repo", e);
				bubNotifs.send(BUB_ORANGE, "Could not browse to repo");
			}
			return true;
		}

		if (danceRepoButton != null && danceRepoButton.contains(x, y)) {
			try {
				Desktop.getDesktop().browse(Constants.DANCE_REPOSITORY_URI);
			} catch (UnsupportedOperationException e) {
				barNotifs.send("The repository web page could not be opened.");
			} catch (IOException e) {
				Log.error("could not browse to repo", e);
				bubNotifs.send(BUB_ORANGE, "Could not browse to repo");
			}
			return true;
		}

		// update button actions
		if (updater.showButton()) {
			Updater.Status status = updater.getStatus();
			if (updateButton.contains(x, y) && status == Updater.Status.UPDATE_AVAILABLE) {
				SoundController.playSound(SoundEffect.MENUHIT);
				updater.startDownload();
				updateButton.removeHoverEffects();
				updateButton.setHoverAnimationDuration(800);
				updateButton.setHoverAnimationEquation(AnimationEquation.IN_OUT_QUAD);
				updateButton.setHoverFade(0.6f);
				return true;
			} else if (restartButton.contains(x, y) && status == Updater.Status.UPDATE_DOWNLOADED) {
				SoundController.playSound(SoundEffect.MENUHIT);
				updater.prepareUpdate();
				displayContainer.exitRequested = true;
				return true;
			}
		}

		// start moving logo (if clicked)
		if (logoState == LogoState.DEFAULT || logoState == LogoState.CLOSING) {
			if (logo.contains(x, y, 0.25f)) {
				this.openLogo();
				SoundController.playSound(SoundEffect.MENUHIT);
				return true;
			}
		}

		// other button actions (if visible)
		else if (logoState == LogoState.OPEN || logoState == LogoState.OPENING) {
			if (logo.contains(x, y, 0.25f) || playButton.contains(x, y, 0.25f)) {
				SoundController.playSound(SoundEffect.MENUHIT);
				enterSongMenu();
				return true;
			} else if (exitButton.contains(x, y, 0.25f)) {
				displayContainer.exitRequested = true;
				return true;
			}
		}
		return false;
	}

	@Override
	public boolean mouseWheelMoved(int newValue) {
		if (super.mouseWheelMoved(newValue)) {
			return true;
		}

		UI.changeVolume((newValue < 0) ? -1 : 1);
		return true;
	}

	@Override
	public boolean keyPressed(int key, char c) {
		if (super.keyPressed(key, c)) {
			return true;
		}

		switch (key) {
		case KEY_ESCAPE:
		case KEY_Q:
			if (logoState == LogoState.OPEN || logoState == LogoState.OPENING) {
				this.closeLogo();
				break;
			}
			buttonState.setMenuState(MenuState.EXIT);
			displayContainer.switchState(buttonState);
			return true;
		case KEY_P:
			SoundController.playSound(SoundEffect.MENUHIT);
			if (logoState == LogoState.DEFAULT || logoState == LogoState.CLOSING) {
				this.openLogo();
			} else {
				enterSongMenu();
			}
			return true;
		case KEY_D:
			SoundController.playSound(SoundEffect.MENUHIT);
			displayContainer.switchState(downloadState);
			return true;
		case KEY_R:
			nextTrack(true);
			return true;
		case KEY_UP:
			UI.changeVolume(1);
			return true;
		case KEY_DOWN:
			UI.changeVolume(-1);
			return true;
		}
		return false;
	}

	/**
	 * Returns true if the coordinates are within the music position bar bounds.
	 * @param cx the x coordinate
	 * @param cy the y coordinate
	 */
	private boolean musicPositionBarContains(float cx, float cy) {
		return ((cx > musicBarX && cx < musicBarX + musicBarWidth) &&
		        (cy > musicBarY && cy < musicBarY + musicBarHeight));
	}

	/**
	 * Plays the next track, and adds the previous one to the stack.
	 * @param user {@code true} if this was user-initiated, false otherwise (track end)
	 */
	private void nextTrack(boolean user) {
		lastMeasureProgress = 0f;
		boolean isTheme = MusicController.isThemePlaying();
		if (isTheme && !user) {
			// theme was playing, restart
			// NOTE: not looping due to inaccurate track positions after loop
			MusicController.playAt(0, false);
			return;
		}
		BeatmapSetNode node = songMenuState.setFocus(BeatmapSetList.get().getRandomNode(), -1, true, false);
		boolean sameAudio = false;
		if (node != null) {
			sameAudio = MusicController.getBeatmap().audioFilename.equals(node.getBeatmapSet().get(0).audioFilename);
			if (!isTheme && !sameAudio)
				previous.add(node.index);
		}
		if (OPTION_DYNAMIC_BACKGROUND.state && !sameAudio && !MusicController.isThemePlaying()) {
			bgAlpha.setTime(0);
		}
	}

	/**
	 * Enters the song menu, or the downloads menu if no beatmaps are loaded.
	 */
	private void enterSongMenu() {
		OpsuState state = songMenuState;
		if (BeatmapSetList.get().getMapSetCount() == 0) {
			downloadState.notifyOnLoad("Download some beatmaps to get started!");
			state = downloadState;
		}
		displayContainer.switchState(state);
	}
	
	private void openLogo() {
		logoPosition.change(300, 0, logoPositionOffsetX, OUT_CUBIC);
		logoState = LogoState.OPENING;
		playButton.getImage().setAlpha(0f);
		exitButton.getImage().setAlpha(0f);
	}
	
	private void closeLogo() {
		logoPosition.change(1800, 0, logoPositionOffsetX, IN_QUAD);
		logoState = LogoState.CLOSING;
	}
	
	private static class PulseData {
		private int position;
		private float initialScale;

		private PulseData(int position, float initialScale) {
			this.position = position;
			this.initialScale = initialScale;
		}
	}
}