#include "GSPlayer2.h"
#include "PpcMainWnd.h"
#include "PpcOptions.h"
#include "PpcSkin.h"
#include "PpcDisplay.h"

extern const TCHAR s_szSupportedExt[][5];

static const UINT s_uHoldKeys[][2] = {
	{VK_RETURN, 0}, {VK_LEFT, 0},
	{VK_UP, 0}, {VK_RIGHT, 0}, {VK_DOWN, 0},
	{VK_BTN1, MOD_WIN}, {VK_BTN2, MOD_WIN},
	{VK_BTN3, MOD_WIN}, {VK_BTN4, MOD_WIN},
	{VK_BTN5, MOD_WIN}, {VK_BTN6, MOD_WIN}, 
};

CPpcMainWnd::CPpcMainWnd()
{
	m_fMenuLoop = FALSE;
	m_fActive = FALSE;
	m_fHotKey = FALSE;
	m_dwLastOperation = 0;
	m_fDisplay = GetDisplayStatus();

	m_hwndCB = NULL;
	m_hwndLV = NULL;
	m_fListDrag = FALSE;
	m_fHold = FALSE;
	m_fNoListRedraw = FALSE;

	InitSize();
}

CPpcMainWnd::~CPpcMainWnd()
{
}

COptions* CPpcMainWnd::GetOptionsClass()
{
	return new CPpcOptions();
}

CSkin* CPpcMainWnd::GetSkinClass()
{
	return new CPpcSkin();
}

HACCEL CPpcMainWnd::GetAccelHandle()
{
	if (!m_hAccel) {
		ACCEL accel[] = {
			{FVIRTKEY | FCONTROL, 'Z', IDM_PLAY_PLAYPAUSE},		// Play/Pause
			{FVIRTKEY | FCONTROL, 'X', IDM_PLAY_STOP},				// Stop
			{FVIRTKEY | FCONTROL, 'C', IDM_PLAY_PREV},				// Prev
			{FVIRTKEY | FCONTROL, 'V', IDM_PLAY_REW},				// Rew
			{FVIRTKEY | FCONTROL, 'B', IDM_PLAY_FF},				// FF
			{FVIRTKEY | FCONTROL, 'N', IDM_PLAY_NEXT},				// Next
			{FVIRTKEY | FCONTROL, 'R', IDM_PLAY_REPEAT},			// Repeat
			{FVIRTKEY | FCONTROL, 'H', IDM_PLAY_SHUFFLE},			// Shuffle
			{FVIRTKEY | FCONTROL, 'O', IDM_FILE_OPEN},				// Open
			{FVIRTKEY | FCONTROL, 'U', IDM_FILE_OPEN_LOCATION},	// Open Location
			{FVIRTKEY | FCONTROL, 'A', IDM_FILE_ADD},				// Add
			{FVIRTKEY | FCONTROL, 'F', IDM_FILE_FIND},				// Find
			{FVIRTKEY | FCONTROL, 'L', IDM_FILE_LIST},				// List
			{FVIRTKEY | FCONTROL, 'S', IDM_FILE_SAVE_LIST},		// Save List
			{FVIRTKEY | FCONTROL, 'E', IDM_TOOL_EFFECT},			// Effect
			{FVIRTKEY | FCONTROL, 'Y', IDM_TOOL_VOLUP},			// Volume Up
			{FVIRTKEY | FCONTROL, 'T', IDM_TOOL_VOLDOWN},		// Volume Down
			{FVIRTKEY | FCONTROL, 'Q', IDM_APP_EXIT},	// Exit
		};
		m_hAccel = CreateAcceleratorTable(accel, sizeof(accel) / sizeof(ACCEL));
	}
	return m_hAccel;
}

BOOL CPpcMainWnd::CanTransAccel(MSG* pMsg)
{
	return pMsg->hwnd == m_hWnd || pMsg->hwnd == m_hwndLV;
}

void CPpcMainWnd::RegisterClass()
{
	WNDCLASS	wc;
	memset(&wc, 0, sizeof(WNDCLASS));
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wc.lpfnWndProc = (WNDPROC)PpcMainWndProc;
    wc.hInstance = GetInst();
    wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
    wc.lpszClassName = MAINWND_CLASS_NAME;
	::RegisterClass(&wc);
}

LRESULT CALLBACK CPpcMainWnd::PpcMainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	static CPpcMainWnd* pMainWnd = NULL;

	if (pMainWnd &&
		uMsg != WM_TIMER && uMsg != WM_PAINT && uMsg != WM_GETTEXT &&
		uMsg != WM_ERASEBKGND && uMsg < MAP_MSG_BASE) {
		pMainWnd->m_dwLastOperation = GetTickCount();
	}

	switch (uMsg) {
	case WM_CREATE:
		CREATESTRUCT* pcs;
		pcs = (CREATESTRUCT*)lParam;
		pMainWnd = (CPpcMainWnd*)pcs->lpCreateParams;
		return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
	case WM_INITMENUPOPUP:
		pMainWnd->OnInitMenuPopup((HMENU)wParam, LOWORD(lParam), HIWORD(lParam));
		return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
	case WM_NOTIFY:
		{
			NMHDR* pnmh = (NMHDR*)lParam;
			switch (pnmh->code) {
			case NM_RETURN:
				pMainWnd->OnListViewReturn(pnmh);
				return 0;
			case LVN_KEYDOWN:
				pMainWnd->OnListViewKeyDown(pnmh);
				return 0;
			case NM_DBLCLK:
				pMainWnd->OnListViewDblClk(pnmh);
				return 0;
			case LVN_BEGINDRAG:
				pMainWnd->OnListViewBeginDrag(pnmh);
				return 0;
			case GN_CONTEXTMENU:
				pMainWnd->OnListViewConextMenu(pnmh);
				return 0;
			default:
				return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
			}
		}
	case WM_SETTINGCHANGE:
		SHHandleWMSettingChange(hwnd, wParam, lParam, &pMainWnd->m_sai);
		return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
	case WM_ENTERMENULOOP:
		pMainWnd->m_fMenuLoop = TRUE;
		return 0;
	case WM_EXITMENULOOP:
		pMainWnd->m_fMenuLoop = FALSE;
		return 0;
	}
	return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
}

BOOL CPpcMainWnd::Create(LPTSTR pszCmdLine, HWND hwndParent, DWORD dwStyle)
{
	CWaitCursor wc;

	// 僋儔僗偺搊榐
	RegisterClass();

	// 僂僀儞僪僂嶌惉
	CreateWindow(MAINWND_CLASS_NAME, MAINWND_TITLE, WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 
		PPC_MAINWND_WIDTH, PPC_MAINWND_HEIGHT, NULL, NULL, GetInst(), this);


	if (!m_hWnd)
		return FALSE;

	ShowWindow(m_hWnd, SW_SHOW);
	UpdateWindow(m_hWnd);

	if (_tcslen(pszCmdLine)) {
		SendCmdLine(m_hWnd, pszCmdLine);
	}
	else {
		// 僨僼僅儖僩儕僗僩偺撉傒崬傒
		if (((CPpcOptions*)m_pOptions)->m_fSaveDefList) {
			m_nCurrent = 0;	// 奐偐側(cè)偄傛?zhèn)蓚穫?
			// 撉傒崬傒
			m_fNoListRedraw = TRUE;
			SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
			TCHAR szPath[MAX_PATH];
			GetDefPlayListPath(szPath);
			LoadPlayList(szPath);
			SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
			m_fNoListRedraw = FALSE;
			InvalidateRect(m_hwndLV, 0, FALSE);
			UpdateWindow(m_hwndLV);

			m_nCurrent = OPEN_NONE;

			// 儗僕儏乕儉忣曬傪斀塮偡傞
			if (((CPpcOptions*)m_pOptions)->m_fResume && 
				((CPpcOptions*)m_pOptions)->m_nResumeTrack != -1 &&
				((CPpcOptions*)m_pOptions)->m_nResumeTrack < m_pListFile->GetCount()) {
				Open(((CPpcOptions*)m_pOptions)->m_nResumeTrack);
				if (m_nCurrent == OPEN_NONE)
					OpenFirstFile();
				else {
					MAP_Seek(m_hMap, ((CPpcOptions*)m_pOptions)->m_nResumeTime);
					((CPpcOptions*)m_pOptions)->m_nResumeTime = 0;
				}
			}
			else
				OpenFirstFile();
			if (((CPpcOptions*)m_pOptions)->m_fPlayOnStart)
				Play();
		}
	}

	return TRUE;
}

BOOL CPpcMainWnd::InitImages()
{
	InitSize();
	BOOL fRet = CMainWnd::InitImages();
	if (fRet) {
		ShowWindow(m_hwndLV, ((CPpcSkin*)m_pSkin)->IsPlaylistVisible() ? SW_SHOW : SW_HIDE);
		ListView_SetBkColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTBACK));
		ListView_SetTextBkColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTBACK));
		ListView_SetTextColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTTEXT));

		m_hFntTitle = (HFONT)SendMessage(m_hWnd, WM_GETFONT, 0, 0);

		InvalidateRect(m_hwndLV, NULL, TRUE);
		UpdateWindow(m_hwndLV);

		// 儃儕儏乕儉僗儔僀僟乕偑桳岠偐柍岠偐
		if (m_pSkin->GetImageList(IMAGELIST_VOLSLIDER) && m_pSkin->GetImageList(IMAGELIST_VOLTRACK)) {
			m_nVolumeSliderLeft = VOLSLIDER_LEFT;
			m_nVolumeSliderTop = PPC_VOLSLIDER_TOP;
			m_nVolumeSliderWidth = VOLSLIDER_WIDTH;
			m_nVolumeSliderHeight = VOLSLIDER_HEIGHT;
		}
		else {
			m_nVolumeSliderLeft = 0;
			m_nVolumeSliderTop = 0;
			m_nVolumeSliderWidth = 0;
			m_nVolumeSliderHeight = 0;
		}

		m_nBtnMax = PPC_BTN_MAX;
	}

	return fRet;
}

void CPpcMainWnd::InitSize()
{
	m_nWidth = PPC_MAINWND_WIDTH;
	m_nHeight = PPC_MAINWND_HEIGHT;
	m_nClientWidth = PPC_MAINWND_WIDTH;
	m_nClientHeight = PPC_MAINWND_HEIGHT;
	m_nDispWidth = PPC_DISP_WIDTH;
	m_nDispHeight = PPC_DISP_HEIGHT;
	m_nBtnTop = PPC_BTN_TOP;
	m_nBtnMax = PPC_BTN_MAX;
	m_nStatusTop = PPC_STATUS_TOP;
	m_nStatusHeight = PPC_STATUS_HEIGHT;
	m_nTitleTop = PPC_TITLE_TOP;
	m_nTitleWidth = PPC_TITLE_WIDTH;
	m_nTitleHeight = PPC_TITLE_HEIGHT;
	m_nSeekTop = PPC_SEEK_TOP;
	m_nSeekWidth = PPC_SEEK_WIDTH;
	m_nStreamTitleTop = PPC_STREAM_TITLE_TOP;
	m_nStreamTitleWidth = PPC_STREAM_TITLE_WIDTH;
	m_nStreamTitleHeight = PPC_STREAM_TITLE_HEIGHT;
	m_nVolumeSliderLeft = VOLSLIDER_LEFT;
	m_nVolumeSliderTop = PPC_VOLSLIDER_TOP;
	m_nVolumeSliderWidth = VOLSLIDER_WIDTH;
	m_nVolumeSliderHeight = VOLSLIDER_HEIGHT;
	m_nVolumeTrackWidth = VOLTRACK_WIDTH;
}

void CPpcMainWnd::OnCreate(HWND hwnd)
{
	m_hWnd = hwnd;
	CreateMenuBar();
	CreateListView();

	CMainWnd::OnCreate(hwnd);

	RegisterHotKeys();
	SetTimer(m_hWnd, ID_TIMER_DISPCHECK, TIMER_DISPCHECK_INTERVAL, NULL);
	SetTimer(m_hWnd, ID_TIMER_DISPSTATE, TIMER_DISPSTATE_INTERVAL, NULL);

	memset(&m_sai, 0, sizeof(m_sai));
	m_sai.cbSize = sizeof(m_sai);

	SetFocus(m_hwndLV);
	ShowWindow(m_hwndLV, SW_HIDE);
}

void CPpcMainWnd::OnClose()
{
	KillTimer(m_hWnd, ID_TIMER_DISPCHECK);
	UnregisterHotKeys();
	CMainWnd::OnClose();
}

LRESULT CPpcMainWnd::OnCommand(WPARAM wParam, LPARAM lParam)
{
	switch (LOWORD(wParam)) {
	case IDM_TOOL_TOGGLEDISPLAY:
		ToggleDisplay();
		OnTimer(ID_TIMER_DISPSTATE);
		return 0;
	case IDM_FILE_UP:
		OnFileUp();
		return 0;
	case IDM_FILE_DOWN:
		OnFileDown();
		return 0;
	case IDM_FILE_DELETE:
		OnFileDelete();
		return 0;
	case IDM_FILE_DELETEALL:
		OnFileDeleteAll();
		return 0;
	case IDM_PLAY_SELECTED:
		OnPlaySelected();
		return 0;
	case IDM_FILE_SORT_BYNAME:
	case IDM_FILE_SORT_BYPATH:
		OnFileSort(LOWORD(wParam));
		return 0;
	case IDOK:
		PostMessage(m_hWnd, WM_CLOSE, 0, 0);
		return 0;
	case IDM_TOOL_HOLD:
		OnToolHold();
		return 0;
	case IDM_TOOL_HOLDDISP:
		OnToolHoldDisp();
		return 0;
	case IDM_PLAY_PLAYSTOP:
		OnPlayPlayStop();
		return 0;
	}
	return CMainWnd::OnCommand(wParam, lParam);
}

void CPpcMainWnd::OnActivate(int nActive, BOOL fMinimized, HWND hwndPrevious)
{
	m_fActive = nActive == WA_INACTIVE ? FALSE : TRUE;

	if (!m_pOptions)
		return;

	if (((CPpcOptions*)m_pOptions)->m_fReleaseKeyMap && !m_fHold) {
		if (nActive == WA_INACTIVE)
			UnregisterHotKeys();
		else
			RegisterHotKeys();
	}

	SHHandleWMActivate(m_hWnd, MAKELONG(nActive, fMinimized), (LONG)hwndPrevious, &m_sai, FALSE);
}

void CPpcMainWnd::OnHotKey(int nId, UINT fuModifiers, UINT uVirtKey)
{
	// 枹張棟偺WM_HOTKEY傪嶍彍偡傞
	MSG msg;
	while (PeekMessage(&msg, m_hWnd, WM_HOTKEY, WM_HOTKEY, PM_REMOVE));

	CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
	if (!pOptions) return;

	// 搊榐忣曬傪嶲徠偡傞
	for (int i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
		ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
		if (p->key == uVirtKey) {
			// 儌乕僟儖僟僀傾儘僌偑昞帵偝傟偰偄傞応崌偼
			// 僟僀傾儘僌傪偩偡傕偺丄儊僯儏乕傪弌偡傕偺傪張棟偟側(cè)偄
			if (m_fMenuLoop || m_hMenu || (GetWindowLong(m_hWnd, GWL_STYLE) & WS_DISABLED)) {
				switch (p->cmd) {
				case IDM_PLAY_PLAYPAUSE:
				case IDM_PLAY_STOP:
				case IDM_PLAY_PREV:
				case IDM_PLAY_REW:
				case IDM_PLAY_FF:
				case IDM_PLAY_NEXT:
				case IDM_PLAY_REPEAT:
				case IDM_TOOL_VOLUP:
				case IDM_TOOL_VOLDOWN:
				case IDM_TOOL_TOGGLEDISPLAY:
				case IDM_TOOL_HOLD:
				case IDM_TOOL_HOLDDISP:
				case IDM_PLAY_PLAYSTOP:
					break;
				default: return;
				}
			}

			if (m_fHold) {
				BOOL fHold = FALSE;
				ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
				for (int j = 0; j < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; j++) {
					if (s_uHoldKeys[j][0] == p->key) {
						fHold = TRUE;
						break;
					}
				}

				if (p->cmd == IDM_TOOL_TOGGLEDISPLAY ||
					p->cmd == IDM_TOOL_HOLD ||
					p->cmd == IDM_TOOL_HOLDDISP || !fHold)
					PostMessage(m_hWnd, WM_COMMAND, p->cmd, 0);
				else {
					KillTimer(m_hWnd, ID_TIMER_HOLD);
					m_fDrawHold = TRUE;
					SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
					UpdateTitle();
				}
			}
			else PostMessage(m_hWnd, WM_COMMAND, p->cmd, 0);

			// 僶僢僋儔僀僩惂屼埲奜偱
			// 帺摦僶僢僋儔僀僩ON惂屼偑桳岠偺偲偒
			if (pOptions->m_fDispAutoOn &&
				(p->cmd != IDM_TOOL_TOGGLEDISPLAY && p->cmd != IDM_TOOL_HOLDDISP)) {
				TurnOnDisplay();
				m_fDisplay = TRUE;

				InvalidateRect(m_hWnd, NULL, TRUE);
				UpdateWindow(m_hWnd);
			}
			return;
		}
	}

	if (m_fHold) {
		KillTimer(m_hWnd, ID_TIMER_HOLD);
		m_fDrawHold = TRUE;
		SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
		UpdateTitle();
	}
}

void CPpcMainWnd::OnTimer(UINT uID)
{
	CMainWnd::OnTimer(uID);
	if (uID == ID_TIMER_DISPCHECK) {
		// 帺摦夋柺OFF偺僠僃僢僋
		if (!m_pOptions)
			return;

		// 僼儔僌偺僠僃僢僋
		if (!((CPpcOptions*)m_pOptions)->m_nDispAutoOff) {
			m_dwLastOperation = GetTickCount();
			return;
		}

		// 僼僅乕僇僗偑側(cè)偄応崌
		if (!m_fActive) {
			m_dwLastOperation = GetTickCount();
			return;
		}