/* -*-C++-*-    $NetBSD: menu.cpp,v 1.13 2011/11/23 15:49:58 nonaka Exp $       */

/*-
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by UCHIYAMA Yasushi.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <hpcmenu.h>
#include <hpcboot.h>
#include <res/resource.h>
#include <menu/window.h>
#include <menu/tabwindow.h>
#include <menu/rootwindow.h>
#include <machine/bootinfo.h>
#include <framebuffer.h>
#include <console.h>

#include <menu/menu.h>

#define SCALEX(x) (((x) * dpix) / 96/*DPI*/)
#define SCALEY(y) (((y) * dpiy) / 96/*DPI*/)
#define UNSCALEX(x) (((x) * 96) / dpix)
#define UNSCALEY(y) (((y) * 96) / dpiy)

TabWindow *
TabWindowBase::boot(int id)
{
       TabWindow *w = NULL;
       HpcMenuInterface &menu = HPC_MENU;

       switch(id) {
       default:
               break;
       case IDC_BASE_MAIN:
               menu._main = new MainTabWindow(*this, IDC_BASE_MAIN);
               w = menu._main;
               break;
       case IDC_BASE_OPTION:
               menu._option = new OptionTabWindow(*this, IDC_BASE_OPTION);
               w = menu._option;
               break;
       case IDC_BASE_CONSOLE:
               menu._console = new ConsoleTabWindow(*this, IDC_BASE_CONSOLE);
               w = menu._console;
               break;
       }

       if (w)
               w->create(0);

       return w;
}

//
// Main window
//
void
MainTabWindow::_insert_item(HWND w, TCHAR *name, int id)
{
       int idx = SendDlgItemMessage(w, id, CB_ADDSTRING, 0,
           reinterpret_cast <LPARAM>(name));
       if (idx != CB_ERR)
               SendDlgItemMessage(w, IDC_MAIN_DIR, CB_SETITEMDATA,
                   idx, _item_idx++);
}

void
MainTabWindow::init(HWND w)
{
       HpcMenuInterface &menu = HPC_MENU;
       struct HpcMenuInterface::HpcMenuPreferences &pref = HPC_PREFERENCE;

       _window = w;
       // insert myself to tab-control
       TabWindow::init(w);

       // setup child.
       TCHAR *entry;
       int i;
       // kernel directory path
       for (i = 0; entry = menu.dir(i); i++)
               _insert_item(w, entry, IDC_MAIN_DIR);
       SendDlgItemMessage(w, IDC_MAIN_DIR, CB_SETCURSEL, menu.dir_default(),
           0);
       // platform
       _sort_platids(w);
       // kernel file name.
       Edit_SetText(GetDlgItem(w, IDC_MAIN_KERNEL), pref.kernel_user ?
           pref.kernel_user_file : TEXT("netbsd.gz"));

       // root file system.
       int fs = pref.rootfs + IDC_MAIN_ROOT_;
       _set_check(fs, TRUE);

       _edit_md_root = GetDlgItem(w, IDC_MAIN_ROOT_MD_OPS);
       Edit_SetText(_edit_md_root, pref.rootfs_file);
       EnableWindow(_edit_md_root, fs == IDC_MAIN_ROOT_MD ? TRUE : FALSE);

       // layout checkbox and editbox.
       layout();

       // set default kernel boot options.
       _set_check(IDC_MAIN_OPTION_A, pref.boot_ask_for_name);
       _set_check(IDC_MAIN_OPTION_D, pref.boot_debugger);
       _set_check(IDC_MAIN_OPTION_S, pref.boot_single_user);
       _set_check(IDC_MAIN_OPTION_V, pref.boot_verbose);
       _set_check(IDC_MAIN_OPTION_H, pref.boot_serial);

       // serial console speed.
       TCHAR *speed_tab[] = { L"9600", L"19200", L"115200", 0 };
       int sel = 0;
       i = 0;
       for (TCHAR **speed = speed_tab; *speed; speed++, i++) {
               _insert_item(w, *speed, IDC_MAIN_OPTION_H_SPEED);
               if (_wtoi(*speed) == pref.serial_speed)
                       sel = i;
       }
       _combobox_serial_speed = GetDlgItem(_window, IDC_MAIN_OPTION_H_SPEED);
       SendDlgItemMessage(w, IDC_MAIN_OPTION_H_SPEED, CB_SETCURSEL, sel, 0);
       EnableWindow(_combobox_serial_speed, pref.boot_serial);
}

int
MainTabWindow::_platcmp(const void *a, const void *b)
{
       const MainTabWindow::PlatMap *pa =
               reinterpret_cast <const MainTabWindow::PlatMap *>(a);
       const MainTabWindow::PlatMap *pb =
               reinterpret_cast <const MainTabWindow::PlatMap *>(b);

       return wcscmp(pa->name, pb->name);
}

void
MainTabWindow::_sort_platids(HWND w)
{
       HpcMenuInterface &menu = HPC_MENU;
       MainTabWindow::PlatMap *p;
       TCHAR *entry;
       int nids;
       int i;

       for (nids = 0; menu.platform_get(nids); ++nids)
               continue;

       _platmap = reinterpret_cast <MainTabWindow::PlatMap *>
               (malloc(nids * sizeof(MainTabWindow::PlatMap)));

       if (_platmap == NULL) {
               // can't sort, present in the order of definition
               for (i = 0; entry = menu.platform_get(i); i++)
                       _insert_item(w, entry, IDC_MAIN_PLATFORM);
               SendDlgItemMessage(w, IDC_MAIN_PLATFORM, CB_SETCURSEL,
                                  menu.platform_default(), 0);
               return;
       }

       for (i = 0, p = _platmap; i < nids; ++i, ++p) {
               p->id = i;
               p->name = menu.platform_get(i);
       }

       qsort(_platmap, nids, sizeof(MainTabWindow::PlatMap),
             MainTabWindow::_platcmp);

       int defid = menu.platform_default();
       int defitem = 0;
       for (i = 0; i < nids; ++i) {
               if (_platmap[i].id == defid)
                       defitem = i;
               _insert_item(w, _platmap[i].name, IDC_MAIN_PLATFORM);
       }
       SendDlgItemMessage(w, IDC_MAIN_PLATFORM, CB_SETCURSEL, defitem, 0);
}

int
MainTabWindow::_item_to_platid(int idx)
{
       if (_platmap == NULL)
               return idx;
       else
               return _platmap[idx].id;
}

void
MainTabWindow::layout()
{
       // inquire display size.
       HDC hdc = GetDC(0);
       int width = GetDeviceCaps(hdc, HORZRES);
       int height = GetDeviceCaps(hdc, VERTRES);
       int dpix = GetDeviceCaps(hdc, LOGPIXELSX);
       int dpiy = GetDeviceCaps(hdc, LOGPIXELSY);
       ReleaseDC(0, hdc);

       // set origin
       int x, y;
       if (width <= 320) {
               x = 5, y = 140;
       } else if (height <= 240) {
               x = 250, y = 5;
       } else {
               x = 5, y = 140;
       }

       HWND h;
       h = GetDlgItem(_window, IDC_MAIN_OPTION_V);
       SetWindowPos(h, 0, SCALEX(x), SCALEY(y),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
       h = GetDlgItem(_window, IDC_MAIN_OPTION_S);
       SetWindowPos(h, 0, SCALEX(x), SCALEY(y + 20),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
       h = GetDlgItem(_window, IDC_MAIN_OPTION_A);
       SetWindowPos(h, 0, SCALEX(x), SCALEY(y + 40),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
       h = GetDlgItem(_window, IDC_MAIN_OPTION_D);
       SetWindowPos(h, 0, SCALEX(x), SCALEY(y + 60),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
       h = GetDlgItem(_window, IDC_MAIN_OPTION_H);
       SetWindowPos(h, 0, SCALEX(x), SCALEY(y + 80),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
       h = GetDlgItem(_window, IDC_MAIN_OPTION_H_SPEED);
       SetWindowPos(h, 0, SCALEX(x + 100), SCALEY(y + 80),
           SCALEX(120), SCALEY(10), SWP_NOSIZE | SWP_NOZORDER);
}

void
MainTabWindow::get()
{
       HpcMenuInterface &menu = HPC_MENU;
       struct HpcMenuInterface::HpcMenuPreferences &pref = HPC_PREFERENCE;

       HWND w = GetDlgItem(_window, IDC_MAIN_DIR);
       ComboBox_GetText(w, pref.dir_user_path, MAX_PATH);
       pref.dir_user = TRUE;
       w = GetDlgItem(_window, IDC_MAIN_KERNEL);
       Edit_GetText(w, pref.kernel_user_file, MAX_PATH);
       pref.kernel_user = TRUE;

       int i = ComboBox_GetCurSel(GetDlgItem(_window, IDC_MAIN_PLATFORM));
       menu.platform_set(_item_to_platid(i));

       if (_is_checked(IDC_MAIN_ROOT_WD))
               pref.rootfs = 0;
       else if (_is_checked(IDC_MAIN_ROOT_SD))
               pref.rootfs = 1;
       else if (_is_checked(IDC_MAIN_ROOT_MD))
               pref.rootfs = 2;
       else if (_is_checked(IDC_MAIN_ROOT_NFS))
               pref.rootfs = 3;
       else if (_is_checked(IDC_MAIN_ROOT_DK))
               pref.rootfs = 4;
       else if (_is_checked(IDC_MAIN_ROOT_LD))
               pref.rootfs = 5;

       pref.boot_ask_for_name  = _is_checked(IDC_MAIN_OPTION_A);
       pref.boot_debugger      = _is_checked(IDC_MAIN_OPTION_D);
       pref.boot_verbose       = _is_checked(IDC_MAIN_OPTION_V);
       pref.boot_single_user   = _is_checked(IDC_MAIN_OPTION_S);
       pref.boot_serial        = _is_checked(IDC_MAIN_OPTION_H);
       Edit_GetText(_edit_md_root, pref.rootfs_file, MAX_PATH);

       TCHAR tmpbuf[8];
       ComboBox_GetText(_combobox_serial_speed, tmpbuf, 8);
       pref.serial_speed = _wtoi(tmpbuf);
}

void
MainTabWindow::command(int id, int msg)
{
       switch (id) {
       case IDC_MAIN_OPTION_H:
               EnableWindow(_combobox_serial_speed,
                   _is_checked(IDC_MAIN_OPTION_H));
               break;
       case IDC_MAIN_ROOT_WD:
               /* FALLTHROUGH */
       case IDC_MAIN_ROOT_SD:
               /* FALLTHROUGH */
       case IDC_MAIN_ROOT_MD:
               /* FALLTHROUGH */
       case IDC_MAIN_ROOT_NFS:
               /* FALLTHROUGH */
       case IDC_MAIN_ROOT_DK:
               /* FALLTHROUGH */
       case IDC_MAIN_ROOT_LD:
               EnableWindow(_edit_md_root, _is_checked(IDC_MAIN_ROOT_MD));
       }
}

//
// Option window
//
void
OptionTabWindow::init(HWND w)
{
       struct HpcMenuInterface::HpcMenuPreferences &pref = HPC_PREFERENCE;
       HDC hdc = GetDC(0);
       int dpix = GetDeviceCaps(hdc, LOGPIXELSX);
       int dpiy = GetDeviceCaps(hdc, LOGPIXELSY);
       ReleaseDC(0, hdc);

       _window = w;

       TabWindow::init(_window);
       _spin_edit = GetDlgItem(_window, IDC_OPT_AUTO_INPUT);
       _spin = CreateUpDownControl(WS_CHILD | WS_BORDER | WS_VISIBLE |
           UDS_SETBUDDYINT | UDS_ALIGNRIGHT,
           SCALEX(80), SCALEY(0), SCALEX(50), SCALEY(50), _window,
           IDC_OPT_AUTO_UPDOWN, _app._instance, _spin_edit, 60, 1, 30);
       BOOL onoff = pref.auto_boot ? TRUE : FALSE;
       EnableWindow(_spin_edit, onoff);
       EnableWindow(_spin, onoff);

       SET_CHECK(AUTO, pref.auto_boot);
       if (pref.auto_boot) {
               TCHAR tmp[32];
               wsprintf(tmp, TEXT("%d"), pref.auto_boot);
               Edit_SetText(_spin_edit, tmp);
       }
       SET_CHECK(VIDEO,        pref.reverse_video);
       SET_CHECK(PAUSE,        pref.pause_before_boot);
       SET_CHECK(DEBUG,        pref.load_debug_info);
       SET_CHECK(SAFETY,       pref.safety_message);
       Edit_SetText(GetDlgItem(w, IDC_OPT_EXTKOPT), pref.boot_extra);
}

void
OptionTabWindow::command(int id, int msg)
{
       switch (id) {
       case IDC_OPT_AUTO:
               if (IS_CHECKED(AUTO)) {
                       EnableWindow(_spin_edit, TRUE);
                       EnableWindow(_spin, TRUE);
               } else {
                       EnableWindow(_spin_edit, FALSE);
                       EnableWindow(_spin, FALSE);
               }
               break;
       }
}

void
OptionTabWindow::get()
{
       HWND w;
       struct HpcMenuInterface::HpcMenuPreferences &pref = HPC_PREFERENCE;
       if (IS_CHECKED(AUTO)) {
               TCHAR tmp[32];
               Edit_GetText(_spin_edit, tmp, 32);
               pref.auto_boot = _wtoi(tmp);
       } else
               pref.auto_boot = 0;
       pref.reverse_video      = IS_CHECKED(VIDEO);
       pref.pause_before_boot  = IS_CHECKED(PAUSE);
       pref.load_debug_info    = IS_CHECKED(DEBUG);
       pref.safety_message     = IS_CHECKED(SAFETY);

       w = GetDlgItem(_window, IDC_OPT_EXTKOPT);
       Edit_GetText(w, pref.boot_extra, MAX_BOOT_STR);
}
#undef IS_CHECKED
#undef SET_CHECK


//
// Console window
//
void
ConsoleTabWindow::print(TCHAR *buf, BOOL force_display)
{
       int cr;
       TCHAR *p;

       if (force_display)
               goto display;

       if (_filesave) {
               if (_logfile == INVALID_HANDLE_VALUE && !_open_log_file()) {
                       _filesave = FALSE;
                       _set_check(IDC_CONS_FILESAVE, _filesave);
                       EnableWindow(_filename_edit, _filesave);
                       goto display;
               }
               DWORD cnt;
               char c;
               for (int i = 0; *buf != TEXT('\0'); buf++) {
                       c = *buf & 0x7f;
                       WriteFile(_logfile, &c, 1, &cnt, 0);
               }
               FlushFileBuffers(_logfile);
               return;
       }

display:
       // count number of '\n'
       for (cr = 0, p = buf; p = wcschr(p, TEXT('\n')); cr++, p++)
               continue;

       // total length of new buffer ('\n' -> "\r\n" + '\0')
       size_t sz = (wcslen(buf) + cr + 1) * sizeof(TCHAR);

       p = reinterpret_cast <TCHAR *>(malloc(sz));
       if (p == NULL)
               return;

       // convert newlines
       TCHAR *d = p;
       while (*buf != TEXT('\0')) {
               TCHAR c = *buf++;
               if (c == TEXT('\n'))
                       *d++ = TEXT('\r');
               *d++ = c;
       }
       *d = TEXT('\0');

       // append the text and scroll
       int end = Edit_GetTextLength(_edit);
       Edit_SetSel(_edit, end, end);
       Edit_ReplaceSel(_edit, p);
       Edit_ScrollCaret(_edit);
       UpdateWindow(_edit);

       free(p);
}

void
ConsoleTabWindow::init(HWND w)
{
       HDC hdc = GetDC(0);
       int dpix = GetDeviceCaps(hdc, LOGPIXELSX);
       int dpiy = GetDeviceCaps(hdc, LOGPIXELSY);
       ReleaseDC(0, hdc);

       // at this time _window is NULL.
       // use argument of window procedure.
       TabWindow::init(w);
       _edit = GetDlgItem(w, IDC_CONS_EDIT);
       MoveWindow(_edit, SCALEX(5), SCALEY(60),
           SCALEX(UNSCALEX(_rect.right - _rect.left) - 10),
           SCALEY(UNSCALEY(_rect.bottom - _rect.top) - 60), TRUE);
       Edit_FmtLines(_edit, TRUE);

       // log file.
       _filename_edit = GetDlgItem(w, IDC_CONS_FILENAME);
       _filesave = FALSE;
       Edit_SetText(_filename_edit, L"bootlog.txt");
       EnableWindow(_filename_edit, _filesave);
}

void
ConsoleTabWindow::command(int id, int msg)
{
       HpcMenuInterface &menu = HPC_MENU;
       struct HpcMenuInterface::cons_hook_args *hook = 0;
       int bit;

       switch(id) {
       case IDC_CONS_FILESAVE:
               _filesave = _is_checked(IDC_CONS_FILESAVE);
               EnableWindow(_filename_edit, _filesave);
               break;
       case IDC_CONS_CHK0:
               /* FALLTHROUGH */
       case IDC_CONS_CHK1:
               /* FALLTHROUGH */
       case IDC_CONS_CHK2:
               /* FALLTHROUGH */
       case IDC_CONS_CHK3:
               /* FALLTHROUGH */
       case IDC_CONS_CHK4:
               /* FALLTHROUGH */
       case IDC_CONS_CHK5:
               /* FALLTHROUGH */
       case IDC_CONS_CHK6:
               /* FALLTHROUGH */
       case IDC_CONS_CHK7:
               bit = 1 << (id - IDC_CONS_CHK_);
               if (SendDlgItemMessage(_window, id, BM_GETCHECK, 0, 0))
                       menu._cons_parameter |= bit;
               else
                       menu._cons_parameter &= ~bit;
               break;
       case IDC_CONS_BTN0:
               /* FALLTHROUGH */
       case IDC_CONS_BTN1:
               /* FALLTHROUGH */
       case IDC_CONS_BTN2:
               /* FALLTHROUGH */
       case IDC_CONS_BTN3:
               hook = &menu._cons_hook[id - IDC_CONS_BTN_];
               if (hook->func)
                       hook->func(hook->arg, menu._cons_parameter);

               break;
       }
}

BOOL
ConsoleTabWindow::_open_log_file()
{
       TCHAR path[MAX_PATH];
       TCHAR filename[MAX_PATH];
       TCHAR filepath[MAX_PATH];

       if (!_find_pref_dir(path)) {
               print(L"couldn't find temporary directory.\n", TRUE);
               return FALSE;
       }

       Edit_GetText(_filename_edit, filename, MAX_PATH);
       wsprintf(filepath, TEXT("\\%s\\%s"), path, filename);
       _logfile = CreateFile(filepath, GENERIC_WRITE, 0, 0,
           CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
       if (_logfile == INVALID_HANDLE_VALUE)
               return FALSE;

       wsprintf(path, TEXT("log file is %s\n"), filepath);
       print(path, TRUE);

       return TRUE;
}

//
// Common utility
//
static BOOL
is_ignore_directory(TCHAR *filename)
{
       static const TCHAR *dirs[] = {
               // Network (in Japanese)
               (const TCHAR *)"\xcd\x30\xc3\x30\xc8\x30\xef\x30\xfc\x30\xaf\x30\x00\x00",
       };

       for (int i = 0; i < sizeof(dirs) / sizeof(dirs[0]); i++) {
               if (wcscmp(filename, dirs[i]) == 0) {
                       return TRUE;
               }
       }
       return FALSE;
}

BOOL
_find_pref_dir(TCHAR *path)
{
       WIN32_FIND_DATA fd;
       HANDLE find;

       lstrcpy(path, TEXT("\\*.*"));
       find = FindFirstFile(path, &fd);

       if (find != INVALID_HANDLE_VALUE) {
               do {
                       int attr = fd.dwFileAttributes;
                       if ((attr & FILE_ATTRIBUTE_DIRECTORY) &&
                           (attr & FILE_ATTRIBUTE_TEMPORARY) &&
                           !is_ignore_directory(fd.cFileName)) {
                               wcscpy(path, fd.cFileName);
                               FindClose(find);
                               return TRUE;
                       }
               } while (FindNextFile(find, &fd));
       }
       FindClose(find);

       return FALSE;
}