#include "tgrid.h"
#include "tw/colors.h"
#include "tw/event.h"
 
using namespace TwConsts;
 
//-------------------------------------------------------------------
 
class TGridColumn::Imp {
public:
  vector<TGridCell> m_cells;
  string m_name;
  TGridColumn::Alignment m_alignment;
 
  Imp(const string &name, Alignment alignment)
      : m_name(name), m_alignment(alignment) {}
 
  ~Imp() {}
 
  Imp &operator=(const Imp &src) {
    m_cells = src.m_cells;
    return *this;
  }
 
private:
  // not implemented
  Imp(const Imp &);
};
 
//-------------------------------------------------------------------
 
TGridColumn::TGridColumn(const string &name, Alignment alignment)
    : m_imp(new Imp(name, alignment)) {}
 
TGridColumn::~TGridColumn() { delete m_imp; }
 
TGridColumn *TGridColumn::createEmpty() { return new TGridColumn(); }
 
int TGridColumn::getRowCount() const { return m_imp->m_cells.size(); }
 
const TGridCell &TGridColumn::getCell(int row) const {
  assert(row >= 0 && row < (int)m_imp->m_cells.size());
  return m_imp->m_cells[row];
}
 
void TGridColumn::setCell(int row, const TGridCell &cell) {
  assert(m_imp);
  assert(row >= 0);
 
  // checkColumn();
 
  int firstRow = 0;
  if (m_imp->m_cells.empty())  // se la colonna e' vuota
  {
    //    if(!cell.isEmpty())
    {
      m_imp->m_cells.push_back(cell);
      firstRow = row;
    }
    return;
  }
 
  int oldCellCount = m_imp->m_cells.size();
  assert(oldCellCount > 0);
  int lastRow = firstRow + oldCellCount - 1;
 
  if (row < firstRow)  // prima
  {
    //    if(cell.isEmpty()) return; //non faccio nulla
    int delta = firstRow - row;
    assert(delta > 0);
    m_imp->m_cells.insert(m_imp->m_cells.begin(), delta - 1,
                          TGridCell());  // celle vuote
    m_imp->m_cells.insert(m_imp->m_cells.begin(),
                          cell);  // devo settare la prima comp. del vettore
    firstRow = row;               // row 'e la nuova firstrow
    //    updateIcon();
    //    checkColumn();
    return;
  } else if (row > lastRow)  // dopo
  {
    //    if(cell.isEmpty()) return; //non faccio nulla
    int count = row - lastRow - 1;
    // se necessario, inserisco celle vuote
    for (int i = 0; i < count; ++i) m_imp->m_cells.push_back(TGridCell());
    m_imp->m_cells.push_back(cell);
    //    checkColumn();
    return;
  }
  //"[r0,r1]"
  int index = row - firstRow;
  assert(0 <= index && index < (int)m_imp->m_cells.size());
  m_imp->m_cells[index] = cell;
  //  if(index == 0) updateIcon();
 
  /*
if(cell.isEmpty())
{
if(row==lastRow)
{
// verifico la presenza di celle bianche alla fine
while(!m_imp->m_cells.empty() && m_imp->m_cells.back().isEmpty())
  m_imp->m_cells.pop_back();
}
else
if(row==firstRow)
{
// verifico la presenza di celle bianche all'inizio
while(!m_imp->m_cells.empty() && m_imp->m_cells.front().isEmpty())
{
 m_imp->m_cells.erase(m_imp->m_cells.begin());
 firstRow++;
}
}
 
if(m_imp->m_cells.empty())
firstRow = 0;
}
checkColumn();
*/
}
 
void TGridColumn::getCells(int row, int rowCount, TGridCell cells[]);
void TGridColumn::setCells(int row, int rowCount, const TGridCell cells[]);
 
void TGridColumn::insertEmptyCells(int row, int rowCount) {
  assert(m_imp);
  if (m_imp->m_cells.empty())
    return;  // se la colonna e' vuota non devo inserire celle
 
  int firstRow = 0;
  if (row >= firstRow + (int)m_imp->m_cells.size())
    return;             // dopo:non inserisco nulla
  if (row <= firstRow)  // prima
  {
    firstRow += rowCount;
  } else  // in mezzo
  {
    int delta                           = row - firstRow;
    std::vector<TGridCell>::iterator it = m_imp->m_cells.begin();
    std::advance(it, delta);
    m_imp->m_cells.insert(it, rowCount, TGridCell());
  }
}
 
void TGridColumn::removeCells(int row, int rowCount) {
  if (rowCount <= 0) return;
  if (m_imp->m_cells.empty()) return;  // se la colonna e' vuota
  assert(m_imp);
 
  int firstRow  = 0;  // m_imp->m_first;
  int cellCount = m_imp->m_cells.size();
 
  if (row >= firstRow + cellCount) return;  // sono "sotto" l'ultima cella
  if (row < firstRow) {
    if (row + rowCount <= firstRow)  //"sono sopra la prima cella"
    {                                // aggiorno solo m_first
      firstRow -= rowCount;
      return;
    }
    rowCount += row - firstRow;  // rowCount = row+rowCount-firstRow;
    firstRow = row;
  }
 
  assert(row >= firstRow);
  // le celle sotto firstRow+cellCount sono gia' vuote
  if (rowCount > firstRow + cellCount - row)
    rowCount = firstRow + cellCount - row;
  if (rowCount <= 0) return;
 
  if (row == firstRow) {
    // cancello all'inizio
    assert(rowCount <= cellCount);
    std::vector<TGridCell>::iterator it  = m_imp->m_cells.begin();
    std::vector<TGridCell>::iterator it2 = m_imp->m_cells.begin();
    std::advance(it2, rowCount);
    // m_imp->m_cells.erase(&m_imp->m_cells[0],&m_imp->m_cells[rowCount]);
    m_imp->m_cells.erase(it, it2);
    // verifico la presenza di celle bianche all'inizio
    while (!m_imp->m_cells.empty() /*&& m_imp->m_cells.front().isEmpty()*/) {
      m_imp->m_cells.erase(m_imp->m_cells.begin());
      firstRow++;
    }
  } else {
    // cancello dopo l'inizio
    int d                                = row - firstRow;
    std::vector<TGridCell>::iterator it  = m_imp->m_cells.begin();
    std::vector<TGridCell>::iterator it2 = m_imp->m_cells.begin();
    std::advance(it, d);
    std::advance(it2, d + rowCount);
    // m_imp->m_cells.erase(&m_imp->m_cells[d],&m_imp->m_cells[d+rowCount]);
    m_imp->m_cells.erase(it, it2);
    if (row + rowCount == firstRow + cellCount) {
      // verifico la presenza di celle bianche alla fine
      while (!m_imp->m_cells.empty() /*&& m_imp->m_cells.back().isEmpty()*/) {
        m_imp->m_cells.pop_back();
      }
    }
  }
 
  if (m_imp->m_cells.empty()) {
    firstRow = 0;
  }
  // updateIcon();
}
 
void TGridColumn::clearCells(int row, int rowCount) {}
 
string TGridColumn::getName() const { return m_imp->m_name; }
 
TGridColumn::Alignment TGridColumn::getAlignment() const {
  return m_imp->m_alignment;
}
 
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
 
class TGrid::Data {
public:
  Data(TWidget *w)
      : m_w(w)
      , m_selAction(0)
      , m_dblClickAction(0)
      , m_scrollbar(new TScrollbar(w))
      , m_yoffset(0) {}
 
  ~Data() {
    if (m_selAction) delete m_selAction;
 
    if (m_dblClickAction) delete m_dblClickAction;
  }
 
  int posToRow(const TPoint &p);
 
  void updateScrollBarStatus() {
    if (!m_scrollbar) return;
    int ly = m_w->getLy();
 
    assert(m_columnSet.getColumnCount() > 0);
    TGridColumnP col = m_columnSet.getColumn(0);
 
    if ((col->getRowCount() * m_rowHeight) > ly)
      m_scrollbar->show();  // m_scrollbar->setValue(m_yoffset,0, yrange-ly,
                            // ly);
    else
      m_scrollbar->hide();  // m_scrollbar->setValue(0,0, 0, 0);
    m_scrollbar->invalidate();
  }
 
  TWidget *m_w;
 
  TColumnSetT<TGridColumn> m_columnSet;
 
  vector<int> m_selectedRows;
 
  TGenericGridAction *m_selAction;
  TGenericGridAction *m_dblClickAction;
  TScrollbar *m_scrollbar;
  int m_yoffset;
 
  bool m_colSeparatorDragged;
  int m_prevColSeparatorX;
  int m_colSeparatorX;
  int m_colIndex;
 
  static int m_rowHeight;
};
 
int TGrid::Data::m_rowHeight = 20;
 
int TGrid::Data::posToRow(const TPoint &p) {
  int y    = m_w->getSize().ly - p.y + m_yoffset;
  int item = y / m_rowHeight;
  return item;
}
 
//-------------------------------------------------------------------
//-------------------------------------------------------------------
 
TGrid::TGrid(TWidget *parent, string name) : TWidget(parent, name), m_data(0) {
  m_data = new Data(this);
  m_data->m_scrollbar->setAction(
      new TScrollbarAction<TGrid>(this, &TGrid::scrollTo));
 
  // setBackgroundColor(White);
}
 
//-------------------------------------------------------------------
 
TGrid::~TGrid() { delete m_data; }
 
//-------------------------------------------------------------------
 
void TGrid::addColumn(const string &name, int width,
                      TGridColumn::Alignment align) {
  TGridColumnP column = new TGridColumn(name, align);
  column->setWidth(width);
  m_data->m_columnSet.insertColumn(m_data->m_columnSet.getColumnCount(),
                                   column);
}
 
//-------------------------------------------------------------------
 
void TGrid::addRow() {
  int colCount = m_data->m_columnSet.getColumnCount();
  for (int i = 0; i < colCount; ++i) {
    TGridColumnP col = m_data->m_columnSet.getColumn(i);
    col->setCell(col->getRowCount(), "");
  }
}
 
//-------------------------------------------------------------------
 
void TGrid::removeRow(int row) {
  int colCount = m_data->m_columnSet.getColumnCount();
  for (int i = 0; i < colCount; ++i) {
    TGridColumnP col = m_data->m_columnSet.getColumn(i);
    col->removeCells(row);
  }
}
 
//-------------------------------------------------------------------
 
int TGrid::getColIndex(const string &colName) {
  int colCount = m_data->m_columnSet.getColumnCount();
  for (int i = 0; i < colCount; ++i) {
    TGridColumnP col = m_data->m_columnSet.getColumn(i);
    if (colName == col->getName()) return i;
  }
 
  return -1;
}
 
//-------------------------------------------------------------------
 
void TGrid::setCell(int row, int col, const string &text) {
  assert(row >= 0 && col >= 0);
  TGridColumnP column = m_data->m_columnSet.touchColumn(col);
  column->setCell(row, TGridCell(text));
}
 
//-------------------------------------------------------------------
 
int TGrid::getColCount() const { return m_data->m_columnSet.getColumnCount(); }
 
//-------------------------------------------------------------------
 
int TGrid::getRowCount() const {
  assert(m_data->m_columnSet.getColumnCount() > 0);
  TGridColumnP col = m_data->m_columnSet.getColumn(0);
  return col->getRowCount();
}
 
//-------------------------------------------------------------------
 
int TGrid::getSelectedRowCount() const { return m_data->m_selectedRows.size(); }
 
//-------------------------------------------------------------------
 
int TGrid::getSelectedRowIndex(int i) const {
  assert(i >= 0 && i < (int)m_data->m_selectedRows.size());
  return m_data->m_selectedRows[i];
}
 
//-------------------------------------------------------------------
 
void TGrid::select(int row, bool on) {
  assert(row >= 0 && row < (int)getRowCount());
  std::vector<int>::iterator it = std::find(m_data->m_selectedRows.begin(),
                                            m_data->m_selectedRows.end(), row);
  if (on) {
    if (it == m_data->m_selectedRows.end())
      m_data->m_selectedRows.push_back(row);
  } else {
    if (it != m_data->m_selectedRows.end()) m_data->m_selectedRows.erase(it);
  }
  if (m_data->m_selAction) m_data->m_selAction->sendCommand(row);
 
  invalidate();
}
 
//-------------------------------------------------------------------
 
void TGrid::unselectAll() {
  m_data->m_selectedRows.clear();
  invalidate();
}
 
//-------------------------------------------------------------------
 
bool TGrid::isSelected(int row) const {
  std::vector<int>::iterator it = std::find(m_data->m_selectedRows.begin(),
                                            m_data->m_selectedRows.end(), row);
 
  return it != m_data->m_selectedRows.end();
}
 
//-------------------------------------------------------------------
 
void TGrid::scrollTo(int y) {
  if (m_data->m_yoffset == y) return;
  m_data->m_yoffset = y;
  invalidate();
}
 
//------------------------------------------------------------------------------
 
void TGrid::draw() {
  TDimension size = getSize();
 
  // TRect gridHeaderPlacement(TPoint(0,size.ly-1), TDimension(size.lx-1,
  // -m_data->m_rowHeight));
 
  TRect gridHeaderPlacement(0, size.ly - 1 - m_data->m_rowHeight, size.lx - 1,
                            size.ly - 1);
 
  setColor(Gray180 /*White*/);
  fillRect(gridHeaderPlacement);
 
  int gridHeaderY0 = gridHeaderPlacement.getP00().y;
 
  for (int i = 0; i < m_data->m_columnSet.getColumnCount(); ++i) {
    TGridColumnP col = m_data->m_columnSet.getColumn(i);
    int x0, x1;
    col->getCoords(x0, x1);
 
    // draw column header
    setColor(Black);
    drawText(
        TRect(x0, gridHeaderY0, x1, gridHeaderY0 + m_data->m_rowHeight - 1),
        col->getName());
 
    int rowY = gridHeaderY0;  // - m_data->m_rowHeight;
 
    int y = size.ly - 1 - m_data->m_rowHeight;
    for (int j = m_data->m_yoffset / m_data->m_rowHeight;
         j < col->getRowCount() && y; ++j, y -= m_data->m_rowHeight) {
      drawHLine(TPoint(0, rowY), size.lx);
 
      TRect cellRect(x0, rowY - m_data->m_rowHeight - 1, x1, rowY);
 
      if (isSelected(j)) {
        setColor(Blue, 1);
        fillRect(cellRect);
      }
 
      setColor(Black);
 
      TWidget::Alignment align = TWidget::CENTER;
      switch (col->getAlignment()) {
      case TGridColumn::CenterAlignment:
        align = TWidget::CENTER;
        break;
      case TGridColumn::RightAlignment:
        align = TWidget::END;
        break;
 
      case TGridColumn::LeftAlignment:
        align = TWidget::BEGIN;
        break;
      }
 
      drawText(cellRect, col->getCell(j).m_text, align);
 
      rowY -= m_data->m_rowHeight;
    }
 
    setColor(Gray210);
    drawVLine(TPoint(x0, 0), size.ly);
    drawVLine(TPoint(x1, 0), size.ly);
  }
 
  if (m_data->m_colSeparatorDragged) {
    drawVLine(TPoint(m_data->m_colSeparatorX, 0), size.ly);
  }
}
 
//-------------------------------------------------------------------
 
void TGrid::configureNotify(const TDimension &d) {
  m_data->m_scrollbar->setGeometry(d.lx - 20, 1, d.lx - 2, d.ly - 2);
  m_data->updateScrollBarStatus();
}
 
//-------------------------------------------------------------------
 
void TGrid::leftButtonDown(const TMouseEvent &e) {
  m_data->m_colSeparatorDragged = false;
  int rowCount                  = getRowCount();
 
  int i = m_data->posToRow(e.m_pos);
  if (i == 0) {
    // la riga 0 e' l'header della tabella
 
    for (int j = 0; j < m_data->m_columnSet.getColumnCount(); ++j) {
      TGridColumnP col = m_data->m_columnSet.getColumn(j);
      int x0, x1;
      col->getCoords(x0, x1);
      if (x0 - 3 < e.m_pos.x && e.m_pos.x < x0 + 3) {
        m_data->m_colSeparatorDragged = true;
        m_data->m_colSeparatorX       = x0;
        m_data->m_prevColSeparatorX   = x0;
        m_data->m_colIndex            = j;
      }
    }
  } else {
    i--;
    if (i >= 0 && i < (int)rowCount) {
      if (!e.isShiftPressed()) unselectAll();
      select(i, !isSelected(i));
    }
  }
}
 
//-------------------------------------------------------------------
 
void TGrid::leftButtonDrag(const TMouseEvent &e) {
  if (m_data->m_colSeparatorDragged) {
    m_data->m_colSeparatorX += (e.m_pos.x - m_data->m_prevColSeparatorX);
    m_data->m_prevColSeparatorX = e.m_pos.x;
    invalidate();
  }
}
 
//-------------------------------------------------------------------
 
void TGrid::leftButtonUp(const TMouseEvent &e) {
  if (m_data->m_colSeparatorDragged) {
    TGridColumnP col0 = m_data->m_columnSet.getColumn(m_data->m_colIndex - 1);
    TGridColumnP col1 = m_data->m_columnSet.getColumn(m_data->m_colIndex);
 
    int col0X0, col0X1;
    col0->getCoords(col0X0, col0X1);
 
    int newWidth = m_data->m_colSeparatorX - col0X0;
    int totWidth = col0->getWidth() + col1->getWidth();
 
    col0->setWidth(newWidth);
    col1->setWidth(totWidth - newWidth);
 
    m_data->m_colSeparatorDragged = false;
    invalidate();
  }
}