#include "wx-utils.h"

#include <wx/wxprec.h>
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

#include <wx/spinctrl.h>
#include <wx/xrc/xmlres.h>
#include <wx/stdpaths.h>
#include <wx/fileconf.h>
#include <wx/wfstream.h>
#include <wx/progdlg.h>
#include <wx/choicebk.h>

#include "wx-dialogbox.h"
#include "wx-app.h"
#include "wx-common.h"
#include "wx-status.h"

extern "C"
{
#include "thread.h"
}

int confirm()
{
        if (emulation_state != EMULATION_STOPPED) {
                return wx_messagebox(NULL, "This will reset PCem!\nOkay to continue?", "PCem", WX_MB_OKCANCEL) == WX_IDOK;
        }
        return 1;
}

int wx_messagebox(void* window, const char* message, const char* title = NULL, int style = 5)
{
        return wxMessageBox(message, title, style | wxCENTRE | wxSTAY_ON_TOP, (wxWindow*) window);
}

void wx_simple_messagebox(const char* title, const char *format, ...)
{
        char message[2048];
        va_list ap;
        va_start(ap, format);
        vsnprintf(message, 2047, format, ap);
        message[2047] = 0;
        va_end(ap);
        wx_messagebox(0, message, title, WX_MB_OK);
}


int wx_textentrydialog(void* window, const char* message, const char* title, const char* value, unsigned int min_length, unsigned int max_length, LONG_PARAM result)
{
        while (1)
        {
                wxTextEntryDialog dlg((wxWindow*)window, message, title, value);
                if (max_length > 0)
                        dlg.SetMaxLength(max_length);
                if (dlg.ShowModal() == wxID_OK)
                {
                        wxString value = dlg.GetValue();
                        if (value.Length() >= min_length)
                        {
                                strcpy((char*)result, value.mb_str());
                                return TRUE;
                        }
                }
                else
                        return FALSE;
        }
        return FALSE;
}

void wx_setwindowtitle(void* window, char* s)
{
        ((wxFrame*) window)->SetTitle(s);
}

int wx_xrcid(const char* s)
{
        return XRCID(s);
}

int wx_filedialog(void* window, const char* title, const char* path,
                const char* extensions, const char* extension, int open, char* file)
{
        wxFileDialog dlg((wxWindow*) window, title, "", path, extensions,
                        open ? (wxFD_OPEN | wxFD_FILE_MUST_EXIST) : (wxFD_SAVE | wxFD_OVERWRITE_PROMPT));
        if (dlg.ShowModal() == wxID_OK)
        {
                wxString p = dlg.GetPath();
                wxFileName f(p);
                if (!open && !f.HasExt() && extension)
                {
                        wxString e = extension;
                        if (!p.EndsWith("."))
                                p += ".";
                        p += extension;
                        strcpy(file, p.mb_str());
                }
                else
                        strcpy(file, p.mb_str());
                return 0;
        }
        return 1;
}

void wx_checkmenuitem(void* menu, int id, int checked)
{
        wxMenuItem* item = NULL;
        if (((wxObject*)menu)->GetClassInfo()->IsKindOf(CLASSINFO(wxMenuBar)))
                item = ((wxMenuBar*) menu)->FindItem(id);
        else
                item = ((wxMenu*) menu)->FindItem(id);

        if (item)
                item->Check(checked);
        else
                std::cout << "Menu item not found: " << id << std::endl;
}

void wx_enablemenuitem(void* menu, int id, int enable)
{
        wxMenuItem* item = NULL;
        if (((wxObject*)menu)->GetClassInfo()->IsKindOf(CLASSINFO(wxMenuBar)))
                item = ((wxMenuBar*) menu)->FindItem(id);
        else
                item = ((wxMenu*) menu)->FindItem(id);

        if (item)
                item->Enable(enable);
        else
                std::cout << "Menu item not found: " << id << std::endl;
}

void* wx_getsubmenu(void* menu, int id)
{
        wxMenuItem* m = ((wxMenu*) menu)->FindItem(id);
        if (m)
                return m->GetSubMenu();

        return 0;
}

void* wx_getnativemenu(void* menu)
{
#ifdef _WIN32
        return ((wxMenu*)menu)->GetHMenu();
#endif
        return 0;
}

void* wx_getnativewindow(void* window)
{
#ifdef _WIN32
        return ((wxWindow*)window)->GetHWND();
#endif
        return 0;
}

#ifdef _WIN32
void wx_winsendmessage(void* window, int msg, INT_PARAM wParam, LONG_PARAM lParam)
{
        WinSendMessageEvent* event = new WinSendMessageEvent(wx_getnativewindow(window), msg, wParam, lParam);
        wxQueueEvent((wxWindow*)window, event);
}
#endif

void wx_appendmenu(void* sub_menu, int id, const char* title, enum wxItemKind type)
{
        ((wxMenu*) sub_menu)->Append(id, title, wxEmptyString, type);
}


void wx_enabletoolbaritem(void* toolbar, int id, int enable)
{
        ((wxToolBar*) toolbar)->EnableTool(id, enable);
}

void* wx_getmenu(void* window)
{
        return ((Frame*) window)->GetMenu();
}

void* wx_getmenubar(void* window)
{
        return ((wxFrame*) window)->GetMenuBar();
}

void* wx_gettoolbar(void* window)
{
        return ((wxFrame*) window)->GetToolBar();
}

void* wx_getdlgitem(void* window, int id)
{
        return ((wxWindow*) window)->FindWindow(id);
}

void wx_setdlgitemtext(void* window, int id, char* str)
{
        wxWindow* w = ((wxWindow*) window)->FindWindow(id);
        if (w->GetClassInfo()->IsKindOf(CLASSINFO(wxTextCtrl)))
                ((wxTextCtrl*) w)->SetValue(str);
        else
                ((wxStaticText*) w)->SetLabel(str);
}

void wx_enablewindow(void* window, int enabled)
{
        ((wxWindow*) window)->Enable(enabled);
}

void wx_showwindow(void* window, int show)
{
        wxCommandEvent* event = new wxCommandEvent(WX_SHOW_WINDOW_EVENT, wxID_ANY);
        event->SetEventObject((wxWindow*)window);
        event->SetInt(show);
        wxQueueEvent((wxWindow*)window, event);
}

int wx_iswindowvisible(void* window)
{
        return ((wxWindow*) window)->IsShown();
}

void wx_togglewindow(void* window)
{
        wx_showwindow(window, -1);
}

void wx_callback(void* window, WX_CALLBACK callback, void* data)
{
        CallbackEvent* event = new CallbackEvent(callback, data);
        wxQueueEvent((wxWindow*)window, event);
}

void wx_enddialog(void* window, int ret_code)
{
        ((wxDialog*) window)->EndModal(ret_code);
}

int wx_dlgdirlist(void* window, const char* path, int id, int static_path, int file_type)
{
        wxWindow* w = ((wxWindow*) window)->FindWindow(id);
        if (w->GetClassInfo()->IsKindOf(CLASSINFO(wxListBox)))
        {
                wxListBox* list = (wxListBox*)w;
                list->Clear();
                wxArrayString items;
                wxString f = wxFindFirstFile(path);
                while (!f.empty())
                {
                        wxFileName file(f);
                        items.Add(file.GetName());
                        f = wxFindNextFile();
                }
                items.Sort();
                list->Set(items);
                return TRUE;
        }
        return FALSE;
}

int wx_dlgdirselectex(void* window, LONG_PARAM path, int count, int id)
{
        wxWindow* w = ((wxWindow*) window)->FindWindow(id);
        if (w->GetClassInfo()->IsKindOf(CLASSINFO(wxListBox)))
        {
                wxListBox* list = (wxListBox*)w;
                strcpy((char*)path, (list->GetStringSelection() + ".").GetData().AsChar());
                return TRUE;
        }
        return FALSE;
}

int wx_sendmessage(void* window, int type, INT_PARAM param1, LONG_PARAM param2)
{
        switch (type)
        {
        case WX_CB_ADDSTRING:
                ((wxComboBox*) window)->Append((char*) param2);
                break;
        case WX_CB_SETCURSEL:
                if (param1 >= 0 && param1 < (int)((wxComboBox*) window)->GetCount())
                        ((wxComboBox*) window)->Select(param1);
                break;
        case WX_CB_GETCURSEL:
                return ((wxComboBox*) window)->GetCurrentSelection();
                break;
        case WX_CB_GETLBTEXT:
                strcpy((char*) param2, ((wxComboBox*) window)->GetString(param1).mb_str());
                break;
        case WX_CB_RESETCONTENT:
        {
#ifndef __WXOSX_MAC__
                ((wxComboBox*) window)->SetValue("");
                ((wxComboBox*) window)->Clear();
#else
                /* Clear() does not work on OSX */
                wxComboBox* cb = (wxComboBox*) window;
                int count = cb->GetCount();
                while (count--)
                        cb->Delete(0);
#endif
                break;
        }
        case WX_BM_SETCHECK:
                ((wxCheckBox*) window)->SetValue(param1);
                break;
        case WX_BM_GETCHECK:
                return ((wxCheckBox*) window)->GetValue();
                break;
        case WX_WM_SETTEXT:
        {
                if (((wxWindow*) window)->GetClassInfo()->IsKindOf(CLASSINFO(wxTextCtrl)))
                        ((wxTextCtrl*) window)->SetValue((char*) param2);
                else
                        ((wxStaticText*) window)->SetLabel((char*) param2);
        }
                break;
        case WX_WM_GETTEXT:
                if (((wxWindow*) window)->GetClassInfo()->IsKindOf(CLASSINFO(wxTextCtrl)))
                        strcpy((char*) param2, ((wxTextCtrl*) window)->GetValue().mb_str());
                else
                        strcpy((char*) param2, ((wxStaticText*) window)->GetLabel().mb_str());
                break;
        case WX_UDM_SETPOS:
                ((wxSpinCtrl*) window)->SetValue(param2);
                break;
        case WX_UDM_GETPOS:
                return ((wxSpinCtrl*) window)->GetValue();
        case WX_UDM_SETRANGE:
        {
                int min = (param2 >> 16) & 0xffff;
                int max = param2 & 0xffff;
                ((wxSpinCtrl*) window)->SetRange(min, max);
                break;
        }
        case WX_UDM_SETINCR:
        {
                /* SetIncrement-method may not exist on all platforms */
#ifdef __WXGTK__
                ((wxSpinCtrl*) window)->SetIncrement(param2);
#endif
                break;
        }
        case WX_LB_GETCOUNT:
        {
                return ((wxListBox*) window)->GetCount();
        }
        case WX_LB_GETCURSEL:
        {
                return ((wxListBox*) window)->GetSelection();
        }
        case WX_LB_SETCURSEL:
        {
                ((wxListBox*) window)->SetSelection(param1);
                break;
        }
        case WX_LB_GETTEXT:
        {
                strcpy((char*) param2, ((wxListBox*) window)->GetString(param1).mb_str());
                break;
        }
        case WX_LB_INSERTSTRING:
        {
                ((wxListBox*) window)->Insert((char*) param2, param1);
                break;
        }
        case WX_LB_DELETESTRING:
        {
                ((wxListBox*) window)->Delete(param1);
                break;
        }
        case WX_LB_RESETCONTENT:
        {
                ((wxListBox*) window)->Clear();
                break;
        }
        case WX_CHB_SETPAGETEXT:
        {
                ((wxChoicebook*)window)->SetPageText(param1, (char *)param2);
                break;
        }
        case WX_CHB_ADDPAGE:
        {
                ((wxChoicebook*)window)->AddPage((wxWindow *)param1, (char *)param2);
                break;
        }
        case WX_CHB_REMOVEPAGE:
        {
                ((wxChoicebook*)window)->RemovePage(param1);
                break;
        }
        case WX_CHB_GETPAGECOUNT:
        {
                return ((wxChoicebook*)window)->GetPageCount();
        }
        case WX_REPARENT:
        {
                ((wxWindow *)window)->Reparent((wxWindow *)param1);
                break;
        }
        }

        ((wxWindow*)window)->Fit();

        return 0;
}

int wx_dialogbox(void* window, const char* name, int (*callback)(void* window, int message, INT_PARAM param1, LONG_PARAM param2))
{
        PCemDialogBox dlg((wxWindow*) window, name, callback);
        dlg.OnInit();
        dlg.Fit();
        int ret = dlg.ShowModal();
        dlg.Destroy();
        return ret;
}

void wx_exit(void* window, int value)
{
        wxCommandEvent* event = new wxCommandEvent(WX_EXIT_EVENT, wxID_ANY);
        event->SetEventObject((wxWindow*)window);
        event->SetInt(value);
        wxQueueEvent((wxWindow*)window, event);
}

void wx_stop_emulation(void* window)
{
        wxCommandEvent* event = new wxCommandEvent(WX_STOP_EMULATION_EVENT, wxID_ANY);
        event->SetEventObject((wxWindow*)window);
        wxQueueEvent((wxWindow*)window, event);
}

int wx_yield()
{
	return wxYield();
}

/* Timer stuff */

class PCemTimer : public wxTimer
{
public:
        PCemTimer(void (*fn)())
        {
                this->fn = fn;
        }
        virtual ~PCemTimer() {};

        void Notify()
        {
                fn();
        }
private:
        void (*fn)();
};

void* wx_createtimer(void (*fn)())
{
        return new PCemTimer(fn);
}

void wx_starttimer(void* timer, int milliseconds, int once)
{
        wxTimer* t = (wxTimer*)timer;
        t->Start(milliseconds, once);
}

void wx_stoptimer(void* timer)
{
        wxTimer* t = (wxTimer*)timer;
        t->Stop();
}

void wx_destroytimer(void* timer)
{
        wx_stoptimer(timer);
        delete (wxTimer*)timer;
}

void wx_popupmenu(void* window, void* menu, int* x, int* y)
{
        PopupMenuEvent* event = new PopupMenuEvent((wxWindow*)window, (wxMenu*)menu, x, y);
        wxQueueEvent((wxWindow*)window, event);
}

void* wx_create_status_frame(void* window)
{
        StatusFrame* frame = new StatusFrame((wxWindow*)window);
        return frame;
}

void wx_destroy_status_frame(void* window)
{
        StatusFrame* frame = (StatusFrame*)window;
        delete frame;
}

void wx_setwindowposition(void* window, int x, int y)
{
        ((wxFrame*) window)->SetPosition(wxPoint(x, y));
}

void wx_setwindowsize(void* window, int width, int height)
{
        ((wxFrame*) window)->SetSize(wxSize(width, height));
}

void wx_show_status(void* window)
{
        wxWindow* status = ((wxWindow*)window)->FindWindowById(STATUS_WINDOW_ID);
        if (!status)
        {
                StatusFrame* statusFrame = new StatusFrame((wxWindow*) window);
                statusFrame->Show();
        }
}

void wx_close_status(void* window)
{
        wxWindow* status = ((wxWindow*)window)->FindWindowById(STATUS_WINDOW_ID);
        if (status)
        {
                status->Close();
        }
}

void wx_get_home_directory(char* path)
{
        wxString home = wxFileName::GetHomeDir();
        if (!home.EndsWith(wxFileName::GetPathSeparator())) {
                home.Append(wxFileName::GetPathSeparator());
        }
        strcpy(path, home.mb_str());
}

int wx_create_directory(char* path)
{
        return wxFileName::Mkdir(path);
}

int wx_setup(char* path)
{
        wxFileName p(path);
        if (!p.DirExists())
        {
                if (!p.Mkdir())
                        return FALSE;
                wxFileName configs(p);
                configs.AppendDir("configs");
                if (!configs.DirExists() && !configs.Mkdir())
                        return FALSE;

                wxFileName roms(p);
                roms.AppendDir("roms");
                if (!roms.DirExists() && !roms.Mkdir())
                        return FALSE;

                wxFileName nvr(p);
                nvr.AppendDir("nvr");
                if (!nvr.DirExists() && !nvr.Mkdir())
                        return FALSE;

                wxFileName screenshots(p);
                screenshots.AppendDir("screenshots");
                if (!screenshots.DirExists() && !screenshots.Mkdir())
                        return FALSE;

                wxFileName logs(p);
                logs.AppendDir("logs");
                if (!logs.DirExists() && !logs.Mkdir())
                        return FALSE;
        }

        return TRUE;
}

int wx_file_exists(char* path)
{
        wxFileName p(path);
        return p.Exists();
}

int wx_dir_exists(char* path)
{
        wxFileName p(path);
        return p.DirExists();
}

int wx_copy_file(char* from, char* to, int overwrite)
{
        return wxCopyFile(from, to, overwrite);
}

int wx_image_save(const char* path, const char* name, const char* format, unsigned char* rgba, int width, int height, int alpha)
{
        int x, y;
        wxLogNull logNull;
        wxImage image(width, height);
        if (alpha)
        {
                unsigned char* rgb = (unsigned char*)malloc(width*height*3);
                unsigned char* a = (unsigned char*)malloc(width*height);
                for (x = 0; x < width; ++x)
                {
                        for (y = 0; y < height; ++y)
                        {
                                rgb[(y*width+x)*3+0] = rgba[(y*width+x)*4+0];
                                rgb[(y*width+x)*3+1] = rgba[(y*width+x)*4+1];
                                rgb[(y*width+x)*3+2] = rgba[(y*width+x)*4+2];
                                a[y*width+x] = rgba[(y*width+x)*4+3];
                        }
                }
                image.SetData(rgb);
                image.SetAlpha(a);
        }
        else
                image.SetData(rgba, true);

        wxImageHandler* h;
        wxString ext;

        if (!strcmp(format, IMAGE_TIFF))
        {
                h = new wxTIFFHandler();
                ext = "tif";
        }
        else if (!strcmp(format, IMAGE_BMP))
        {
                h = new wxBMPHandler();
                ext = "bmp";
        }
        else if (!strcmp(format, IMAGE_JPG))
        {
                h = new wxJPEGHandler();
                ext = "jpg";
        }
        else
        {
                h = new wxPNGHandler();
                ext = "png";
        }

        int res = 0;
        if (h)
        {
                wxString p(path);
                if (!p.EndsWith("/"))
                        p = p.Append("/");
                p = p.Append(name).Append(".").Append(ext);

                wxFileOutputStream stream(p);
                res = h->SaveFile(&image, stream, false);
                delete h;
        }

        return res;
}

void* wx_image_load(const char* path)
{
        wxLogNull logNull; /* removes sRGB-warnings on Windows */
        wxImage* image = new wxImage(path);
        if (image->IsOk())
                return image;
        delete image;
        return 0;
}

void wx_image_free(void* image)
{
        delete (wxImage*)image;
}

void wx_image_rescale(void* image, int width, int height)
{
        ((wxImage*)image)->Rescale(width, height);
}

void wx_image_get_size(void* image, int* width, int* height)
{
        *width = ((wxImage*)image)->GetWidth();
        *height = ((wxImage*)image)->GetHeight();
}

unsigned char* wx_image_get_data(void* image)
{
        return ((wxImage*)image)->GetData();
}

unsigned char* wx_image_get_alpha(void* image)
{
        return ((wxImage*)image)->GetAlpha();
}

/* wxFileConfig */

void* wx_config_load(const char* path)
{
        if (!wxFileExists(path))
                return 0;
        wxFileInputStream stream(path);
        if (stream.IsOk())
                return new wxFileConfig(stream);
        return 0;
}
int wx_config_get_string(void* config, const char* name, char* dst, int size, const char* defVal)
{
        wxFileConfig* c = ((wxFileConfig*)config);
        wxString val;
        bool res = c->Read(name, &val, wxString(defVal));
        strncpy(dst, val.GetData().AsChar(), size-1);
        dst[size-1] = 0;
        return res;
}
int wx_config_get_int(void* config, const char* name, int* dst, int defVal)
{
        wxFileConfig* c = ((wxFileConfig*)config);
        return c->Read(name, dst, defVal);
}

int wx_config_get_float(void* config, const char* name, float* dst, float defVal)
{
        wxFileConfig* c = ((wxFileConfig*)config);
        return c->Read(name, dst, defVal);

}

int wx_config_get_bool(void* config, const char* name, int* dst, int defVal)
{
        wxFileConfig* c = ((wxFileConfig*)config);
        wxString val;
        bool res = 1;
        if (c->Read(name, &val))
        {
                val.LowerCase();
                if (val.StartsWith("true"))
                        *dst = 1;
                else if (val.StartsWith("false"))
                        *dst = 0;
                else
                        res = 0;
        }
        if (!res)
                res = c->Read(name, (bool*)dst, (bool)defVal);

        return res;
}

int wx_config_has_entry(void* config, const char* name)
{
        wxFileConfig* c = ((wxFileConfig*)config);
        return c->HasEntry(name);
}

void wx_config_free(void* config)
{
        delete (wxFileConfig*)config;
}

typedef struct progress_data_t {
        WX_CALLBACK callback;
        void* data;
        int active;
        int result;
} progress_data_t;

static void progress_callback(void* data)
{
        progress_data_t* d = (progress_data_t*) data;
        d->result = d->callback(d->data);
        d->active = 0;
}

int wx_progressdialog(void* window, const char* title, const char* message, WX_CALLBACK callback, void* data, int range, volatile int *pos)
{
        struct progress_data_t pdata;
        pdata.callback = callback;
        pdata.data = data;
        pdata.active = 1;
        pdata.result = 0;

        thread_t* t = thread_create(progress_callback, &pdata);

        wxProgressDialog dlg(title, message, range, (wxWindow*)window, wxPD_APP_MODAL | wxPD_SMOOTH | wxPD_AUTO_HIDE);
        while (pdata.active)
        {
                dlg.Update(*pos);
                wxMilliSleep(50);
        }
        thread_kill(t);

        return pdata.result;
}

void wx_date_format(char* s, const char* format)
{
        wxString res = wxDateTime::Now().Format(format);
        strcpy(s, res.mb_str());
}