#include "PreferencesPanel.h"

enum {ACCOUNT_NAME, ACCOUNT_NUMBER, ACCOUNT_SHARED, ACCOUNT_DEFAULT, ACCOUNT_DELETE, NUMBER_COLS_ACCOUNT};
enum {CATEGORY_NAME, CATEGORY_COLOR, CATEGORY_FONT, CATEGORY_DELETE, NUMBER_COLS_CATEGORY};

enum {CATEGORIES_GRID_ID=1, ACCOUNTS_GRID_ID, NAME_ID, CHANGE_NAME_ID, CHANGE_PASSWORD_ID, KILL_ME_ID};

BEGIN_EVENT_TABLE(PreferencesPanel, wxPanel)
EVT_BUTTON(CHANGE_NAME_ID, PreferencesPanel::OnChangeName)
EVT_BUTTON(CHANGE_PASSWORD_ID, PreferencesPanel::OnChangePassword)
EVT_BUTTON(KILL_ME_ID, PreferencesPanel::OnKillMe)
EVT_GRID_CMD_CELL_CHANGE(CATEGORIES_GRID_ID, PreferencesPanel::OnCategoryModified)
EVT_GRID_CMD_CELL_CHANGE(ACCOUNTS_GRID_ID, PreferencesPanel::OnAccountModified)
EVT_SHOW(PreferencesPanel::OnShow)
END_EVENT_TABLE()

PreferencesPanel::PreferencesPanel(KissCount* kiss, wxUI *parent) : wxPanel(&(*parent)), _kiss(kiss), _wxUI(parent)
{
  wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
  //wxBoxSizer *hbox = new wxBoxSizer(wxHORIZONTAL);
  wxStaticBox* staticUser, *staticAccount, *staticCategories;
  User* user = _kiss->GetUser();
  wxGridBagSizer *gridBagSizer;
  wxStaticText* label;
  wxButton* buttonChangeName, *buttonChangePassword, *killMe;
  wxStaticBoxSizer * staticBoxSizer;

  SetSizer(vbox);

  staticUser = new wxStaticBox(this, -1, _("User"));
  staticAccount = new wxStaticBox(this, -1, _("Accounts"));
  staticCategories = new wxStaticBox(this, -1, _("Categories"));

  // User
  staticBoxSizer = new wxStaticBoxSizer (staticUser, wxVERTICAL);

  gridBagSizer = new wxGridBagSizer(10, 10);
  staticBoxSizer->Add(gridBagSizer);

  label = new wxStaticText(this, -1, _("Name"));
  gridBagSizer->Add(label, wxGBPosition(0, 0));
    
  _name = new wxTextCtrl(this, NAME_ID, user->_name);
  gridBagSizer->Add(_name, wxGBPosition(0, 1));

  buttonChangeName = new wxButton(this, CHANGE_NAME_ID, _("Change Name"));
  buttonChangePassword = new wxButton(this, CHANGE_PASSWORD_ID, _("Change Password"));
  killMe = new wxButton(this, KILL_ME_ID, _("Kill me"));

  gridBagSizer->Add(buttonChangeName, wxGBPosition(1, 0));
  gridBagSizer->Add(buttonChangePassword, wxGBPosition(1, 1));
  gridBagSizer->Add(killMe, wxGBPosition(1, 2));

  vbox->Add(staticBoxSizer);
  vbox->Add(-1, 20);

  // Account
  staticBoxSizer = new wxStaticBoxSizer (staticAccount, wxVERTICAL);

  _accountsGrid = new wxGrid(this, ACCOUNTS_GRID_ID);

  InitAccounts(user);

  staticBoxSizer->Add(_accountsGrid);

  vbox->Add(staticBoxSizer);
  vbox->Add(-1, 20);

  // Categories
  staticBoxSizer = new wxStaticBoxSizer (staticCategories, wxVERTICAL);

  _categoriesGrid = new wxGrid(this, CATEGORIES_GRID_ID);

  staticBoxSizer->Add(_categoriesGrid);

  InitCategories(user);

  vbox->Add(staticBoxSizer);

  Fit();
  SetMinSize(GetSize());

  Hide();
}

void PreferencesPanel::InitAccounts(User* user)
{
  std::vector<Account>::iterator it;
  int curLine = 0;
  Account account ;
  DEFAULT_FONT(font);

  _accountsGrid->CreateGrid(0, NUMBER_COLS_ACCOUNT);
  _accountsGrid->SetRowLabelSize(0);
  _accountsGrid->SetColLabelValue(ACCOUNT_NAME, _("Name"));
  _accountsGrid->SetColLabelValue(ACCOUNT_NUMBER, _("Number"));
  _accountsGrid->SetColLabelValue(ACCOUNT_SHARED, _("Shared"));
  _accountsGrid->SetColLabelValue(ACCOUNT_DEFAULT, _("Default"));
  _accountsGrid->SetColLabelValue(ACCOUNT_DELETE, _("Delete"));
  _accountsGrid->SetDefaultCellFont(font);

  for (it = user->_accounts.begin(); it != user->_accounts.end(); it++, curLine++)
    {
      _accountsGrid->AppendRows();

      _accountsGrid->SetCellValue(curLine, ACCOUNT_NAME, it->name);
      _accountsGrid->SetCellValue(curLine, ACCOUNT_NUMBER, it->number);

      _accountsGrid->SetCellRenderer(curLine, ACCOUNT_SHARED, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(curLine, ACCOUNT_SHARED, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellRenderer(curLine, ACCOUNT_DEFAULT, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(curLine, ACCOUNT_DEFAULT, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellRenderer(curLine, ACCOUNT_DELETE, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(curLine, ACCOUNT_DELETE, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellValue(curLine, ACCOUNT_SHARED, (it->shared)?wxT("1"):wxT("0"));
      _accountsGrid->SetCellValue(curLine, ACCOUNT_DEFAULT, (it->_default)?wxT("1"):wxT("0"));
      
      _accountsGrid->SetCellAlignment(curLine, ACCOUNT_SHARED, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _accountsGrid->SetCellAlignment(curLine, ACCOUNT_DEFAULT, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _accountsGrid->SetCellAlignment(curLine, ACCOUNT_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);
    }

  _accountsGrid->AutoSizeColumns(true);    
  _accountsGrid->AppendRows();

  _accountsGrid->SetReadOnly(curLine, ACCOUNT_SHARED, true);
  _accountsGrid->SetReadOnly(curLine, ACCOUNT_DEFAULT, true);
  _accountsGrid->SetReadOnly(curLine, ACCOUNT_DELETE, true);
}

#define SET_ROW_COLOR(row, color)  for(int i=0; i<NUMBER_COLS_CATEGORY; i++) \
    {									\
      _categoriesGrid->SetCellBackgroundColour(row, i, color);		\
    }

void PreferencesPanel::InitCategories(User* user)
{
  std::vector<Category>::iterator it;
  int curLine = 0;
  DEFAULT_FONT(font);

  _categoriesGrid->CreateGrid(0, NUMBER_COLS_CATEGORY);
  _categoriesGrid->SetRowLabelSize(0);
  _categoriesGrid->SetDefaultCellFont(font);

  _categoriesGrid->SetColLabelValue(CATEGORY_NAME, _("Name"));
  _categoriesGrid->SetColLabelValue(CATEGORY_COLOR, _("Color"));
  _categoriesGrid->SetColLabelValue(CATEGORY_FONT, _("Font"));
  _categoriesGrid->SetColLabelValue(CATEGORY_DELETE, _("Delete"));

  for (it=user->_categories.begin(); it!=user->_categories.end(); it++, curLine++)
    {
      _categoriesGrid->AppendRows();
	
      _categoriesGrid->SetCellValue(curLine, CATEGORY_NAME, it->name);
      SET_ROW_COLOR(curLine, it->color);
      if (curLine)
	{
	  _categoriesGrid->SetCellRenderer(curLine, CATEGORY_DELETE, new wxGridCellBoolRenderer ());
	  _categoriesGrid->SetCellEditor(curLine, CATEGORY_DELETE, new wxGridCellBoolEditor ());
	}

      _categoriesGrid->SetCellAlignment(curLine, CATEGORY_COLOR, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _categoriesGrid->SetCellAlignment(curLine, CATEGORY_FONT, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _categoriesGrid->SetCellAlignment(curLine, CATEGORY_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);
    }

  _categoriesGrid->SetReadOnly(0, CATEGORY_NAME, true);
  _categoriesGrid->SetReadOnly(0, CATEGORY_DELETE, true);
  _categoriesGrid->AutoSizeColumns(true);    

  _categoriesGrid->AppendRows();
  _categoriesGrid->SetReadOnly(curLine, CATEGORY_COLOR, true);
  _categoriesGrid->SetReadOnly(curLine, CATEGORY_FONT, true);
  _categoriesGrid->SetReadOnly(curLine, CATEGORY_DELETE, true);
  SET_ROW_COLOR(curLine, OWN_GREEN);
}

void PreferencesPanel::OnAccountModified(wxGridEvent& event)
{
  int op_complete = 2;
  wxString value ;
  Account new_account, account;
  User* user = _kiss->GetUser();
  int row = event.GetRow();
  int col = event.GetCol();
  static bool inModification = false ;
  int i;

  if (inModification) return;

  inModification = true;

  value = _accountsGrid->GetCellValue(row, ACCOUNT_NAME);
  if (value != wxT(""))
    {
      new_account.name = value;
      op_complete--;
    }
  
  value = _accountsGrid->GetCellValue(row, ACCOUNT_NUMBER);
  if (value != wxT(""))
    {
      new_account.number = value;
      op_complete--;
    }

  value = _accountsGrid->GetCellValue(row, ACCOUNT_SHARED);
  if (value != wxT("") && value != wxT("0"))
    new_account.shared = true;
  else
    new_account.shared = false;

  value = _accountsGrid->GetCellValue(row, ACCOUNT_DEFAULT);
  if (value != wxT("") && value != wxT("0"))
    new_account._default = true;
  else
    new_account._default = false;

  if (col == ACCOUNT_DEFAULT)
    {
      new_account.id = user->_accounts[row].id;

      for (i=0; i<user->GetAccountsNumber(); i++)
	{
	  if (i != row)
	    {
	      account = user->_accounts[i];
	      if (account._default)
		{
		  account._default = false;
		  _kiss->UpdateAccount(account);
		  _accountsGrid->SetCellValue(i, ACCOUNT_DEFAULT, wxT(""));
		  break;
		}
	    }

	  _kiss->UpdateAccount(new_account);
	}
    }

  // Account modification
  if (user->GetAccountsNumber() && row < user->GetAccountsNumber())
    {
      new_account.id = user->_accounts[row].id;

      if (col == ACCOUNT_DELETE)
	{
	  if (user->_accounts.size() == 1)
	    {
	      wxMessageBox(_("It must be at least one account !"), _("Error"), wxICON_ERROR | wxOK);
	      _accountsGrid->SetCellValue(row, col, wxT("0"));
	      return;
	    }
	  wxMessageDialog dialog(_wxUI, _("Are you sure want to delete ")+new_account.name, wxT("KissCount"), wxYES_NO);
	  if (dialog.ShowModal() == wxID_NO)
	    {
	      _accountsGrid->SetCellValue(row, col, wxT("0"));
	    }
	  else
	    {
	      _accountsGrid->DeleteRows(row, 1);
	      _kiss->DeleteAccount(new_account);
	    }

	  _wxUI->Layout();
	  inModification = false;
	  _wxUI->NeedReload();
	  return;
	}
      _kiss->UpdateAccount(new_account);
    }
  // New account
  else
    {
      if (op_complete) 
	{
	  inModification = false;
	  return ;
	}

      if (user->GetAccountId(new_account.name) != wxT("0"))
	{
	  wxMessageBox(_("Account ")+new_account.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
	  inModification = false;
	  return ;
	}

      _accountsGrid->SetCellRenderer(row, ACCOUNT_SHARED, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(row, ACCOUNT_SHARED, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellRenderer(row, ACCOUNT_DEFAULT, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(row, ACCOUNT_DEFAULT, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellRenderer(row, ACCOUNT_DELETE, new wxGridCellBoolRenderer ());
      _accountsGrid->SetCellEditor(row, ACCOUNT_DELETE, new wxGridCellBoolEditor ());
      _accountsGrid->SetCellAlignment(row, ACCOUNT_SHARED, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _accountsGrid->SetCellAlignment(row, ACCOUNT_DEFAULT, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _accountsGrid->SetCellAlignment(row, ACCOUNT_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);

      _accountsGrid->SetReadOnly(row, ACCOUNT_SHARED, false);
      _accountsGrid->SetReadOnly(row, ACCOUNT_DEFAULT, false);
      _accountsGrid->SetReadOnly(row, ACCOUNT_DELETE, false);

      if (!user->GetAccountsNumber())
	{
	  new_account._default = true;
	  _accountsGrid->SetCellValue(row, ACCOUNT_DEFAULT, wxT("1"));
	}
      
      _accountsGrid->AutoSizeColumns(true);    
      _accountsGrid->AppendRows();

      _accountsGrid->SetReadOnly(row+1, ACCOUNT_SHARED, true);
      _accountsGrid->SetReadOnly(row+1, ACCOUNT_DEFAULT, true);
      _accountsGrid->SetReadOnly(row+1, ACCOUNT_DELETE, true);

      _kiss->AddAccount(new_account);
    }
  
  _wxUI->Layout();
  _wxUI->NeedReload();
  inModification = false;
}

void PreferencesPanel::OnCategoryModified(wxGridEvent& event)
{
  int op_complete = 1;
  wxString value;
  User* user = _kiss->GetUser();
  int row = event.GetRow();
  int col = event.GetCol();
  static bool inModification = false ;
  Category new_cat;

  if (inModification) return;

  inModification = true;

  value = _categoriesGrid->GetCellValue(row, CATEGORY_NAME);
  if (value != wxT(""))
    {
      new_cat.name = value;
      op_complete--;
    }

  new_cat.color = _categoriesGrid->GetCellBackgroundColour(row, col);
  new_cat.font = wxT("");
  new_cat.parent = wxT("0");

  // Categories modification
  if (user->GetCategoriesNumber() && row < user->GetCategoriesNumber())
    {
      new_cat.id = user->_categories[row].id;
      if (col == CATEGORY_DELETE)
	{
	  wxMessageDialog dialog(_wxUI, _("Are you sure want to delete : \n")+new_cat.name, wxT("KissCount"), wxYES_NO);
	  if (dialog.ShowModal() == wxID_NO)
	    {
	      _categoriesGrid->SetCellValue(row, col, wxT("0"));
	    }
	  else
	    {
	      _categoriesGrid->DeleteRows(row, 1);
	      _kiss->DeleteCategory(user->_categories[row]);
	    }

	  _wxUI->Layout();
	  _wxUI->NeedReload();
	  inModification = false;
	  return;
	}
      _kiss->UpdateCategory(new_cat);
    }
  // New category
  else
    {
      if (op_complete) 
	{
	  inModification = false;
	  return ;
	}
      
      if (user->GetCategoryId(new_cat.name) != wxT("0"))
	{
	  wxMessageBox(_("Category ")+new_cat.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
	  inModification = false;
	  return ;
	}

      _kiss->AddCategory(new_cat);
      _categoriesGrid->SetReadOnly(row, CATEGORY_COLOR, false);
      _categoriesGrid->SetReadOnly(row, CATEGORY_FONT, false);
      _categoriesGrid->SetReadOnly(row, CATEGORY_DELETE, false);
      _categoriesGrid->SetCellRenderer(row, CATEGORY_DELETE, new wxGridCellBoolRenderer ());
      _categoriesGrid->SetCellEditor(row, CATEGORY_DELETE, new wxGridCellBoolEditor ());

      _categoriesGrid->SetCellAlignment(row, CATEGORY_COLOR, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _categoriesGrid->SetCellAlignment(row, CATEGORY_FONT, wxALIGN_CENTRE, wxALIGN_CENTRE);
      _categoriesGrid->SetCellAlignment(row, CATEGORY_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);

      row++;
      _categoriesGrid->AppendRows();
      _categoriesGrid->SetReadOnly(row, CATEGORY_COLOR, true);
      _categoriesGrid->SetReadOnly(row, CATEGORY_FONT, true);
      _categoriesGrid->SetReadOnly(row, CATEGORY_DELETE, true);
      SET_ROW_COLOR(row, OWN_GREEN);
    }

  _wxUI->Layout();
  _wxUI->NeedReload();
  return;
}

void PreferencesPanel::OnChangeName(wxCommandEvent& event)
{ 
  User* user = _kiss->GetUser();
  wxString name = _name->GetLineText(0);

  if (name == user->_name)
    return;

  if (!name.size())
    {
      wxMessageBox(_("Invalid name"), _("Error"), wxICON_ERROR | wxOK);
      return;
    }

  if (_kiss->UserExists(name))
    {
      wxMessageBox(_("User ") + name + _(" already exists"), _("Error"), wxICON_ERROR | wxOK);
      return;
    }

  _kiss->ChangeName(name);

  wxMessageBox(_("Name changed"), wxT("KissCount"), wxICON_INFORMATION | wxOK);
  _wxUI->NeedReload();
  _wxUI->SetTitle(_kiss->GetUser()->_name + wxT(" - ") +_("Preferences"));
}

void PreferencesPanel::OnChangePassword(wxCommandEvent& event)
{  
  PasswordDialog p(_kiss, _wxUI);
  p.ShowModal();
}

void PreferencesPanel::OnShow(wxShowEvent& event)
{
  _wxUI->SetTitle(_kiss->GetUser()->_name + _(" - ") +_("Preferences"));
}

void PreferencesPanel::OnKillMe(wxCommandEvent& event)
{  
  User* user = _kiss->GetUser();

  wxMessageDialog dialog(_wxUI, _("Are you sure want to delete ")+user->_name+_(" profil ?"), wxT("KissCount"), wxYES_NO);
  if (dialog.ShowModal() == wxID_NO)
    {
      return;
    }

  _kiss->KillMe();
}