// Copyright 2008 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#include <cmath>
#include <string>
#include <wx/brush.h>
#include <wx/clipbrd.h>
#include <wx/colour.h>
#include <wx/control.h>
#include <wx/dataobj.h>
#include <wx/dcclient.h>
#include <wx/font.h>
#include <wx/menu.h>
#include <wx/pen.h>

#include "Common/CommonTypes.h"
#include "Common/DebugInterface.h"
#include "Common/StringUtil.h"
#include "Core/PowerPC/PowerPC.h"
#include "DolphinWX/Debugger/CodeWindow.h"
#include "DolphinWX/Debugger/DebuggerUIUtil.h"
#include "DolphinWX/Debugger/MemoryView.h"
#include "DolphinWX/Debugger/WatchWindow.h"
#include "DolphinWX/Frame.h"
#include "DolphinWX/Globals.h"
#include "DolphinWX/WxUtils.h"

enum
{
  IDM_GOTOINMEMVIEW = 12000,
  IDM_COPYADDRESS,
  IDM_COPYHEX,
  IDM_COPYCODE,
  IDM_RUNTOHERE,
  IDM_DYNARECRESULTS,
  IDM_WATCHADDRESS,
  IDM_TOGGLEMEMORY,
  IDM_VIEWASFP,
  IDM_VIEWASASCII,
  IDM_VIEWASHEX,
};

CMemoryView::CMemoryView(DebugInterface* debuginterface, wxWindow* parent)
    : wxControl(parent, wxID_ANY), debugger(debuginterface),
      align(debuginterface->GetInstructionSize(0)), rowHeight(13), selection(0), oldSelection(0),
      selecting(false), memory(0), curAddress(debuginterface->GetPC()),
      dataType(MemoryDataType::U8), viewAsType(VIEWAS_FP)
{
  Bind(wxEVT_PAINT, &CMemoryView::OnPaint, this);
  Bind(wxEVT_LEFT_DOWN, &CMemoryView::OnMouseDownL, this);
  Bind(wxEVT_LEFT_UP, &CMemoryView::OnMouseUpL, this);
  Bind(wxEVT_MOTION, &CMemoryView::OnMouseMove, this);
  Bind(wxEVT_RIGHT_DOWN, &CMemoryView::OnMouseDownR, this);
  Bind(wxEVT_MOUSEWHEEL, &CMemoryView::OnScrollWheel, this);
  Bind(wxEVT_MENU, &CMemoryView::OnPopupMenu, this);
  Bind(wxEVT_SIZE, &CMemoryView::OnResize, this);
}

int CMemoryView::YToAddress(int y)
{
  wxRect rc = GetClientRect();
  int ydiff = y - rc.height / 2 - rowHeight / 2;
  ydiff = (int)(floorf((float)ydiff / (float)rowHeight)) + 1;
  return curAddress + ydiff * align;
}

void CMemoryView::OnMouseDownL(wxMouseEvent& event)
{
  int x = event.m_x;
  int y = event.m_y;

  if (x > 16)
  {
    oldSelection = selection;
    selection = YToAddress(y);
    bool oldselecting = selecting;
    selecting = true;

    if (!oldselecting || (selection != oldSelection))
      Refresh();
  }
  else
  {
    debugger->ToggleMemCheck(YToAddress(y));

    Refresh();

    // Propagate back to the parent window to update the breakpoint list.
    wxCommandEvent evt(wxEVT_HOST_COMMAND, IDM_UPDATE_BREAKPOINTS);
    GetEventHandler()->AddPendingEvent(evt);
  }

  event.Skip();
}

void CMemoryView::OnMouseMove(wxMouseEvent& event)
{
  wxRect rc = GetClientRect();

  if (event.m_leftDown && event.m_x > 16)
  {
    if (event.m_y < 0)
    {
      curAddress -= align;
      Refresh();
    }
    else if (event.m_y > rc.height)
    {
      curAddress += align;
      Refresh();
    }
    else
      OnMouseDownL(event);
  }

  event.Skip();
}

void CMemoryView::OnMouseUpL(wxMouseEvent& event)
{
  if (event.m_x > 16)
  {
    curAddress = YToAddress(event.m_y);
    selecting = false;
    Refresh();
  }

  event.Skip();
}

void CMemoryView::OnScrollWheel(wxMouseEvent& event)
{
  const bool scroll_down = (event.GetWheelRotation() < 0);
  const int num_lines = event.GetLinesPerAction();

  if (scroll_down)
  {
    curAddress += num_lines * 4;
  }
  else
  {
    curAddress -= num_lines * 4;
  }

  Refresh();
  event.Skip();
}

void CMemoryView::OnPopupMenu(wxCommandEvent& event)
{
  CFrame* main_frame = static_cast<CFrame*>(GetGrandParent()->GetParent());
  CCodeWindow* code_window = main_frame->g_pCodeWindow;
  CWatchWindow* watch_window = code_window->m_WatchWindow;

#if wxUSE_CLIPBOARD
  wxTheClipboard->Open();
#endif

  switch (event.GetId())
  {
#if wxUSE_CLIPBOARD
  case IDM_COPYADDRESS:
    wxTheClipboard->SetData(new wxTextDataObject(wxString::Format("%08x", selection)));
    break;

  case IDM_COPYHEX:
  {
    std::string temp = StringFromFormat("%08x", debugger->ReadExtraMemory(memory, selection));
    wxTheClipboard->SetData(new wxTextDataObject(StrToWxStr(temp)));
  }
  break;
#endif

  case IDM_WATCHADDRESS:
    debugger->AddWatch(selection);
    if (watch_window)
      watch_window->NotifyUpdate();
    Refresh();
    break;

  case IDM_TOGGLEMEMORY:
    memory ^= 1;
    Refresh();
    break;

  case IDM_VIEWASFP:
    viewAsType = VIEWAS_FP;
    Refresh();
    break;

  case IDM_VIEWASASCII:
    viewAsType = VIEWAS_ASCII;
    Refresh();
    break;
  case IDM_VIEWASHEX:
    viewAsType = VIEWAS_HEX;
    Refresh();
    break;
  }

#if wxUSE_CLIPBOARD
  wxTheClipboard->Close();
#endif
  event.Skip();
}

void CMemoryView::OnMouseDownR(wxMouseEvent& event)
{
  // popup menu
  wxMenu menu;
// menu.Append(IDM_GOTOINMEMVIEW, _("&Goto in mem view"));
#if wxUSE_CLIPBOARD
  menu.Append(IDM_COPYADDRESS, _("Copy &address"));
  menu.Append(IDM_COPYHEX, _("Copy &hex"));
#endif
  menu.Append(IDM_WATCHADDRESS, _("Add to &watch"));
  menu.Append(IDM_TOGGLEMEMORY, _("Toggle &memory"));

  wxMenu* viewAsSubMenu = new wxMenu;
  viewAsSubMenu->Append(IDM_VIEWASFP, _("FP value"));
  viewAsSubMenu->Append(IDM_VIEWASASCII, "ASCII");
  viewAsSubMenu->Append(IDM_VIEWASHEX, _("Hex"));
  menu.AppendSubMenu(viewAsSubMenu, _("View As:"));

  PopupMenu(&menu);
}

void CMemoryView::OnPaint(wxPaintEvent& event)
{
  wxPaintDC dc(this);
  wxRect rc = GetClientRect();
  wxFont hFont("Courier");
  hFont.SetFamily(wxFONTFAMILY_TELETYPE);

  wxCoord w, h;
  dc.GetTextExtent("0WJyq", &w, &h, nullptr, nullptr, &hFont);
  if (h > rowHeight)
    rowHeight = h;
  dc.GetTextExtent("0WJyq", &w, &h, nullptr, nullptr, &DebuggerFont);
  if (h > rowHeight)
    rowHeight = h;

  if (viewAsType == VIEWAS_HEX)
    dc.SetFont(hFont);
  else
    dc.SetFont(DebuggerFont);

  dc.GetTextExtent("W", &w, &h);
  int fontSize = w;
  int textPlacement = 17 + 9 * fontSize;

  // TODO: Add any drawing code here...
  int width = rc.width;
  int numRows = (rc.height / rowHeight) / 2 + 2;
  dc.SetBackgroundMode(wxTRANSPARENT);
  const wxColour bgColor = *wxWHITE;
  wxPen nullPen(bgColor);
  wxPen currentPen(*wxBLACK_PEN);
  wxPen selPen(*wxGREY_PEN);
  nullPen.SetStyle(wxTRANSPARENT);

  wxBrush currentBrush(*wxLIGHT_GREY_BRUSH);
  wxBrush pcBrush(*wxGREEN_BRUSH);
  wxBrush mcBrush(*wxBLUE_BRUSH);
  wxBrush bgBrush(bgColor);
  wxBrush nullBrush(bgColor);
  nullBrush.SetStyle(wxTRANSPARENT);

  dc.SetPen(nullPen);
  dc.SetBrush(bgBrush);
  dc.DrawRectangle(0, 0, 16, rc.height);
  dc.DrawRectangle(0, 0, rc.width, 5 + 8);

  // TODO - clean up this freaking mess!!!!!
  for (int row = -numRows; row <= numRows; row++)
  {
    unsigned int address = curAddress + row * align;

    int rowY1 = rc.height / 2 + rowHeight * row - rowHeight / 2;
    int rowY2 = rc.height / 2 + rowHeight * row + rowHeight / 2;

    wxString temp = wxString::Format("%08x", address);
    u32 col = debugger->GetColor(address);
    wxBrush rowBrush(wxColour(col >> 16, col >> 8, col));
    dc.SetBrush(nullBrush);
    dc.SetPen(nullPen);
    dc.DrawRectangle(0, rowY1, 16, rowY2);

    if (selecting && (address == selection))
      dc.SetPen(selPen);
    else
      dc.SetPen(row == 0 ? currentPen : nullPen);

    if (address == debugger->GetPC())
      dc.SetBrush(pcBrush);
    else
      dc.SetBrush(rowBrush);

    dc.DrawRectangle(16, rowY1, width, rowY2 - 1);
    dc.SetBrush(currentBrush);
    dc.SetTextForeground("#600000");  // Dark red
    dc.DrawText(temp, 17, rowY1);

    if (viewAsType != VIEWAS_HEX)
    {
      char mem[256];
      debugger->GetRawMemoryString(memory, address, mem, 256);
      dc.SetTextForeground(wxTheColourDatabase->Find("NAVY"));
      dc.DrawText(StrToWxStr(mem), 17 + fontSize * (8), rowY1);
      dc.SetTextForeground(*wxBLACK);
    }

    if (!PowerPC::HostIsRAMAddress(address))
      continue;

    if (debugger->IsAlive())
    {
      std::string dis;
      u32 mem_data = debugger->ReadExtraMemory(memory, address);

      if (viewAsType == VIEWAS_FP)
      {
        float flt = *(float*)(&mem_data);
        dis = StringFromFormat("f: %f", flt);
      }
      else if (viewAsType == VIEWAS_ASCII)
      {
        u32 a[4] = {(mem_data & 0xff000000) >> 24, (mem_data & 0xff0000) >> 16,
                    (mem_data & 0xff00) >> 8, (mem_data & 0xff)};

        for (auto& word : a)
        {
          if (word == '\0')
            word = ' ';
        }

        dis = StringFromFormat("%c%c%c%c", a[0], a[1], a[2], a[3]);
      }
      else if (viewAsType == VIEWAS_HEX)
      {
        u32 mema[8] = {debugger->ReadExtraMemory(memory, address),
                       debugger->ReadExtraMemory(memory, address + 4),
                       debugger->ReadExtraMemory(memory, address + 8),
                       debugger->ReadExtraMemory(memory, address + 12),
                       debugger->ReadExtraMemory(memory, address + 16),
                       debugger->ReadExtraMemory(memory, address + 20),
                       debugger->ReadExtraMemory(memory, address + 24),
                       debugger->ReadExtraMemory(memory, address + 28)};

        for (auto& word : mema)
        {
          switch (dataType)
          {
          case MemoryDataType::U8:
            dis += StringFromFormat(" %02X %02X %02X %02X", ((word & 0xff000000) >> 24) & 0xFF,
                                    ((word & 0xff0000) >> 16) & 0xFF, ((word & 0xff00) >> 8) & 0xFF,
                                    word & 0xff);
            break;
          case MemoryDataType::U16:
            dis += StringFromFormat(" %02X%02X %02X%02X", ((word & 0xff000000) >> 24) & 0xFF,
                                    ((word & 0xff0000) >> 16) & 0xFF, ((word & 0xff00) >> 8) & 0xFF,
                                    word & 0xff);
            break;
          case MemoryDataType::U32:
            dis += StringFromFormat(" %02X%02X%02X%02X", ((word & 0xff000000) >> 24) & 0xFF,
                                    ((word & 0xff0000) >> 16) & 0xFF, ((word & 0xff00) >> 8) & 0xFF,
                                    word & 0xff);
            break;
          }
        }
      }
      else
      {
        dis = "INVALID VIEWAS TYPE";
      }

      if (viewAsType != VIEWAS_HEX)
        dc.DrawText(StrToWxStr(dis), textPlacement + fontSize * (8 + 8), rowY1);
      else
        dc.DrawText(StrToWxStr(dis), textPlacement, rowY1);

      dc.SetTextForeground(*wxBLUE);

      std::string desc = debugger->GetDescription(address);
      if (!desc.empty())
        dc.DrawText(StrToWxStr(desc), 17 + fontSize * ((8 + 8 + 8 + 30) * 2), rowY1);

      // Show blue memory check dot
      if (debugger->IsMemCheck(address))
      {
        dc.SetBrush(mcBrush);
        dc.DrawRectangle(8, rowY1 + 1, 11, 11);
      }
    }
  }

  dc.SetPen(currentPen);
}

void CMemoryView::OnResize(wxSizeEvent& event)
{
  Refresh();
  event.Skip();
}
